(e-mail address removed) wrote:
....
int main(char *argv[], int argc) {
/*
int a, b, c, d, e;
for (int i = 0; i < 1000000000; i++) {
a = 1;
b = 2;
c = 3;
d = 4;
e = 5;
}
*/
int a[5];
for (int i = 0; i < 1000000000; i++) {
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
a[4] = 5;
}
return 0;
}
The first (commented out) version ran twice as fast. (For doubles
instead of ints, it was a factor of 4). So the simpleton part of me
thinks that that answers my question. The remaining part tells me that
it is never that simple.
Right, there's no point in assigning values to variables if you never use
the value. So even if the compiler generates the sort of code you expect
you are only measuring half of the problem at best.
Probably. Compilers can also be quite good at "optimising" pointless
operations. However it is easier for compilers to track usage of
individual variables than arrays. Your compiler may simply be optimising
the useless code in the first case better than the useless code in the
second. The situation when the values are used could be quite different.
If you need an indexed lookup for the values put them in an array, if
your code accesses the values directly and independently then don't.
First of all, your implementation does 1000000000-1 completely
unnecessary steps. You are assigning the same values to the same
variables a billion times. It's most probably that your compiler will
optimize the 999,999,999 unneeded iterations away... So this example
isn't a very good start to check for efficiency.
Although many compiler writers take the view that if you didn't want a
loop you could have written the code without one. So removing a loop
altogether is an optimisation they deliberately choose not to implement.
Second, as far as I can tell, the second version runs slower because you
need to dereference a pointer 5 billion times.
The expression:
a[2] = 3;
is analogous to:
*(a+2) = 3;
That appears to be the case at the source level, but if you think about it
a[2] just represents an int object in memory in much the same way as the
variable name c does. It is entirely possible for the code generated to
access them (i.e. using a constant index like this) to be identical. Or to
put it another way consider
int a;
*&a = 1;
which is very similar to what you are doing with
int a[1];
a[0] = 1;
The use of an array name in a context like this creates an address, so
loosely speaking there is an implicit & in a[0] as well as an implicit *.
However you look at it this is something that a compiler is likely to
generate reasonable code for.
Lawrence
