Performance de pthread sous linux

Version imprimable

Bonjour,

J'utilise la lib pthread pour découper un gros calcul en 2.
Sous windows j'obtient bien avec un bipro 30 à 40% de gain alors que sous linux je suis 10% plus lent. Je n'y comprend rien, je pensais que linux était mieux pensé que windows pour la gestion des taches !
Ou alors je m'y prend mal. Voici le code que j'utilise, il n'est pas exploitable directement mais donne une idée de la maniere don't j'ai impléménté mon calcul

Le calcul est partagé dans la fonction "myThreadEmit" nno et nn1 valent respectivement (0->50000) & (50000->100000) pour les thread 1 & 2

"emit_partielle_c" est la fonction que je chronometre

Si quelqu'un voit un loup, merci d'avance

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
struct dataEmit {
  long nn0,nn1,iptsss;
  double *cord,*loss,
    xm,ym,xpm,ypm,em,pm,pzm,erest,wavel,radian,wsync,
    dpm,zdpm,dp2,z2,z4,dp4,z2dp2,dp3z,x2,y2,xp2,
    yp2,xxpm,yypm,xym,xpypm,xypm,x4,y4,xp4,x2xp2,
    y2yp2,x3xp,xp3x,yp3y,xmax,ymax,r2,rp2,rrrp,
    z3dp,xpym,yp4,y3yp,zm;
} my_structEmit;
 
 
 
void *myThreadEmit(void *arg)
{
  double un_s_erest,gm,xx,yy,xxp,yyp,pp,ee,rr,rrp,bg;
  double sqrtxy,pzi,bz,ddp,zz,ddp2;
  double xx2,yy2,xxp2,yyp2,zz2,kwavel,un_s_c,un_s_pzm;
  int np;
 
  struct dataEmit *d;
  d = (struct dataEmit *)arg;
 
  un_s_erest=1./ d->erest;
  kwavel=d->wavel/360.;
  un_s_c=1./299792458.;
  un_s_pzm=1./ d->pzm;
 
 
  for (np=d->nn0;np<d->nn1;np++) {
    if (d->loss[np]==0) {
      gm = 1+d->cord[np*6+5]*un_s_erest;
      if (gm>1.) {
        xx = d->cord[np*6];
        yy = d->cord[np*6+2];
        xxp = d->cord[np*6+1];
        yyp = d->cord[np*6+3];
        pp = d->cord[np*6+4]/ d->radian;
        ee = d->cord[np*6+5]- d->wsync;
 
        rr = sqrt(xx*xx+yy*yy);
        if (rr!=0) rrp = (xx*xxp+yy*yyp)/rr; else rrp=0;
        d->r2+=rr*rr;
        d->rp2+=rrp*rrp;
        d->rrrp+=rr*rrp;
 
        if (fabs(xx)>d->xmax) d->xmax=fabs(xx);
        if (fabs(yy)>d->ymax) d->ymax=fabs(yy);
 
        xx-=d->xm;
        yy-=d->ym;
        xxp-=d->xpm;
        yyp-=d->ypm;
        pp-=d->pm;
        ee-=d->em;
 
        xx2=xx*xx;
        xxp2=xxp*xxp;
        yy2=yy*yy;
        yyp2=yyp*yyp;
 
        bg = sqrt(gm*gm-1);
        sqrtxy = 1./sqrt(1+xxp2+yyp2);
        pzi=bg* d->erest*un_s_c*sqrtxy;
        bz = bg*sqrtxy/gm;
        ddp=un_s_pzm*pzi-1;
        zz=-pp*bz*kwavel;
 
        d->dpm+=ddp;
        d->zm+=zz;
        d->zdpm+=ddp*zz;
        ddp2=ddp*ddp;
        zz2=zz*zz;
        d->dp2+=ddp2;
        d->z2+=zz2;
        d->z4+=zz2*zz2;
        d->dp4+=ddp2*ddp2;
        d->z2dp2+=zz2*ddp2;
        d->z3dp+=zz*zz2*ddp;
        d->dp3z+=ddp*ddp2*zz;
 
        d->x2+=xx2;
        d->y2+=yy2;
        d->xp2+=xxp2;
        d->yp2+=yyp2;
 
        d->xxpm+=xx*xxp;
        d->yypm+=yy*yyp;
        d->xym+=xx*yy;
        d->xpypm+=xxp*yyp;
        d->xypm+=xx*yyp;
        d->xpym+=xxp*yy;
 
        d->x4+=xx2*xx2;
        d->y4+=yy2*yy2;
        d->xp4+=xxp2*xxp2;
        d->yp4+=yyp2*yyp2;
        d->x2xp2+=xx2*xxp2;
        d->y2yp2+=yy2*yyp2;
        d->x3xp+=xx*xx2*xxp;
        d->xp3x+=xxp*xxp2*xx;
        d->y3yp+=yy*yy2*yyp;
        d->yp3y+=yyp*yyp2*yy;
      }
    }
  }
  pthread_exit(NULL);
  return(NULL);
}
 
 
void emit_partielle_c_(int *npoint,double *cord,double *loss,
  double *xm,double *ym,double *xpm,double *ypm,double *em,double *pm,double *pzm,double *erest,double *wavel,double *radian,double *wsync,
  double *dpm,double *zdpm,double *dp2,double *z2,double *z4,
  double *dp4,double *z2dp2,double *dp3z,double *x2,double *y2,double *xp2,
  double *yp2,double *xxpm,double *yypm,double *xym,double *xpypm,
  double *xypm,double *x4,double *y4,double *xp4,double *x2xp2,
  double *y2yp2,double *x3xp,double *xp3x,double *yp3y,
  double *xmax,double *ymax,double *r2,double *rp2,double *rrrp,
  double *z3dp,double *xpym,double *yp4,double *y3yp,double *zm)
{
  long nn0,nn1;
  int i,rc,Nthr=nbr_thread_partran;
  pthread_t tid[Nthr];
  struct dataEmit d[Nthr];
 
 
  for (i=0;i<Nthr;i++) {
    nn0=i*(*npoint)/Nthr;
    nn1=(i+1)*(*npoint)/Nthr;
    if (i==Nthr-1) nn1=*npoint;
    d[i].nn0=nn0;
    d[i].nn1=nn1;
    d[i].iptsss=*npoint;
    d[i].cord=cord;
    d[i].loss=loss;
    d[i].xm=*xm;
    d[i].ym=*ym;
    d[i].xpm=*xpm;
    d[i].ypm=*ypm;
    d[i].em=*em;
    d[i].pm=*pm;
    d[i].pzm=*pzm;
    d[i].erest=*erest;
    d[i].wavel=*wavel;
    d[i].radian=*radian;
    d[i].wsync=*wsync;
    d[i].dpm=d[i].zdpm=d[i].dp2=d[i].z2=d[i].z4=d[i].dp4=d[i].z2dp2=0;
    d[i].dp3z=d[i].x2=d[i].y2=d[i].xp2=d[i].yp2=d[i].xxpm=d[i].yypm=0;
    d[i].xym=d[i].xpypm=d[i].xypm=d[i].x4=d[i].y4=d[i].xp4=d[i].x2xp2=0;
    d[i].y2yp2=d[i].x3xp=d[i].xp3x=d[i].yp3y=d[i].xmax=d[i].ymax=0;
    d[i].r2=d[i].rp2=d[i].rrrp=d[i].z3dp=d[i].xpym=d[i].yp4=d[i].y3yp=d[i].zm=0;
  }
 
  for (i=0;i<Nthr;i++) {
    rc=pthread_create(&tid[i],NULL, myThreadEmit, (void *)&d[i]);
    if (rc) {
      printf("ERROR: return code from pthread_create() is %d\n",rc);
    }
  }
 
  for(i=0; i<Nthr; i++) {
    rc = pthread_join(tid[i],NULL);
    if (rc) {
      printf("ERROR: return code from pthread_join() is %d\n",rc);
    }
  }
 
  for (i=0;i<Nthr;i++) {
    *r2=*r2+d[i].r2;
    *rp2=*rp2+d[i].rp2;
    *rrrp=*rrrp+d[i].rrrp;
    *x2=*x2+d[i].x2;
    *y2=*y2+d[i].y2;
    *xp2=*xp2+d[i].xp2;
    *yp2=*yp2+d[i].yp2;
    *xxpm=*xxpm+d[i].xxpm;
    *yypm=*yypm+d[i].yypm;
    *xym=*xym+d[i].xym;
    *xpypm=*xpypm+d[i].xpypm;
    *xypm=*xypm+d[i].xypm;
    *xpym=*xpym+d[i].xpym;
    *x4=*x4+d[i].x4;
    *y4=*y4+d[i].y4;
    *xp4=*xp4+d[i].xp4;
    *yp4=*yp4+d[i].yp4;
    *x2xp2=*x2xp2+d[i].x2xp2;
    *y2yp2=*y2yp2+d[i].y2yp2;
    *x3xp=*x3xp+d[i].x3xp;
    *xp3x=*xp3x+d[i].xp3x;
    *y3yp=*y3yp+d[i].y3yp;
    *yp3y=*yp3y+d[i].yp3y;
    *dpm=*dpm+d[i].dpm;
    *zm=*zm+d[i].zm;
    *zdpm=*zdpm+d[i].zdpm;
    *dp2=*dp2+d[i].dp2;
    *z2=*z2+d[i].z2;
    *z4=*z4+d[i].z4;
    *dp4=*dp4+d[i].dp4;
    *z2dp2=*z2dp2+d[i].z2dp2;
    *z3dp=*z3dp+d[i].z3dp;
    *dp3z=*dp3z+d[i].dp3z;
    if (d[i].xmax>*xmax) *xmax=d[i].xmax;
    if (d[i].ymax>*ymax) *ymax=d[i].ymax;
  }
}

05/08/2009, 00h33
Mac LAK

Citation:

Envoyé par uriotcea

Je n'y comprend rien, je pensais que linux était mieux pensé que windows pour la gestion des taches !

Non, classiquement, Windows est bien meilleur avec les threads, et Linux bien meilleur avec les processus... Surtout si tes threads sont "courts", c'est à dire lancés pour une durée du même ordre de grandeur que leur temps d'initialisation.

Il n'y a pas de "loups" dans ton code, c'est une manière classique de lancer un calcul en parallèle. Mais typiquement, sur ce coup, Windows gagne en général (à niveau d'optimisation égal bien entendu). Si tu avais fait le même code avec des "fork()", ce serait Linux qui aurait normalement "gagné".

Tu pourrais d'ailleurs peut-être gagner encore en perfs en lançant un thread de plus que le nombre de cœurs, afin d'optimiser un peu l'accès au bus mémoire. Cela dépend de tes calculs, bien sûr, mais c'est une possibilité à regarder pour arriver à 50% de gain.
05/08/2009, 07h30
uriotcea

En fait je me rend compte que je ne me suis mal exprimé. sous linux si ma boucle contenant le calcul (concequent tout de même) est inferieur à 10000, je n'ai pas de gain mais c'est même plutot plus lent. J'ai du mal à croire que le lancement d'un thread puisse etre plus long qu'une telle boucle de calcul. 10000 itérations prend quelquechose comme 20ms, j'aurais estimé le lancement de thread à quelques dizaines de us.

Aurais-tu un example ou un lien pour faire l'équivalent avec fork() ?
05/08/2009, 13h23
matafan

Ca n'ira pas plus vite avec un fork(). Mais si tu y tiens, ce n'est guère plus compliqué, sauf qu'il faut mettre tes données en mémoire partagée.

Ton noyau a bien le support du SMP ?
05/08/2009, 14h09
uriotcea

Je viens d'essayer avec fork(), c'est effectivement assez aisé à mettre en place mais cette fois le calcul avec 2 threads/fork est 3 à 4 plus lent.
C'est bien pire que pthread. Je suis vraiment surpris de ces résultats
05/08/2009, 18h17
Mac LAK
Citation:

Envoyé par uriotcea

En fait je me rend compte que je ne me suis mal exprimé. sous linux si ma boucle contenant le calcul (concequent tout de même) est inferieur à 10000, je n'ai pas de gain mais c'est même plutot plus lent.

Étrange, tout ça... Je rejoins matafan, ton kernel doit avoir été compilé de façon assez étrange.

Tapes "uname -a" sur un terminal, stp, et donnes-nous le résultat. Bien sûr, si ton Linux tourne en machine virtuelle, il est par contre tout à fait normal qu'il soit bien plus lent que la machine hôte !

Citation:

Envoyé par uriotcea

J'ai du mal à croire que le lancement d'un thread puisse etre plus long qu'une telle boucle de calcul. 10000 itérations prend quelquechose comme 20ms, j'aurais estimé le lancement de thread à quelques dizaines de us.

Grosse erreur : si tu veux des threads réellement performants, il vaut mieux les créer suspendus en début de programme, puis les alimenter / lancer / suspendre quand tu en as besoin. Et ceci même sous Windows, d'ailleurs.

Citation:

Envoyé par uriotcea

Je viens d'essayer avec fork(), c'est effectivement assez aisé à mettre en place mais cette fois le calcul avec 2 threads/fork est 3 à 4 plus lent.
C'est bien pire que pthread. Je suis vraiment surpris de ces résultats

En fait, tout dépend du temps de calcul : Linux gère mieux les processus, mais il faut quand même que plusieurs conditions soient réunies :
- Le temps de calcul doit être significatif, plusieurs minutes au moins. Or, toi, tu es proche de la durée du quantum de temps par défaut...
- Les processus lancés doivent être "autonomes" et ne pas dépendre d'un moyen "lent" (sockets, fichiers, pipes) pour accéder à leurs données.
- Ils ne doivent pas être préemptés par n'importe quoi, notamment d'inutile comme la couche graphique.
Mais encore une fois, si les performances s'effondrent autant, ça fait penser à un problème de noyau...