Discussion :

[azmodai]

Bonjour,

Je souhaiterais paralléliser une boucle for toute simple, habituellement je n'ai aucun problème et j'obtiens bien un facteur d'accélération proche du nombre de cores utilisés.

Cette fois-ci je bute sur un petit problème, mon code est plus lent en étant parallélisé, en rajoutant l'option reduction(+,mavar) j'ai les mêmes performances qu'en séquentiel.... J'ai essayé un ensemble d'options qui me paraissaient corhérentes, mais je n'obtiens jamais de meilleurs performances ...

Je viens à vous car je souhaterais un conseil de votre part pour que mon partage de calcul se fasse correctement avec le moi d'overhead possible.

Voici mon code d'origine :

nbrExamples = environ 14.000 dans mon cas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
for(e = 0 ; e < nbrExamples ; e++)
		{
			//cout << "current thread : " << omp_get_thread_num() <<endl;	
 
			int h = 0;
 
			//start at the root
 
			const int response_one = *(featuresResponsesPtrOffset + e);
			const int response_left = *(featuresResponsesPtrOffsetLeft + e); 
			const int response_right = *(featuresResponsesPtrOffsetRight +e);
 
			// left
			if(response_one < current->threshold)    
			{
				if(current->left->alpha > 0)
				{
                			if(response_left < current->left->threshold) { h = 1; }
                			else { h = -1; }
            			}
            			else
            			{
                			if(response_left >= current->left->threshold) { h = 1; }
                			else { h = -1; }
            			}
			}       	
			else
			{
				if(current->right->alpha > 0)
				{
                			if(response_right < current->right->threshold) { h = 1; }
                			else { h = -1; }
            			}
            			else
            			{
                			if(response_right >= current->right->threshold) { h = 1; }
                			else { h = -1; }
            			}
			}
 
 
 
				ui[e] = (labels[e]) ? 1 * h : -1 * h;
 
 
			r += weights[e]*ui[e];			
 
		}

un simple #pragma parallel for fait ralentir considérablement l'éxecution,
un #pragma parallel for reduction(+:r) me ramène à des temps de calculs similaires à ce que j'obtiens en séquentiel (environ 12sec).

Pensez-vous que mon problème soit sous-dimensionné ? Je passe environ 12sec sur cette partie ...

Une observation cependant, pour l'option schedule(synamic, chunk), si chunk =1, mon temps de calcul passe à 90 secondes !

Merci !

[oodini]

N'y a-t-il pas une situation de concurrence sur l'accès à la variable r ?