Question

I have written a function that sorts a big scale of data. To test its performance, I compared it with qsort. If I compile it on my desktop which is running FreeBSD with GCC 4.2.2, the result is that qsort taking less time than my function. However, I compiled it on a server which is running RedHat with GCC 4.1.2, the result is that my function takes less time than qsort.

I am confused about whether my function is better than qsort or not. Could someone help me explain this strange situation?

I have tested it a lot of times using the same CFLAGS, running it in same machine and all the other same conditions except the different functions.

My code:

 53 int
 54 main(void)
 55 {
 56     int * array_first, * array_next;
 57     int len = 1000000;
 58     int i;
 59     struct timeval start, duration;
 60 
 61 
 62 
 63     array_first = malloc(sizeof(int) * len);
 64     array_next = malloc(sizeof(int) * len);
 65 
 66 
 67     for(i = 0; i < len; i++){
 68         *(array_first + i) = rand() % 1000;
 69         *(array_next + i) = *(array_first + i);
 70     }
 71 
 72     set_starttime(&start);
 73     quicksort(array_first, len, sizeof(int), compar);
 74     get_runningtime(start, &duration);
 75     printf("%lu\n", duration.tv_sec * MICRO_PER_SEC + duration.tv_usec);
 76     set_starttime(&start);
 77     qsort(array_next, len, sizeof(int), compar);
 78     get_runningtime(start, &duration);
 79     printf("%lu\n", duration.tv_sec * MICRO_PER_SEC + duration.tv_usec);
 80 
 81     assert(memcmp(array_first, array_next, sizeof(int) * len) == 0);
 82 
 83     free(array_first);
 84     free(array_next);
 85 
 86     return 0;
 87 }
 88 

Answer 1

There could be many many reasons why the performances are different.

• Implementation of qsort could be different in the two systems, one happens to suite your test-case better
• If test-cases are generated randomly, you could have just got unlucky with one test case
• Compiling your code with different compiler versions, means different optimizations are done that change the performance of your code
• Running the tests on different systems means that there would be different performances in the same code. On one architecture with a certain test-case, the cache may be marginally misused, while on another architecture with bigger cache this is not issue.

I could think of a 100 hundred other reasons, but this should be enough to let you know you shouldn’t try making such a comparison.