rand() et pthread

Version imprimable

rand() et pthread

Hello,

Soit le main() suivant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 int main(int argc, char* argv[]) { pthread_t ta; pthread_t tb; pthread_create (&ta, NULL, task_a, NULL); pthread_create (&tb, NULL, task_b, NULL); srand (time(NULL)); generenb(NOMBRE); #if 1 pthread_join (ta, NULL); pthread_join (tb, NULL); #endif system("PAUSE"); return 0; }
Dans la fonction que je duplique avec les thread, je génère une suite de nombre que je veux à chaque fois différente d'un thread à l'autre.

Lorsque je n'ai qu'un seul thread (le a), la fonction generenb() ainsi que mon thread fonctionnent bien. Sur les deux "files", j'ai bien à chaque fois 2 nombres différents. Mais dès que je rajoute un deuxième thread, eh bien les nombres générés sont identiques (dans le thread a et b). A priori, ça me semble logique (vu que je lance une tache qui génère des nombres aléatoires, et rand() va générer dans les deux threads les même nombre).

Bref, comment contourner mon problème ? de faire en sorte que, à partir de rand() :
- threada => génère X
- threadb => génère Y
- fonction() => génère Z

au lieu de

- threada => génère X
- threadb => génère X
- fonction() => génère Z

edit 1: Après réflexion, je me demandais s'il ne serait pas possible de rajouter à un argument à ma fonction generenb, qui serait une sorte de "grain de sel", argument que je changerais à chaque appele de ma fonction.

Citation:

Envoyé par nuitn0ire

Lorsque je n'ai qu'un seul thread (le a), la fonction generenb() ainsi que mon thread fonctionnent bien. Sur les deux "files", j'ai bien à chaque fois 2 nombres différents. Mais dès que je rajoute un deuxième thread, eh bien les nombres générés sont identiques (dans le thread a et b). A priori, ça me semble logique (vu que je lance une tache qui génère des nombres aléatoires, et rand() va générer dans les deux threads les même nombre).

C'est aussi ce que je constate avec ce code basique :
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 #include <windows.h> #include <pthread.h> #include <stdio.h> #include <stdlib.h> #include <time.h> void *task (void *puser) { int i; for (i = 0; i < 5; i++) { printf ("%s:%d\n", (char *) puser, rand ()); Sleep (1); } return NULL; } int main (void) { srand (time (NULL)); { pthread_t ta; pthread_t tb; pthread_create (&ta, NULL, task, (void *) "A"); pthread_create (&tb, NULL, task, (void *) "B"); pthread_join (ta, NULL); pthread_join (tb, NULL); } return 0; }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 A:41 B:41 A:18467 B:18467 A:6334 B:6334 A:26500 B:26500 A:19169 B:19169 Press ENTER to continue.
C'est étrange. Il me semblait pourtant qu'il y a avait une statique pour rand() par procéssus, mais qu'il était commun aux tâches (threads).

Ou pourrait effectivement démarrer chaque tâche avec un srand() différent...
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 #include <windows.h> #include <pthread.h> #include <stdio.h> #include <stdlib.h> #include <time.h> void *task (void *puser) { int i; char const *s = puser; srand (time (NULL) + s[0]); for (i = 0; i < 5; i++) { printf ("%s:%d\n", s, rand ()); Sleep (1); } return NULL; } int main (void) { { pthread_t ta; pthread_t tb; pthread_create (&ta, NULL, task, (void *) "A"); pthread_create (&tb, NULL, task, (void *) "B"); pthread_join (ta, NULL); pthread_join (tb, NULL); } return 0; }
Ca marche :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 A:13289 B:13293 A:12938 B:23687 A:4678 B:22542 A:13224 B:4519 A:21361 B:31676 Press ENTER to continue.

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
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
#define NOMBRE 100
 
char genere(int nombre);
 
static void *task_a (void *p_data)
{
 char const *s = p_data;
 srand (time (NULL) + s[0]);
 genere(NOMBRE);   
 (void) p_data;
 return NULL;
}
 
static void *task_b (void *p_data)
{
 char const *s = p_data;
 srand (time (NULL) + s[0]);
 genere(NOMBRE);             
 (void) p_data;
 return NULL;
}
 
int main(int argc, char* argv[])
{
 pthread_t ta;
 pthread_t tb;
 pthread_create (&ta, NULL, task_a, NULL);
 pthread_create (&tb, NULL, task_b, NULL);
 #if 1
 pthread_join (ta, NULL);
 pthread_join (tb, NULL);
 #endif
 
 system("PAUSE");    
 return 0;
}
 
char genere(int nombre)
{
 int i; 
 for (i = 0 ; i < NOMBRE ; i++)
  {
  int max2 = 100;
  int min2 = 1;
  int nb
  nb=min2+(int) (rand() % (max2+1-min2));                            
 }
}

violent plantage chez moi :(

11/03/2008, 12h07
pepito31

srand

Oui, je crois savoir que le srand permet de generer des nombres aleatoires independants, pour chaque run du pgrm !
rand ne fait que generer desnombres "pseudo-aleatoires" puisqu'ils seront tjs les memes apres chaque run ...

(mais je crois que vous aviez trouve la soluce, deja)
pepito

Citation:

Envoyé par nuitn0ire

<...>violent plantage chez moi :(

Bah, oui. J'avais pourtant donné un exemple qui fonctionne...

Il n'y a besoin que d'une fonction 'thread'
Il faut apprendre à utiliser le 4ème paramètre de pthread_create(). Si tu passes NULL tu reçois NULL dans la tâche, logique... Déréférencement de NULL -> comportement indéterminé, tout peut arriver.

Ceci fonctionne. Si tu ne comprends pas poses des questions, mais ne recopies pas sans comprendre...
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 #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <time.h> #define NOMBRE 10 void genere (int nombre, char const *s) { int i; for (i = 0; i < nombre; i++) { int max = 100; int min = 1; int nb; nb = min + (int) (rand () % (max + 1 - min)); printf ("%s: nb=%d\n", s, nb); } } static void *task (void *p_data) { char const *s = p_data; srand (time (NULL) + s[0]); genere (NOMBRE, s); return NULL; } int main (void) { pthread_t ta; pthread_t tb; pthread_create (&ta, NULL, task, (void *) "A"); pthread_create (&tb, NULL, task, (void *) "B"); pthread_join (ta, NULL); pthread_join (tb, NULL); return 0; }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 A: nb=75 A: nb=90 A: nb=16 A: nb=40 A: nb=40 A: nb=80 A: nb=35 A: nb=40 B: nb=78 B: nb=70 B: nb=12 B: nb=35 B: nb=55 B: nb=6 B: nb=47 B: nb=13 B: nb=76 B: nb=51 A: nb=32 A: nb=99 Press ENTER to continue.
Comme il n'y a pas de suspension explicite, c'est sans doute printf() (fonction I/O standard) qui fait office de 'scheduler' quand il peut... Dans mon code, il y a vait un Sleep(1) qui garantissait une juste répartition du temps entre les 2 tâches.

Eh bien écoute, je ne comprends pas.. Pas envie de passer pour un boulet, mais voici mon code complet :

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
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
#define NOMBRE 100
 
char genereip(int nombreip);
 
static void *task_a (void *p_data)
{
 srand (time (NULL));
 genereip(NOMBRE);   
 (void) p_data;
 return NULL;
}
 
static void *task_b (void *p_data)
{
 genereip(NOMBRE);             
 (void) p_data;
 return NULL;
}
 
int main(int argc, char* argv[])
{
 pthread_t ta, tb;
 pthread_create (&ta, NULL, task_a, NULL);
 pthread_create (&tb, NULL, task_b, NULL);
 pthread_join (ta, NULL);
 pthread_join (tb, NULL);
 
 system("PAUSE");    
 return 0;
}
 
char genereip(int nombreip)
{
 int i; 
 for (i = 0 ; i < NOMBRE ; i++)
  {
  int max2 = 1;
  int min2 = 100;
  int nb;
  nb=min2+(int) (rand() % (max2+1-min2));
  char ip[12];
  sprintf(ip,"192.168.1.%d",nb);
  printf("ip : %s\n",ip);
 }
}

Je comprends pas comment adapter ton code au mien. Par ailleurs, dans

Code:

pthread_create (&ta, NULL, task, (void *) "A");

je ne comprends pas le "A".

(bon, je débute en C, mais j'aimerais bien comprendre comment réorganiser mon code de façon à corriger mon problème).

Voilà. Patapay.

11/03/2008, 16h12
Médinoc

Emmanuel: Pour rand(), ça dépend des implémentations.
La C Run-Time Library (CRT) de Microsoft utilise une "graine" par thread, pour rester thread-safe: Aucun thread n'a d'influence sur les autres.

D'ailleurs, c'est malin, le coup du srand(time(NULL)+valeur spécifique au thread). Je vais le garder sous la main, ce truc...
11/03/2008, 16h16
Emmanuel Delahaye

Citation:

Envoyé par Médinoc

Emmanuel: Pour rand(), ça dépend des implémentations.
La C Run-Time Library (CRT) de Microsoft utilise une "graine" par thread, pour rester thread-safe: Aucun thread n'a d'influence sur les autres.

OK, c'est pas idiot, surtout en cryptographie !

Citation:

Envoyé par nuitn0ire

Je comprends pas comment adapter ton code au mien.

Déjà, il est incorrect :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Project : Forums Compiler : GNU GCC Compiler (called directly) Directory : C:\dev\forums\ -------------------------------------------------------------------------------- Switching to target: default Compiling: main.c main.c:25: warning: unused parameter 'argc' main.c:25: warning: unused parameter 'argv' main.c: In function `genereip': main.c:48: warning: too few arguments for format main.c: At top level: main.c:37: warning: unused parameter 'nombreip' main.c: In function `genereip': main.c:50: warning: control reaches end of non-void function Linking console executable: console.exe Process terminated with status 0 (0 minutes, 0 seconds) 0 errors, 5 warnings
Pourquoi tu crées 2 tâches. Les deux doivent avoir le même comportement, donc une seule suffit. Par contre, elles traiteront sans doute des données différentes, donc on passe un paramètre qui permet au moins de les différencier quand on fait un printf(), par exemple.

Code:

char ip[12];

est trop petit pour une adresse IP complète. Si tu ne sais pas compter (bienvenu au club!), tu fais comme ça :

Code:

char ip[sizeof "255.255.255.255"];

tu es alors sûr d"avoir la bonne taille.

Tu as choisi une plage d'IP étrange...
Code:

1 2 int max2 = 1; int min2 = 100;
C'est voulu ?
J'aurais dit :
Code:

1 2 3 int min = 1; int max = 100;
et pourquoi se limiter à 100 ?

Citation:

Par ailleurs, dans

Code:

pthread_create (&ta, NULL, task, (void *) "A");

je ne comprends pas le "A".

(bon, je débute en C, mais j'aimerais bien comprendre comment réorganiser mon code de façon à corriger mon problème).

As-tu lu la doc de pthread_create () ? As-tu compris à quoi servait le 4ème paramètre ?

http://emmanuel-delahaye.developpez.com/pthreads.htm

notamment le chapitre sur les données...

Je propose ceci :
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 #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <time.h> #include <windows.h> static char genereip (int nombreip, char const *s) { int i; for (i = 0; i < nombreip; i++) { int max = 254; int min = 2; int nb = min + (rand () % (max + 1 - min)); char ip[sizeof "192.168.1.255"]; sprintf (ip, "192.168.1.%d", nb); printf ("%s : ip : %s\n", s, ip); Sleep(1); } } static void *task (void *p_data) { char const *s = p_data; srand (time (NULL) + s[0]); genereip (100, s); return NULL; } int main (void) { pthread_t ta, tb; pthread_create (&ta, NULL, task, (void *) "alphonse"); pthread_create (&tb, NULL, task, (void *) "beatrice"); pthread_join (ta, NULL); pthread_join (tb, NULL); system ("PAUSE"); return 0; }
Pose des questions si tu ne comprends pas.

Re,

Bon, ton code fonctionne, je l'ai adapté au mien, ça marche.

mais !

Si je rajoute un 3eme thread, j'ai nouveau mon problème de base, à savoir qu'il y a deux threads qui me renvoient le même résultat (problème que j'avais avec mon tout premier code). Avec un truc comme :
Code:

1 2 3 4 5 6 7 8 9 10 /* [...] */ pthread_t ta, tb, tc; pthread_create (&ta, NULL, task, (void *) "alphonse"); pthread_create (&tb, NULL, task, (void *) "beatrice"); pthread_create (&tc, NULL, task, (void *) "test"); pthread_join (ta, NULL); pthread_join (tb, NULL); pthread_join (tc, NULL); /* [...] */
Donc j'aimerais comprendre pourquoi et comment résoudre ce problème. Une fois résolu, j'aurai quelques petites questions..

/edit : tant qu'à faire, je vais en profiter pour poser mes questions :

1) La constante qu'on déclare dans la fonction (donc qui apparait en 4eme paramètre du pthread_create, c'est une variable qui sert uniquement à différencier les thread, de façon à ce que chacun d'eux ne fasse pas exactement la même chose, et donc nous renvoi une erreur à l'execution du programme ?

2) J'imagine que cette approche des thread est simpliste (outre mon problème de rand), dans le code, on déclare les 2 ou 3 threads de cette façon dans le main, je me demandais si on ne pouvait pas faire une fonction dans laquelle on déclare simplement le nombre de thread que l'on veut et qui va se charger de nous les creer automatiquement. Un truc genre createthread(10) nous créerait 10 threads, au lieu de se cogner une succession de ligne comme on le fait là. Ce serait à mon sens plus propre et "pro".

Citation:
Envoyé par nuitn0ire
Si je rajoute un 3eme thread, j'ai nouveau mon problème de base, à savoir qu'il y a deux threads qui me renvoient le même résultat (problème que j'avais avec mon tout premier code). Avec un truc comme :
Code:

1 2 3 4 5 6 7 8 9 10 /* [...] */ pthread_t ta, tb, tc; pthread_create (&ta, NULL, task, (void *) "alphonse"); pthread_create (&tb, NULL, task, (void *) "beatrice"); pthread_create (&tc, NULL, task, (void *) "test"); pthread_join (ta, NULL); pthread_join (tb, NULL); pthread_join (tc, NULL); /* [...] */
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 alphonse : ip : 192.168.1.32 beatrice : ip : 192.168.1.35 test : ip : 192.168.1.94 alphonse : ip : 192.168.1.58 beatrice : ip : 192.168.1.180 test : ip : 192.168.1.79 alphonse : ip : 192.168.1.35 beatrice : ip : 192.168.1.58 test : ip : 192.168.1.5 alphonse : ip : 192.168.1.21 beatrice : ip : 192.168.1.49 test : ip : 192.168.1.243 alphonse : ip : 192.168.1.174 beatrice : ip : 192.168.1.116 test : ip : 192.168.1.49 alphonse : ip : 192.168.1.191 beatrice : ip : 192.168.1.70 test : ip : 192.168.1.155 alphonse : ip : 192.168.1.92 beatrice : ip : 192.168.1.37 test : ip : 192.168.1.18 alphonse : ip : 192.168.1.160 beatrice : ip : 192.168.1.16 test : ip : 192.168.1.211 alphonse : ip : 192.168.1.77 beatrice : ip : 192.168.1.143 test : ip : 192.168.1.163 alphonse : ip : 192.168.1.78 beatrice : ip : 192.168.1.2 test : ip : 192.168.1.169 Appuyez sur une touche pour continuer...
Je n'ai pas ce problème... Tu as du faire une erreur de codage quelque part...

Citation:

Donc j'aimerais comprendre pourquoi et comment résoudre ce problème. Une fois résolu, j'aurai quelques petites questions..

Pour moi, le problème est résolu. Il suffit que la première lettre du nom soit différente des autres. Sinon, un peut utiliser un nombre
Code:

1 2 3 4 5 6 7 8 9 10 pthread_t ta, tb, tc; /* il faudrait vérifier qu'il n'y a pas de doublons, faire un tableau etc. */ int a=rand(), b=rand(), c=rand(); pthread_create (&ta, NULL, task, &a); pthread_create (&tb, NULL, task, &b); pthread_create (&tc, NULL, task, &c); <...>
Citation:

/edit : tant qu'à faire, je vais en profiter pour poser mes questions :

1) La constante qu'on déclare dans la fonction (donc qui apparait en 4eme paramètre du pthread_create, c'est une variable qui sert uniquement à différencier les thread, de façon à ce que chacun d'eux ne fasse pas exactement la même chose,

Oui. Je me sers de la valeur du premier caractère de la chaine pour srand(). Comme je l'ai montré au-dessus, des valeurs entières suffisent...

Citation:

et donc nous renvoi une erreur à l'execution du programme ?

Euh, non aucun rapport. Ca sert à résoudre le problème de la suite de nombre qui est identique dans tous les threads. Là, je demande que les générateurs pseudo-aléatoires de chaque threads commencent à des valeurs différentes (graine ou seed, le 's' de srand()...).

Citation:

2) J'imagine que cette approche des thread est simpliste (outre mon problème de rand), dans le code, on déclare les 2 ou 3 threads de cette façon dans le main, je me demandais si on ne pouvait pas faire une fonction dans laquelle on déclare simplement le nombre de thread que l'on veut et qui va se charger de nous les creer automatiquement. Un truc genre createthread(10) nous créerait 10 threads, au lieu de se cogner une succession de ligne comme on le fait là. Ce serait à mon sens plus propre et "pro".

- structure de données,
- tableau de structure,
- boucle...

Rien que du C de base...

13/03/2008, 12h06
nuitn0ire
Ok, j'ai pigé l'histoire de la graine, j'avais mal compris le code à l'origine. Du coup ça fonctionne bien comme je veux, merci.

Bon, j'ai essayé de trouver des infos concernant ma dernière requête, à savoir automatiser l'ouverture des threads que je répète. Ca donne ce code ci :
Code:

1 2 3 4 5 6 7 8 9 char datas[20][5]; int i; pthread_t t[20]; for(i=0;i<20;i++) { sprintf(datas[i],"%d",i); pthread_create (&t[i], NULL, task, (void *)datas[i]); pthread_join (t[i], NULL); }
Le hic, c'est que même si ce code se compile, malheureusement il ne me génère qu'un seul thread.. Et non 20 (comme dans mon exemple).
13/03/2008, 12h15
corrector
Citation:
Envoyé par nuitn0ire

Code:

1 2 3 4 5 6 7 8 9 char datas[20][5]; int i; pthread_t t[20]; for(i=0;i<20;i++) { sprintf(datas[i],"%d",i); pthread_create (&t[i], NULL, task, (void *)datas[i]); pthread_join (t[i], NULL); }

Le hic, c'est que même si ce code se compile, malheureusement il ne me génère qu'un seul thread.. Et non 20 (comme dans mon exemple).
Tu démarres un thread... et tu attends qu'il se termine juste après. Ton code génère bien 20 threads, mais 1 à la fois.

Autant appeler directement task (data[i]) :
Code:

1 2 3 4 5 6 7 char datas[20][5]; int i; for(i=0;i<20;i++) { sprintf(datas[i],"%d",i); task (data[i]); }

Problème résolu avec le code suivant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 char datas[NTHREAD][5]; int i; pthread_t t[NTHREAD]; for(i=0;i<NTHREAD;i++) { sprintf(datas[i],"%d",i); pthread_create (&t[i], NULL, task, (void *)datas[i]); } for(i=0;i<NTHREAD;i++) { pthread_join (t[i], NULL); }
Cependant, la boucle qui est dans la fonction qu'elle mon thread ne s'arrête plus.. elle devait s'arrêter à un résultat de 100, là elle ne s'arrête plus..

/edit : au temps pour moi, j'ai oublié que ma boucle bouclait NTHREAD fois ;p En fait ça marche.

Merci à tous !

Citation:

Envoyé par nuitn0ire

Problème résolu avec le code suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
char datas[NTHREAD][5];
int i;
pthread_t t[NTHREAD];
for(i=0;i<NTHREAD;i++)
{
 sprintf(datas[i],"%d",i);
 pthread_create (&t[i], NULL, task, (void *)datas[i]);
}
 
for(i=0;i<NTHREAD;i++)
{
 pthread_join (t[i], NULL);
}

Cependant, la boucle qui est dans la fonction qu'elle mon thread ne s'arrête plus.. elle devait s'arrêter à un résultat de 100, là elle ne s'arrête plus..

/edit : au temps pour moi, j'ai oublié que ma boucle bouclait NTHREAD fois ;p En fait ça marche.

Merci à tous !

On peut aussi faire comme ça :

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
 
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
#include <windows.h>
 
static void genereip (int nombreip, int n)
{
   int i;
   for (i = 0; i < nombreip; i++)
   {
      int max = 254;
      int min = 2;
      int nb = min + (rand () % (max + 1 - min));
      char ip[sizeof "192.168.1.255"];
      sprintf (ip, "192.168.1.%d", nb);
      printf ("%2d : ip : %s\n", n, ip);
      Sleep (1);
   }
}
 
static void *task (void *p_data)
{
   int *pi = p_data;
   int n = *pi;
   srand (time (NULL) + n);
   genereip (10, n);
   return NULL;
}
 
int main (void)
{
#define NTHREAD 4
 
   int datas[NTHREAD];
   int i;
   pthread_t t[NTHREAD];
 
   for (i = 0; i < NTHREAD; i++)
   {
      datas[i] = i + 1;
      pthread_create (t+i, NULL, task, datas + i);
   }
 
   for (i = 0; i < NTHREAD; i++)
   {
      pthread_join (t[i], NULL);
   }
   return 0;
}

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
 
 1 : ip : 192.168.1.223
 2 : ip : 192.168.1.227
 3 : ip : 192.168.1.230
 4 : ip : 192.168.1.233
 1 : ip : 192.168.1.154
 2 : ip : 192.168.1.23
 3 : ip : 192.168.1.146
 4 : ip : 192.168.1.137
 1 : ip : 192.168.1.213
 2 : ip : 192.168.1.114
 3 : ip : 192.168.1.137
 4 : ip : 192.168.1.39
 1 : ip : 192.168.1.240
 2 : ip : 192.168.1.15
 3 : ip : 192.168.1.166
 4 : ip : 192.168.1.63
 1 : ip : 192.168.1.13
 2 : ip : 192.168.1.77
 3 : ip : 192.168.1.18
 4 : ip : 192.168.1.213
 1 : ip : 192.168.1.95
 2 : ip : 192.168.1.226
 3 : ip : 192.168.1.105
 4 : ip : 192.168.1.237
 1 : ip : 192.168.1.177
 2 : ip : 192.168.1.253
 3 : ip : 192.168.1.77
 4 : ip : 192.168.1.153
 1 : ip : 192.168.1.14
 2 : ip : 192.168.1.123
 3 : ip : 192.168.1.231
 4 : ip : 192.168.1.87
 1 : ip : 192.168.1.113
 2 : ip : 192.168.1.180
 3 : ip : 192.168.1.115
 4 : ip : 192.168.1.182
 1 : ip : 192.168.1.88
 2 : ip : 192.168.1.12
 3 : ip : 192.168.1.189
 4 : ip : 192.168.1.244
 
Press ENTER to continue.

14/03/2008, 11h29
nuitn0ire

Encore deux questions :

Est-ce qu'il est possible de mettre moins d'une seconde au srand(). J'entends par là que srand() modifie le grain toutes les secondes, mais j'ai l'impression que lorsque je mets trop de thread (ici plus de 10), j'ai des doublons qui apparaissent. Ca me semble logique dans la mesure où le srand() ne modifie pas assez vite la graine, dans ce cas un ou deux thread récupérerons la même graine, du coup => doublons.

Es-ce qu'il y a une limite à ne pas dépasser dans l'utilisation des thread ? Par exemple une limite qui, si elle est dépassée, peu rendre notre programme instable.
14/03/2008, 12h56
Emmanuel Delahaye

Citation:

Envoyé par nuitn0ire

Est-ce qu'il est possible de mettre moins d'une seconde au srand(). J'entends par là que srand() modifie le grain toutes les secondes,

Euh, non... srand() ne modifie la graine que si on lui demande...

Citation:

mais j'ai l'impression que lorsque je mets trop de thread (ici plus de 10), j'ai des doublons qui apparaissent. Ca me semble logique dans la mesure où le srand() ne modifie pas assez vite la graine, dans ce cas un ou deux thread récupérerons la même graine, du coup => doublons.

C'est gênant ? J'ai un peu du mal à voir ce que tu veux faire...

Citation:

Es-ce qu'il y a une limite à ne pas dépasser dans l'utilisation des thread ? Par exemple une limite qui, si elle est dépassée, peu rendre notre programme instable.

Il y a certainement une limite, mais je suppose qu'elle dépend du système...

http://sourceware.org/pthreads-win32/

etc. :google2: est ton ami...
15/03/2008, 04h43
corrector

Citation:

Envoyé par Emmanuel Delahaye

Euh, non... srand() ne modifie la graine que si on lui demande...

Oui, mais l'idiome classique :

Code:

srand (time (NULL));

génère la même graine s'il est appelé plusieurs fois en moins d'une seconde, et je crois que c'est (presque) ce que nuitn0ire a voulu dire.

C'est parfois un problème quand on peut lancer très vite plusieurs fois un programme, par exemple à partir d'un script.

Citation:

Envoyé par Emmanuel Delahaye

C'est étrange. Il me semblait pourtant qu'il y a avait une statique pour rand() par procéssus, mais qu'il était commun aux tâches (threads).

C'est quand même mieux d'avoir chaque thread qui peut appeler indépendament rand(), que d'avoir à protéger l'appel par un mutex!
Citation:
Envoyé par Emmanuel Delahaye
Ou pourrait effectivement démarrer chaque tâche avec un srand() différent...
Code:

1 2 3 4 5 6 7 8 9 void *task (void *puser) { char const *s = puser; srand (time (NULL) + s[0]); ... pthread_create (&ta, NULL, task, (void *) "A"); pthread_create (&tb, NULL, task, (void *) "B");
Si les threads sont lancés suffisamment vite, alors ça marche.

Si le "A" démarre seulement 1 seconde après (en réalité, dans la seconde suivante) le "B", ça marche plus. Le cas va rarement se présenter, mais il est tout à fait possible.

Ce n'est donc pas une solution.