Multi threading lent

Version imprimable

Bonjour,

Je suis en train de découvrir les multithreads. J'ai donc récupérer un exemple de Intel :
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 #include <stdio.h> #include <pthread.h> #define INTERVALS 1000000000 #define THREADS 2 float global_sum = 0.0; pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER; void *pi_calc (void *num); int main () { pthread_t tid[THREADS]; int i, t_num[THREADS]; for (i = 0; i < THREADS; i++) { t_num[i] = i; pthread_create (&tid[i], NULL, pi_calc, &t_num[i]); } for (i = 0; i < THREADS; i++) pthread_join (tid[i], NULL); printf ("Pi = %f\n", global_sum); } void *pi_calc (void *num) { int i, myid, start, end; float h, x, my_sum = 0.0; myid = *(int *)num; h = 1.0 / INTERVALS; start = (INTERVALS / THREADS) * myid; end = start + (INTERVALS / THREADS); for (i = start; i < end; i++) { x = h * ((float)i - 0.5); my_sum += 4.0 / (1.0 + x * x); } pthread_mutex_lock (&global_lock); global_sum += my_sum; pthread_mutex_unlock (&global_lock); }
Je compile sous linux (gcc main.c -o main -lpthread) et je teste les performances avec la commande time ./main : 29,01s user 0,00s system 198% cpu 14,611 total
Le CPU travaille à 198% pendant 14.6 secondes : normal, processeur Dual Core.
Afin de vérifier l'efficacité du Multithreading, je modifie le programme pour qu'il lance les 2 fonctions l'une après l'autre :
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 <stdio.h> #define INTERVALS 1000000000 #define THREADS 2 float global_sum = 0.0; void *pi_calc (void *num); int main () { int i, t_num[THREADS]; for (i = 0; i < THREADS; i++) { t_num[i] = i; pi_calc(&t_num[i]); } printf ("Pi = %f\n", global_sum); } void *pi_calc (void *num) { int i, myid, start, end; float h, x, my_sum = 0.0; myid = *(int *)num; h = 1.0 / INTERVALS; start = (INTERVALS / THREADS) * myid; end = start + (INTERVALS / THREADS); for (i = start; i < end; i++) { x = h * ((float)i - 0.5); my_sum += 4.0 / (1.0 + x * x); } global_sum += my_sum; }
Je relance time : 14,49s user 0,00s system 99% cpu 14,490 total
Le CPU travaille à 99% pendant 14.5 secondes.

En fait, ce qui me perturbe c'est que la version multithread a la même vitesse d'exécution que la version utilisant un seul processeur. Normalement, la version multithread devrait être 2 fois plus rapide que l'autre.

Est-ce que quelqu'un sait pourquoi il y a ce problème ?

Merci

Mr Bonheur

Citation:

Envoyé par MrBonheur

En fait, ce qui me perturbe c'est que la version multithread a la même vitesse d'exécution que la version utilisant un seul processeur. Normalement, la version multithread devrait être 2 fois plus rapide que l'autre.

Je suppose que le mutex 'resérialise' l'exécution...

Fait tes calculs en 'double', la précision est meilleure (et le résultat plus cohé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
35
36
37
38
39
40
41
42
43
 
#include <stdio.h>
#include <pthread.h>
 
#define INTERVALS 1000000000
#define THREADS 2
 
double global_sum = 0.0;
pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER;
 
static void *pi_calc (void *num)
{
   int i, myid, start, end;
   double h, x, my_sum = 0.0;
   myid = *(int *) num;
   h = 1.0 / INTERVALS;
   start = (INTERVALS / THREADS) * myid;
   end = start + (INTERVALS / THREADS);
   for (i = start; i < end; i++)
   {
      x = h * ((double) i - 0.5);
      my_sum += 4.0 / (1.0 + x * x);
   }
   pthread_mutex_lock (&global_lock);
   global_sum += my_sum;
   pthread_mutex_unlock (&global_lock);
 
   return NULL;
}
 
int main (void)
{
   pthread_t tid[THREADS];
   int i, t_num[THREADS];
   for (i = 0; i < THREADS; i++)
   {
      t_num[i] = i;
      pthread_create (&tid[i], NULL, pi_calc, &t_num[i]);
   }
   for (i = 0; i < THREADS; i++)
      pthread_join (tid[i], NULL);
   printf ("Pi = %f\n", global_sum);
}

Code:

1
2
3
4
5
 
Pi = 3141592655.589901
done in 31.109 s
 
Press ENTER to continue.

Citation:

Je suppose que le mutex 'resérialise' l'exécution...

C'est à dire ? je ne comprends pas. :question:

Même si je n'ai pas compris pourquoi la durée d'exécution est identique dans les 2 cas, j'ai essayé avec un autre exemple : un boucle pur sans paramètre ou calcul tordu et le résultat est plus que satisfaisant :

Avec multithread :
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 #include <stdio.h> #include <pthread.h> #define THREADS 2 pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER; static void *calc () { int i; double j = 0.; for (i=0;i<2000000000;i++) { j = j + 1; } pthread_mutex_lock (&global_lock); pthread_mutex_unlock (&global_lock); return NULL; } int main (void) { pthread_t tid[THREADS]; int i, t_num[THREADS]; for (i = 0; i < THREADS; i++) { t_num[i] = i; pthread_create (&tid[i], NULL, calc, NULL); } for (i = 0; i < THREADS; i++) pthread_join (tid[i], NULL); }
Durée : 37,01s user 0,00s system 193% cpu 19,112 total soit 19.1 secondes d'exécution.

version sans thread :
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 #include <stdio.h> #include <pthread.h> #define THREADS 2 pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER; static void *calc () { int i; double j = 0.; for (i=0;i<2000000000;i++) { j = j+1; } return NULL; } int main (void) { pthread_t tid[THREADS]; int i, t_num[THREADS]; for (i = 0; i < THREADS; i++) { t_num[i] = i; calc(); } }
Durée : 35,13s user 0,00s system 99% cpu 35,160 total soit 35.2 secondes d'exécution.

Par contre, je ne sais pas pourquoi, avec le précédent exemple, ça ne marche pas.

29/09/2007, 14h01
Emmanuel Delahaye

Citation:

Envoyé par MrBonheur

Par contre, je ne sais pas pourquoi, avec le précédent exemple, ça ne marche pas.

Parce que 2 processus en parallelle modifiants la même variable impliquent un mécanisme de synchronisation (mutex), qui a pour effet de ralentir l'action de chaque tâche (suspension le temps que l'écriture se termine). En définitive, on a effectué le même nombre de cycles d'écritures dans la variable commune. On a donc rien changé au temps total. (Ben oui, même avec 2 ou 50 processeurs, on peut pas écrire 'en même temps' dans la même variable. C'est ce que j'appelle la 'resérialisation...'