Disappointing performance in Ubuntu for computational workload

Question

I've found rather poor performance running some computational code under Ubuntu on a brand new headless workstation machine I'm using for scientific computation. I noticed a difference in speed running some slightly complex code on Ubuntu versus on my old Mac laptop which I use for development. However, I've managed to distill it down to an incredibly simple example which still exhibits less than stelar improvements over my old machine:

#include <stdio.h>
#include <math.h>

int main() {
        double res = 0.0;
        for(int i=1; i<200000000; i++) {
                res += exp((double) 100.0/i);
        }
        printf("%lf", res);
        return(0);
}

Now the Mac is a nearly 5 year old 2.4GHz Core 2 Duo MacBook Pro running OS X 10.5 which runs this code in about 6.8 secs. However, on a brand new 3.4GHz Core i7 Dell running Ubuntu 11.10 it takes about 6.1 secs! Can someone enlighten me as to what is going on here, because it is absurd that a nearly 5 year old laptop is within 10% of a brand new desktop workstation? It is even more absurd because I can see the Core i7 turbo-boosting to nearly 4GHz with monitoring tools!

Mac compiled with:

gcc -o test test.c -std=gnu99 -arch x86_64 -O2

Ubuntu compiled with:

gcc -o test test.c -std=gnu99 -m64 -O2 -lm

Thanks,

Louis

Answer 1

it is absurd that a nearly 5 year old laptop is within 10% of a brand new desktop workstation

Bear in mind that you are benchmarking one specific function (exp). We don't really know if the two implementations of the exp() function that you're benchmarking are identical (it is not inconceivable that one is better optimized than the the other).

If you were to benchmark a different function, the results could be quite different (perhaps more in line with your expectations; or not).

If exp() is really the bottleneck of your actual application, one possibility is to look into using a fast approximation. Here is a paper that offers one such approximation: A Fast, Compact Approximation of the Exponential Function.

Answer 2

As others noted, you're simply benchmarking one math library implementation of exp( ) against another. If you need high-quality math libraries on Linux, I would suggest looking at Intel's compiler tools (which come with an excellent set of libraries); they are also available for OS X and Windows.

Answer 3

Try turning on the -ffast-math option. This might give you a much less pedantically correct implementation of exp(). The question then is whether you want the potentially wrong answer that can produce.

Answer 4

You are comparing apples and oranges, for Mac you allow for architecture specific optimizations which you don't for ubuntu. Use -O3 -march=native on both to have a fair comparison.

Answer 5

A few things to try:

• Make sure your CPU is set to run fixed at its full speed during the experiment. It may be toggling up and down, which adds a lot of overhead
• Pin the test program to one core using taskset, so that the OS scheduler doesn't migrate it around

Answer 6

the difference in number of cpu cycles is just 30%. Given that we don't know exactly what code the compiler generated I would not say it's absurd. Most of the performance gain with your new cpu is the number of cores, and your code does not make use of that.

It may also be interesting to try and unroll the loop. The speed ratio may change.

int main() {
    double res0 = 0.0;        
    double res1 = 0.0;        
    double res2 = 0.0;        
    double res3 = 0.0;        
    double res4 = 0.0;        
    for(int i=1; i<200000000; i+=5) {
            res0 += exp((double) 100.0/i);
            res1 += exp((double) 100.0/(i+1));
            res2 += exp((double) 100.0/(i+2));
            res3 += exp((double) 100.0/(i+3));
            res4 += exp((double) 100.0/(i+4));
    }
    double res=res0+res1+res2+res3+res4;
    printf("%lf", res);
    return(0);
}