Rendimiento decepcionante en Ubuntu para la carga de trabajo computacional

Question

He encontrado un rendimiento bastante pobre ejecutando algún código computacional en Ubuntu en una nueva máquina de estación de trabajo sin cabeza que estoy usando para el cálculo científico. Noté una diferencia en la velocidad al ejecutar un código ligeramente complejo en Ubuntu en comparación con mi viejo portátil Mac que uso para el desarrollo. Sin embargo, me las he arreglado para destilar abajo a un increíblemente sencillo ejemplo que todavía exhibe menos de stelar mejoras con respecto a mi vieja máquina:

#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); 
} 

Ahora el Mac es una de casi 5 años de edad de 2,4 GHz Core 2 Duo MacBook Pro ejecutando OS X 10.5 que ejecuta este código en aproximadamente 6.8 segundos. Sin embargo, en un nuevo Dell Core i7 de 3.4GHz que ejecuta Ubuntu 11.10, ¡tarda aproximadamente 6.1 segundos! ¿Puede alguien aclararme qué está pasando aquí, porque es absurdo que una laptop de casi 5 años esté dentro del 10% de una nueva estación de trabajo de escritorio? ¡Es aún más absurdo porque puedo ver que el Core i7 turboalimenta a casi 4GHz con herramientas de monitoreo!

Mac compilado con:

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

Ubuntu compilado con:

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

Gracias,

Louis

Answer 1

es absurdo que un viejo ordenador portátil casi 5 años es de dentro del 10% de una nueva estación de trabajo de escritorio

Tenga en cuenta que usted está benchmarking una función específica (exp). Realmente no sabemos si las dos implementaciones de la función exp() que está evaluando son idénticas (no es inconcebible que una esté mejor optimizada que la otra).

Si tuviera que comparar una función diferente, los resultados podrían ser bastante diferentes (quizás más en línea con sus expectativas, o no).

Si exp() es realmente el cuello de botella de su aplicación real, una posibilidad es considerar el uso de una aproximación rápida. Aquí hay un documento que ofrece una de estas aproximaciones: A Fast, Compact Approximation of the Exponential Function.

Answer 2

Estás comparando manzanas y naranjas, para Mac permites optimizaciones específicas de la arquitectura que no utilizas para ubuntu. Use -O3 -march=native en ambos para tener una comparación justa.

Answer 3

Algunas cosas para probar:

• Asegúrese de que su CPU está en RUN fijo en su máxima velocidad durante el experimento. Se puede alternar arriba y hacia abajo, lo que añade un montón de gastos generales
• Pin el programa de prueba a un núcleo usando taskset, por lo que el planificador del sistema operativo no migra alrededor

Answer 4

Como otros, que' simplemente comparando una implementación de la biblioteca matemática de exp() con otra. Si necesita bibliotecas matemáticas de alta calidad en Linux, le sugiero que consulte las herramientas de compilación de Intel (que vienen con un excelente conjunto de bibliotecas); también están disponibles para OS X y Windows.

Answer 5

la diferencia en el número de ciclos de CPU es solo del 30%. Dado que no sabemos exactamente qué código generó el compilador, no diría que es absurdo. La mayor parte de la ganancia de rendimiento con su nueva CPU es la cantidad de núcleos, y su código no hace uso de eso.

También puede ser interesante intentar y desenrollar el ciclo. La relación de velocidad puede cambiar.

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); 
} 

Answer 6

intente encender la opción -ffast-math. Esto podría darle una implementación menos pedante y correcta de exp(). La pregunta entonces es si desea la respuesta potencialmente incorrecta que puede producir.