¿Por qué la versión OpenMP es más lenta?

Question

Estoy experimentando con OpenMP. Escribí un código para verificar su rendimiento. En una CPU Intel de 4 núcleos única con Kubuntu 11.04, el siguiente programa compilado con OpenMP es alrededor de 20 veces más lento que el programa compilado sin OpenMP. ¿Por qué?

He compilado por g ++ -g -O2 -funroll-bucles -march -fomit-frame-pointer = -fopenmp nativa

#include <math.h> 
#include <iostream> 

using namespace std; 

int main() 
{ 
    long double i=0; 
    long double k=0.7; 

    #pragma omp parallel for reduction(+:i) 
    for(int t=1; t<300000000; t++){  
    for(int n=1; n<16; n++){ 
     i=i+pow(k,n); 
    } 
    } 

    cout << i<<"\t"; 
    return 0; 
} 

Answer 1

El problema es que la variable k es considerado como una variable compartida , por lo que debe sincronizarse entre los hilos. Una posible solución para evitar esto es:

#include <math.h> 
#include <iostream> 

using namespace std; 

int main() 
{ 
    long double i=0; 

#pragma omp parallel for reduction(+:i) 
    for(int t=1; t<30000000; t++){  
    long double k=0.7; 
    for(int n=1; n<16; n++){ 
     i=i+pow(k,n); 
    } 
    } 

    cout << i<<"\t"; 
    return 0; 
} 

Tras el toque de Martin Beckett en el comentario más abajo, en lugar de declarar k dentro del bucle, también se puede declarar k const y fuera del bucle.

De lo contrario, ejd es correcto: aquí el problema no parece una mala paralelización, sino una mala optimización cuando el código se paraleliza. Recuerde que la implementación OpenMP de gcc es bastante joven y dista de ser óptima.

Answer 2

código más rápido:

for (int i = 0; i < 100000000; i ++) {;} 

código ligeramente más lento: Código

#pragma omp parallel for num_threads(1) 
for (int i = 0; i < 100000000; i ++) {;} 

2-3 veces más lento:

#pragma omp parallel for 
for (int i = 0; i < 100000000; i ++) {;} 

no importa lo que está entre {y}. Un simple ; o un cálculo más complejo, los mismos resultados. Recopilé bajo Ubuntu 13.10 de 64 bits, usando tanto gcc como g ++, probando diferentes parámetros -ansi -pedantic-errors -Wall -Wextra -O3, y ejecutándome en un Intel quad-core de 3.5GHz.

Supongo que la sobrecarga de administración de subprocesos tiene la culpa? No parece inteligente para OMP crear un hilo cada vez que lo necesite y destruirlo después. Pensé que habría cuatro (u ocho) hilos ejecutándose cuando fuera necesario o durmiendo.

Answer 3

Estoy observando un comportamiento similar en GCC. Sin embargo, me pregunto si en mi caso está relacionado de alguna manera con la plantilla o la función en línea. ¿Su código también está dentro de la plantilla o en la función en línea? Por favor mira here.

Sin embargo, para muy corto para los bucles, se puede observar una pequeña sobrecarga relacionada con hilo de conmutación como en su caso:

#pragma omp parallel for 
for (int i = 0; i < 100000000; i ++) {;} 

Si el bucle se ejecuta para algunas de gravedad mucho tiempo como pocos ms o incluso segundos, se debería observar el aumento de rendimiento cuando se usa OpenMP. Pero solo cuando tienes más de una CPU. Cuantos más núcleos tenga, mayor rendimiento alcanzará con OpenMP.