omp parallèle pour la boucle (réduction pour trouver max) a couru plus lentement que les codes série

Question

Je suis nouveau dans l'utilisation d'OpenMP. Je pense que l'utilisation de la clause max reduction pour trouver l'élément max d'un tableau n'est pas une si mauvaise idée, mais en fait la parallèle pour la boucle a fonctionné beaucoup plus lentement que la série.

int main() { 
double sta, end, elapse_t; 
int bsize = 46000; 
int q = bsize; 
int max_val = 0; 
double *buffer; 
buffer = (double*)malloc(bsize*sizeof(double)); 
srand(time(NULL)); 
for(int i=0;i<q;i++) 
    buffer[i] = rand()%10000; 

sta = omp_get_wtime(); 
//int i; 
#pragma omp parallel for reduction(max : max_val) 
for(int i=0;i<q; i++) 
{ 
    max_val = max_val > buffer[i] ? max_val : buffer[i]; 
} 
end = omp_get_wtime(); 
printf("parallel maximum time %f\n", end-sta); 

sta = omp_get_wtime(); 
for(int i=0;i<q; i++) 
{ 
    max_val = max_val > buffer[i] ? max_val : buffer[i]; 
} 
end = omp_get_wtime(); 
printf("serial maximum time %f\n", end-sta); 

free(buffer); 
return 0;} 

Compile commande

gcc-7 kp_omp.cpp -o kp_omp -fopenmp 

exécution résulte

./kp_omp 
parallel maximum time 0.000505 
serial maximum time 0.000266 

En ce qui concerne le processeur, il est un processeur Intel Core i7-6700 avec 8 cœurs.

Answer 1

Chaque fois que vous parallélisez une boucle, openMP doit effectuer certaines opérations, par exemple créer les unités d'exécution. Ces opérations entraînent une surcharge, ce qui à son tour implique que, pour chaque boucle, il existe un nombre minimum d'itérations sous lesquelles il n'est pas pratique de paralléliser.

Si j'exécute votre code-je obtenir les mêmes résultats que vous avez:

./kp_omp 
parallel maximum time 0.000570 
serial maximum time 0.000253 

Cependant, si je modifie bsize en ligne 8 telle que

int bsize = 100000; 

-je obtenir

./kp_omp 
parallel maximum time 0.000323 
serial maximum time 0.000552 

La version parallélisée est donc plus rapide que la version séquentielle. Une partie des défis que vous rencontrez lorsque vous essayez d'accélérer l'exécution d'un code est de comprendre quand il est pratique de paralléliser et quand la surcharge de la parallélisation va tuer votre gain de performance attendu.