Discussion :

[Tibapbedoum]

Bonjour,
Je voudrais décomposer une boucle-for tres grande, afin de l'exploiter par plusieurs threads...
Par conséquent, voila comment j'ai vu le probleme : si il y a 2 threads, chacun va executer une instruction sur deux. S'il y en a trois, une instruction sur 3, etc...
Voila mon bout de 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
 
/**
 * @brief Fonction de calcul de la somme.
 * On decompose la somme en autant de threads qu'il y a.
 *
 * @param num_thread Le numero du thread executant la fonction.
 * @return NULL.
 */
 
void *decomposeBoucle (void * num_thread) {
  long long i;
 
  /* Approximation de Pi = 4 * arctan(1) */
  for (i = N - *(int*) num_thread; i > 0; i = i-nb_thread) {
 
    if (i % 2 == 0) {
      /*On rentre en section critique : le thread doit finir de modifier la somme avant de pouvoir etre interrompu. */
      pthread_mutex_lock (&mutex);
      somme -= 4.0 / (2 * (double)i - 1);
      pthread_mutex_unlock (&mutex);
    }
 
    else {
      pthread_mutex_lock (&mutex);
      somme += 4.0 / (2 * (double)i - 1);
      pthread_mutex_unlock (&mutex);
    }
 
  }
 
  return NULL;
}

Remarque : N et nb_thread sont des variables globales initialisées dans le main.

Voila. Donc, ca ne marche pas... De ce que je comprend au debugage, c'est à cause des interruptions entre les differents threads, mais je ne comprend pas pourquoi cela pose probleme théoriquement (si un thread est interrompu par un autre, il reprendra là où il était une fois son tour revenu, nan ?)
Si vous pouviez m'éclairer...

[Mac LAK]

Vaudrait mieux calculer des sommes partielles dans chaque thread, puis récupérer les résultats comme valeur de retour des threads pour obtenir la somme "finale", plutôt que d'appeler un mutex à chaque étape. Parce que là, vu ton code, ça serait étonnant que tu gagnes le moindre bout de temps CPU... Les prises de mutex vont te carboniser le temps d'exécution !
Tout comme tu ne gagneras pas beaucoup de temps en utilisant plus de threads que de cœurs disponibles, d'ailleurs.

De plus, au lieu de répartir un "un calcul sur deux", ce serait préférable de séparer en "deux moitiés du tableau des valeurs" : cela accélèrera le processus pour chaque thread, car ils travailleront sur des données contigües.

[souviron34]

vu la forme iter(i) = f(iter(i-1))

il vaudrait mieux avoir la boucle initiale et voir comment la factoriser plutôt que de piocher dans une technique de parallèlisation applicable principalement à des entités indépendantes...

[Tibapbedoum]

Ok... Merci pour vos réponses, je me disais bien qu'il y avait d'autres facons de faire cela... Je ne valide pas le sujet tout de suite au cas où j'aurais d'autres questions sur ce sujet.