2017-10-19 39 views
3

Je lisais sur les obstacles trouvés un exemple dans Wikipedia. Je doute que ce soit correct. Voici le code de (https://en.wikipedia.org/wiki/Barrier_(computer_science)#Implementation)Obstacles dans l'informatique parallèle

struct barrier_type 
    { 
     // how many processors have entered the barrier 
     // initialize to 0 
     int arrive_counter; 
     // how many processors have exited the barrier 
     // initialize to P 
     int leave_counter; 
     int flag; 
     std::mutex lock; 
    }; 

// barrier for p processors 
void barrier(barrier_type* b, int p) 
{ 
    b->lock.lock(); 
    if (b->leave_counter == P) 
    { 
     if (b->arrive_counter == 0) // no other threads in barrier 
     { 
      b->flag = 0; // first arriver clears flag 
     } 
     else 
     { 
      b->lock.unlock(); 
      while (b->leave_counter != P); // wait for all to leave before clearing 
      b->lock.lock(); 
      b->flag = 0; // first arriver clears flag 
     } 
    } 
    b->arrive_counter++; 
    int arrived = b->arrive_counter; 
    b->lock.unlock(); 
    if (arrived == p) // last arriver sets flag 
    { 
     b->arrive_counter = 0; 
     b->leave_counter = 1; 
     b->flag = 1; 
    } 
    else 
    { 
     while (b->flag == 0); // wait for flag 
     b->lock.lock(); 
     b->leave_counter++; 
     b->lock.unlock(); 
    } 
} 

En fonction de barrière, avant d'entrer dans la première if bloc, leave_counter est comparée à P pour vérifier, si elle est égale à P. Toujours dans le bloc else, il y a une comparaison.

Quelle est la raison de la seconde comparaison, puisque le contrôle n'est entré que lorsque la valeur leave_counter est P? Est-ce que j'ai râté quelque chose?

+0

Vous voyez un exemple de motif de verrouillage à double vérification. http://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/ –

+0

@Yadhunandana, Vous parlez du test while (b-> leave_counter! = P)? – jwdonahue

+0

Est-ce le code C ou C++? Il est étiqueté C, mais utilise 'std :: mutex', qui est C++. Ils ne sont pas les mêmes. –

Répondre

1

Le mutex est verrouillé avant le test initial de leave_counter, bloquant tous les autres threads.

Si l'appelant est pas le premier à passer, il déverrouille le mutex puis spin-attend dans le
while (b->leave_counter != P), permettant aux autres threads de procéder.
Finalement, b->leave_counter == P et l'appelant continue.