Why does this run in no time? - c++

Question

I was benchmarking arrays, vectors, boost::array on different compilers on Windows and Linux. I ran into the following strange thing.
I have gcc 4.7.2 on Linux 3.7.0.7, with flags:
g++ -O3 -g -Wall -c -fmessage-length=0 -std=c++11 -MMD -MP -MF"main.d" -MT"main.d" -o "main.o" "../main.cpp"
And this code:
const int arrLength = 5;
int a[arrLength];
for (int i = 0; i < arrLength; i++) {
a[i] = i * 5;
}
srand(time(0)); // randomise at run time so it cannot be precomputed by the compiler
int numbers[10];
for (auto &i : numbers)
i = rand();
clock_t c;
c = clock();
for (int i = 0; i < 100000000; i++) {
for (int j = 0; j < arrLength; j++)
a[j] += numbers[j%10];
}
// write it out so the compiler doesn't omit the whole operation if the values in the array are not being used
for (int x : a)
cout << x;
cout << endl;
cout << (float) (clock() - c) << endl;
It actually runs in 0 seconds... how can this happen?

Answer 1

My compiler just computes the final result. Here's my annotated source code:
asm volatile("DEBUG_IN");
for (int i = 0; i < 100000000; i++)
{
for (int j = 0; j < arrLength; j++)
{
a[j] += numbers[j % 10];
}
}
asm volatile("DEBUG_OUT");
The invocation is g++ -std=c++11 -O3 -S -masm=intel.
The result:
#APP
# 21 "/tmp/x.cpp" 1
DEBUG_IN
# 0 "" 2
#NO_APP
mov ecx, DWORD PTR [esp+60]
imul edi, DWORD PTR [esp+56], 100000000
mov eax, DWORD PTR [esp+64]
mov edx, DWORD PTR [esp+68]
mov DWORD PTR [esp+36], edi
imul edi, ecx, 99999999
lea ecx, [ecx+5+edi]
mov DWORD PTR [esp+40], ecx
imul ecx, eax, 99999999
lea eax, [eax+10+ecx]
mov DWORD PTR [esp+44], eax
imul eax, edx, 99999999
lea eax, [edx+15+eax]
mov edx, DWORD PTR [esp+72]
mov DWORD PTR [esp+48], eax
imul eax, DWORD PTR [esp+72], 99999999
lea eax, [edx+20+eax]
mov DWORD PTR [esp+52], eax
#APP
# 31 "/tmp/x.cpp" 1
DEBUG_OUT
# 0 "" 2
#NO_APP
As you can see, there are just five simple assignments. Note that [esp+36] to [esp+52] refer to the respective elements of numbers.