Discussion :

[black_hole]

Bonjour,

Je suis sur un programme qui effectue des traitement sur des blocs de données partagés.
J'ai plusieurs thread qui ont accès à ces blocs de données et ils doivent faire des calculs sur ces blocs.

Pour cela j'ai donc cré un bloc de données:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
class Block
{
 
public:
    int X;
    int Y;
    volatile int Processed;
    double tab[64];
 
    Block(int Xin,int Yin){X=Xin;Y=Yin;Processed=0;}
};

Et j'ai mon code dans mon thread qui accède à mon bloque. Pour empécher l'accès du bloque à d'autre thread, je met la variable à 1 et je teste avant l'accès au bloque si cette variable est a 1. Si elle est a un je ne fais pas de calcul comme dans le code suivant:

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
 
vector <Block *> * Regions = t->DCTBuf[0]->Regions;
    unsigned int size = Regions->size();
 
    while(!j)
    {
 
        if( (*Regions)[i]->Processed == 1)
        {
            fprintf(fp,"CPU %d region %d offset %d\n",CPU,i,0);
            (*Regions)[i]->Processed++; // Fermeture de l'acces au block
            t->ProcessBlock((*Regions)[i],0);
 
        }
 
        i++;
        if(i >= size )
        {
            j = 1;
            break;
        }
    }

Pour vérifier que ca fonctionne bien j'écris dans un fichier les différents accès aux ressourses.

Le problème c'est que visiblement malgrès le teste avant le traitement du bloque, il semblerait que certains bloques soient traités plusieurs fois.

Pourquoi ca se produit alors que j'ai fait en sorte de faire un teste avant le traitement ?

Si quelqu'un peut m'éclairer?

D'avance merci.

[Médinoc]

Il y a une race condition entre le test de Processed et sa modification. Entre ces deux moments, un autre thread peut lui aussi lire Processed, voir qu'il est à zéro et se préparer à modifier...

Tu devrait utiliser les outils spécifiques au multithreading pour verrouiller tes blocs. Ou au moins, utiliser une fonction atomique de test-and-set (comme InterlockedCompareExchange() sous Windows) à la place de ta lecture et écriture séparées.

[Joel F]

on synchronise avec des mutex pas avec des variables volatile.