Discussion :

[salseropom]

Bonjour, j'utilise des threads dans mon prgm et je pense que mon prgm me retourne une mauvaise valeur à cause d'un pointeur.
Voici une partie de mon code :

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
 
typedef struct
{
  CVodeMem cvode_mem;
  N_Vector y;
  double t;
  double tout;
  unsigned int numpar;
  double rpm6;
} Integ;
 
void CreateInteg(void * cvode_mem,N_Vector y,double t,double tout,unsigned int
numpar,double rpm6,Integ * integ)
{
  integ->cvode_mem=(CVodeMem) cvode_mem;
  integ->y=y;
  integ->t=t;
  integ->tout=tout;
  integ->numpar=numpar;
  integ->rpm6=rpm6;
}
 
void * Integration(void * p)
{
  if(p==NULL)
  {
    fprintf(stderr,"Error in %s %u : p == NULL\n",__FILE__,__LINE__);
    exit(EXIT_FAILURE);
  }
  else
  {
    Integ * pInteg=(Integ * ) p;
    CVodeMem pcvode_mem=pInteg->cvode_mem;
 
    /* Call CVode and test for error */
   int flag = CVode(pInteg->cvode_mem, pInteg->tout,pInteg-> y, &pInteg->t,CV_NORMAL);
    if (check_flag(&flag, "CVode", 1))
    {
      fprintf(stderr,"Error in %s : %d : CVode failed at theta = %g for the particle %d\nExit program\n",__FILE__,__LINE__,pInteg->rpm6*pInteg->t-180.,pInteg->numpar);
      exit(EXIT_FAILURE);     
    }    
 
    return NULL;
 
  }  
}

La fonction CVode modifie mon vecteur pInteg->y

Puis dans mon main, j'ai la chose suivante

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
 
pthread_t task[N];
 
    Integ * integ=malloc(N*sizeof(*integ));
    if(integ==NULL)
    {
      MEMERROR;
      exit(EXIT_FAILURE);
    }
 
    while(tout<tfin)
    {      
      for(i=0;i<N;++i) /* loop on particles */
      {
	CreateInteg(cvode_mem[i],y[i],t[i],ttout[i],i,e->rpm6,&integ[i]);
 
	pthread_create(&task[i], NULL, Integration, &integ[i]);
 
	t[i]=tout;
 
      } /* end of for(i=0;i<N;++i) */
 
      for(i=0;i<N;++i) pthread_join (task[i], NULL);
 
                           /****  Turbulence  *****/  
 
      for(j=0;j<neq;++j)
      {
        aux3=0.;
	for(k=0;k<N;++k) aux3+=Ith(y[k],j);
	for(k=0;k<N;++k) Ith(y[k],j)=Ith(y[k],j)*aux1+aux3*aux2; 
      }

Mon pb vient que mon solveur me renvoie une erreur car il n'y a pas de convergence. Mais je pense que le pb n'est pas là car si je mets la ligne

Code :

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

1
2
 
pthread_join (task[i], NULL);

à l'intérieur de ma boucle for(i=0;i<n;++i) (la 1e boucle), ce qui revient donc à faire un prgm séquentiel, le solveur me renvoie une solution correcte. Donc je pense que le pb doit provenir de mes threads.

Etant donné que je dois résoudre N équations différentielles, j'ai fait un tableaux de N solveur (avec un malloc) afin de ne pas avoir de variable communes aux différents solveur. C'est pourquoi je n'ai pas mis de mutex dans ma fonction integration.

Pour pouvoir effectuer ma "turbulence" je dois nécesairement avoir résolu avant mes N équations différientielles. Est-ce que pthread_join() suffit ou dois-je utiliser des mutex avec conditions ?

J'espère avoir été suffisament clair dans mes explications.

[PRomu@ld]

pthread_join va attendre la fin du thread, tandis que les mutex vont mettre en veille ton thread actif si le mutex est posé, ça ressemble fortement à la même chose. un pthread_join devrait donc suffire.

[salseropom]

OK, merci. En plus, un pthread_join() s'implémente plus facilement qu'un mutex...

[homeostasie]

En plus, un pthread_join() s'implémente plus facilement qu'un mutex...

Ce n'est pas la même chose et donc pas le même rôle!
-> pthread_join() est une fonction de synchronisation qui suspend l'éxécution de ta tâche courante (main() par ex) en attandant la fin du ou des threads. Ca évite un comportement indéterminé dans le cas où la tâche courante se termine avant la fin des threads.

-> une mutex (mutuelle exclusion) est utilisée pour une ressource partageable non réentrante qui ne peut être utilisée que par un processus à la fois. Ceci évite par exemple de lire une donnée qui ne serait pas mise à jour par un autre thread au préalable.
On peut réaliser aussi cela via les sémaphores et on peut aussi synchroniser ainsi l'application.

[PRomu@ld]

Ce que je voulais dire c'est que dans ce cas bien précis, appliquer l'une ou l'autre des technologies, revient à la même chose.

D'ailleur, au passage, un mutex est un sémaphore à un jeton.

[homeostasie]

Ce que je voulais dire c'est que dans ce cas bien précis, appliquer l'une ou l'autre des technologies, revient à la même chose.

Oui j'avais bien compris cela, c'était juste pour complémenter un peu afin de distinguer la différence.

D'ailleur, au passage, un mutex est un sémaphore à un jeton.

Oui!