Protection de tableaux dans un prog. multi-threadé [Non suivi]

**qouify** · 18/07/2007, 16h48

salut à tous,
j'ai un programme multi-threadé écrit avec la librairie pthread.
je manipule un tableau qui est accédé simultanèment par les processus mais ce tableau est partitionné de telle sorte qu'un processus ne peut accèder qu'à certains éléments du tableau auxquels les autres processus n'ont pas accès.
est ce nécessaire de le protèger par un mutex?

merci

**Médinoc** · 18/07/2007, 21h04

processus ou threads ?
Il faudrait savoir...

Enfin, si le tableau n'est jamais déplacé/redimensionné et que deux threads n'accèdent jamais aux mêmes cases, je ne pense pas qu'il soit nécessaire de protéger le tableau.

**berg** · 19/07/2007, 00h00

a mon avis il parle de thread et dit processus par abus de langage (ca m arrive aussi car implicitement je sais que je parle d un processus leger).

Essaie d utiliser les mutex_lock et mutex_unlock.

Le plus simple serait de faire un tableau de mutex de la meme taille que ton tableau TAB. Chaque case de TAB aura un mutex qui sera bloquant lors d une ecriture.

**Freed0** · 19/07/2007, 00h43

Bah nan, si il est certain qu'un thread n'ira jamais dans une autre partie du tableau que la sienne, ça sert à rien de placer des mutexs

**qouify** · 19/07/2007, 11h00

merci pour vos réponses.
effectivement je parle de threads. désolé pour cet abus de langage.
en fait j'ai un résultat surprenant. j'ai deux threads et ces deux fonctions:

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
 
void proceed0() {
   int i, n, id;
   for(id = 0;
        id < PARTITIONS && glob_keep_searching;
        id += 2) {
      for(i = glob_depth_last_dd + 1; i <= glob_depth; i++) {
         n = STATE_TREE_flush1(t, V, i);
         glob_stored1 += n;
         /*  glob_state_count[id][i] += n;  */
      }
   }
}
void proceed1() {
   int i, n, id;
   for(id = 1;
        id < PARTITIONS && glob_keep_searching;
        id += 2) {
      for(i = glob_depth_last_dd + 1; i <= glob_depth; i++) {
         n = STATE_TREE_flush1(t, V, i);
         glob_stored1 += n;
         /*  glob_state_count[id][i] += n;  */
      }
   }
}

le premier thread appelle proceed0 et le second appelle proceed1. le tableau partagé est glob_state_count. vues l'initialisation et l'incrémentation de id dans les boucles, je suis sur qu'il n'y aura pas de conflit.
quand je décommente les affectations au tableau mon temps d'exécution passe de 3 minutes à plus d'une demi heure!
avez vous une idée la dessus?
je précise que la variable glob_state_count n'est pas utilisée autre part dans le code.

**Médinoc** · 19/07/2007, 11h03

Attention, glob_stored_1 devrait être protégé.
Et on ne sait rien sur t et V.

**qouify** · 19/07/2007, 11h12

oui désolé pour cette erreur. j'ai un peu modifié le code de la fonction pour le rendre plus lisible.
dans proceed0 l'affectation est

Code :

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

1
2
 
         glob_stored0 += n;

t est un arbre de couples (char *, int) et V un pointeur sur fichier.
STATE_TREE_flush1(t, V, i) écrit séquentiellement dans le fichier V tous les éléments (str, j) tels que i == j.
mais je ne crois pas que le pb vienne de là.
veux tu que je poste le code complet?

**Fabllot** · 19/07/2007, 18h29

Bonjour!

t est un arbre de couples (char *, int) et V un pointeur sur fichier.
STATE_TREE_flush1(t, V, i) écrit séquentiellement dans le fichier V tous les éléments (str, j) tels que i == j.
mais je ne crois pas que le pb vienne de là.

Peut-être pas, mais écrire dans un même fichier en même temps avec deux threads différents, ça c'est pas terrible!!!

Sinon, que signifie les variables (ou constantes ?) "PARTITIONS" et "glob_keep_searching" ?