# Algorithme de Peterson

En informatique, l'algorithme de Peterson est un algorithme d'exclusion mutuelle pour la programmation concurrente. Cet algorithme est basé sur une approche par attente active et est garanti d'être sans famine et sans interblocage. Il est constitué de deux parties : le protocole d'entrée dans la section critique et le protocole de sortie. L'algorithme présenté est une version pouvant fonctionner avec deux threads. Il a été publié par Gary Peterson en 1981.

## Description de l'algorithme

Le principe de base de l'algorithme de Peterson est que chaque thread aura accès à son tour à la section critique, et qu'un thread ne peut entrer dans la section critique que lorsque celle-ci est libre.
Chaque thread dispose d'un identifiant unique. Par convention, nous considérons que les deux threads utilisés porteront les identifiants 0 et 1. Dans son implémentation de base avec 2 processus, l'algorithme utilise un tableau de deux valeurs booléennes pour indiquer si l'un des threads est actuellement intéressé d'entrer dans la section critique. Il utilise également une autre variable pour indiquer quel thread a actuellement accès à la zone critique.
La particularité importante de cet algorithme est qu'il utilise deux variables différentes pour contrôler l'accès à la zone critique.

### Algorithme initial pour 2 processus

Ci-dessous veut_entrer est un tableau de deux booléens, indiquant pour chaque processus (0 et 1) s'il veut entrer en section critique. La variable tour indique à qui est le tour d'exécuter la section critique.
// Initialisation
bool veut_entrer[2];
veut_entrer[0] = false;
veut_entrer[1] = false;
int tour; :
| // Execution Thread n°0 T0: veut_entrer[0] = true; tour = 1; while (veut_entrer[1] && tour == 1) // attente // Début de la section critique ... // fin de la section critique veut_entrer[0] = false; | // Execution Thread n°1 P1: veut_entrer[1] = true; tour = 0; while (veut_entrer[0] && tour == 0) // attente // Début de la section critique ... // fin de la section critique veut_entrer[1] = false; |

#### Exemple en Java

Voici le pseudo-code de l'algorithme écrit en Java. Les deux threads possèdent comme identifiant 0 et 1, ils peuvent obtenir leur identifiant en appelant ThreadID.get.

#### Exemple d'application en C (avec la bibliothèque 'pthread')
## Propriétés de l'algorithme

L'algorithme satisfait plusieurs propriétés tel que l'exclusion mutuelle, l'absence de famine et d'interblocage.
Voici les développements qui prouvent ces propriétés. Remarque: elles s’appuient sur le code de l'exemple en Java.

### Exclusion mutuelle

L'algorithme de Peterson satisfait la propriété de l'exclusion mutuelle.
Preuve. Supposons qu'il ne satisfasse pas l'exclusion mutuelle. Considérons les dernières exécutions des threads A et B avant qu'elles ne s'entrecroisent au niveau de leur section critique, respectivement CS$_A$ et CS$_B$. En inspectant le code, on remarque que :
   write$_A$(drapeau[A] = vrai) ⇒ write$_A$(victime = A) ⇒ read$_A$(drapeau[B]) ⇒ read$_A$(victime) ⇒ CS$_A$, (1) write$_B$(drapeau[B] = vrai) ⇒ write$_B$(victime = B) ⇒ read$_B$(drapeau[A]) ⇒ read$_B$(victime) ⇒ CS$_B$ (2)
Supposons que A est le dernier thread a écrire dans le champ victime, cette supposition ayant peu d'impact sur la perte de généralité de l'algorithme. Ainsi, on peut écrire :
   write$_B$(victime = B) ⇒ write$_A$(victime = A) (3)
L'équation (3) suppose que A a observé la variable victime dans (1). Comme A est entré dans sa zone critique, par conséquent A a forcément observé que drapeau[B] était faux. Nous avons donc :
   write$_A$(victime = A) ⇒ read$_A$(drapeau[B] == faux) (4)
En combinant les équations (2) et (4) ensemble, on obtient :
   write$_B$(drapeau[B] = vrai) ⇒ write$_B$(victime= B) ⇒ write$_A$(victime= A) ⇒ read$_A$(drapeau[B] == faux). (5)
Via les règles de transitivité de l'implication (⇒), on peut réécrire (5) en :
   write$_B$(drapeau[B] = vrai) ⇒ read$_A$(drapeau[B] == faux).
Ce qui constitue une contradiction. En effet, aucune autre écriture de drapeau[B] n'a pu être effectuée avant les exécutions de la section critique. Par conséquent l'hypothèse de base est erronée et l'algorithme de Peterson satisfait bien la propriété de l'exclusion mutuelle. □

### Absence de famine

L'algorithme de Peterson satisfait la propriété de l'absence de famine.
Preuve. Supposons que cela ne soit pas le cas. Il y a donc au moins un des deux threads qui s'exécute pour toujours sans jamais entrer dans la section critique. Supposons que cela soit A (la preuve est similaire si on supposait que cela soit B). A exécute donc la ligne while (drapeau[j] && victime == i) en boucle, et attendant donc que soit drapeau[j] devienne faux, soit que victime soit égale à B.
Que fait B tandis que A exécute cette ligne de code ? Il doit être en train d'entrer et sortir de la zone critique de manière répétée. Cela veut donc dire que B met la variable victime à B à chaque fois qu'il veut entrer dans la section critique. Par conséquent, la variable victime est toujours égale à B et ne change jamais de valeur. Si c'est le cas, A peut alors sortir de la boucle puisqu'une des deux conditions est remplie. C'est donc une contradiction.
Si ce n'est pas ça, c'est alors parce que B est également coincée dans la boucle en attendant de pouvoir entrer dans la zone critique, attendant que soit flag[A] devienne faux soit victime soit mise à A. Mais victime ne peut pas valoir à la fois A et B. C'est donc également une contradiction. Par conséquent, l'hypothèse de base est fausse et l'algorithme satisfait bien la propriété de l'absence de famine. □

### Absence d'interblocage (deadlock)

L'algorithme de Peterson satisfait la propriété de l'absence d'interblocage.
Preuve. Comme il a déjà démontré que l'algorithme satisfait la propriété de l'absence de famine, et que la propriété de l'absence de famine est une propriété plus forte que l'absence d'interblocage, alors l'algorithme est garanti de ne pas avoir d'interblocage. □