OpenMP ralentit au lieu de booster
Hello,
J'ai fait un programme graphique que je souhaite optimiser. Je me suis donc intéresse à OpenMP (pour dire que j'y connais pas grand chose).
Voila la partie du code que j'ai parallélisé:
Code:
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
50
51
52
53
54
55
56
57
58
59
|
void incrementation(Planete* A, int nmb)
{
int i;
int l;
float truc1;
float truc2;
float truc3;
float distance;
for(l=0;l<=nmb-1;l++)
{
truc1=0;
truc2=0;
truc3=0;
distance=0;
#pragma omp parallel for
for(i=0;i<=nmb-1;i++)
{
if(!(i==l))
{
distance=(A[i].x_now-A[l].x_now)*(A[i].x_now-A[l].x_now)+(A[i].y_now-A[l].y_now)*(A[i].y_now-A[l].y_now)+(A[i].z_now-A[l].z_now)*(A[i].z_now-A[l].z_now);
truc1=truc1+(G*A[i].masse*(A[i].x_now-A[l].x_now))/((distance+1)*sqrt(distance));
truc2=truc2+(G*A[i].masse*(A[i].y_now-A[l].y_now))/((distance+1)*sqrt(distance));
truc3=truc3+(G*A[i].masse*(A[i].z_now-A[l].z_now))/((distance+1)*sqrt(distance));
}
}
A[l].x_after= truc1*PAS*PAS - A[l].x_past + 2*A[l].x_now;
A[l].y_after= truc2*PAS*PAS - A[l].y_past + 2*A[l].y_now;
A[l].z_after= truc3*PAS*PAS - A[l].z_past + 2*A[l].z_now;
}
#pragma omp parallel for
for(l=0;l<=nmb-1;l++)
{
A[l].x_past=A[l].x_now;
A[l].y_past=A[l].y_now;
A[l].z_past=A[l].z_now;
A[l].x_now=A[l].x_after;
A[l].y_now=A[l].y_after;
A[l].z_now=A[l].z_after;
A[l].x_after=0;
A[l].y_after=0;
A[l].z_after=0;
}
} |
Le problème c'est que au final à part avoir monté le pourcentage du processus utilisé de 25% à 96% (mon processeur a 4 coeur) la parallélisation n'a eut aucun effet sur la vitesse d’exécution du programme. Ça la même ralenti: j'ai une baisse de 3 ou 4 FPS par rapport au même code sans les : #pragma omp parallel for . De plus il y a aussi plus d'erreur de calcul( c'est moins stable).
Donc ma question c'est est ce que OpenMP est vraiment utile ou est ce que c'est moi qui ne sais pas l'utilisé?
Merci d'avance.
