"Magical" intel c++ compiler : what happened?

Question

I am on *nix. Have this simple c++ code in looptest.cpp

#include <iostream>
#include <time.h>

int main()
{
      double sum = 0.0;
      int n ;
      std::cout << "n ?" << std::endl;
      std::cin >> n ;
      clock_t t_start = clock();
      for (int i = 0 ; i < n ; ++i)
      {
            sum+= static_cast<double>(i);
      }
      clock_t t_end = clock();
      clock_t diff = t_end - t_start;
      double diffd = static_cast<double>(diff)/CLOCKS_PER_SEC;
      std::cout << diffd << " seconds." << std::endl;
      sum*=1.0;
      return 0;
}

compiled with the intel c++ compiler (icpc (ICC) 14.0.4 20140805, 2013) as follows :

/opt/intel/bin/icpc looptest.cpp -o looptest

When I test it, I have the following curious result :

My-MacBook-Air:tmp11 XXXX$ ./looptest 
n ?
10000
4e-06 seconds.
My-MacBook-Air:tmp11 XXXX$ ./looptest 
n ?
100000
3e-06 seconds.
My-MacBook-Air:tmp11 XXXX$ ./looptest 
n ?
1000000
3e-06 seconds.
My-MacBook-Air:tmp11 XXXX$ ./looptest 
n ?
1000000000
2e-06 seconds.
My-MacBook-Air:tmp11 XXXX$ ./looptest 
n ?
4294967295
3e-06 seconds.

Strange, isn't it ? What happened here ? Of course, compiling with gnu-5.2's g++ instead of icpc gives an expected result (time increasing when n increases.)

Answer 1

sum is nowhere read, so all assignments to the variable were removed. This made the for-loop empty, so it was removed, too. Hence what remains is:

#include <iostream>
#include <time.h>

int main()
{
      int n ;
      std::cout << "n ?" << std::endl;
      std::cin >> n ;
      clock_t t_start = clock();
      clock_t t_end = clock();
      clock_t diff = t_end - t_start;
      double diffd = static_cast<double>(diff)/CLOCKS_PER_SEC;
      std::cout << diffd << " seconds." << std::endl;
      return 0;
}

Effectively you measure how fast a single call to clock() is.

Look at the compiled code to figure out the optimizations the compiler did. GCC "should" be able to do the same optimization, but it will only do it if you add the parameter -O (-O2, -O3, -Os) to the invocation.