Contraster les algorithmes de Peterson et de Dekker

J'essaie de comprendre les algorithmes de Peterson et Dekker qui sont très similaires et présentent beaucoup de symétries.

J'ai essayé de formuler les algorithmes en langage informel comme suit:

Peterson's: "I want to enter."                 flag[0]=true;
            "You can enter next."              turn=1;
            "If you want to enter and          while(flag[1]==true&&turn==1){
            it's your turn I'll wait."         }
            Else: Enter CS!                    // CS
            "I don't want to enter any more."  flag[0]=false;

Dekker's:   "I want to enter."                 flag[0]=true;
            "If you want to enter              while(flag[1]==true){
             and if it's your turn               if(turn!=0){
             I don't want to enter any more."      flag[0]=false;
            "If it's your turn                     while(turn!=0){
             I'll wait."                           }
            "I want to enter."                     flag[0]=true;
                                                 }
                                               }
            Enter CS!                          // CS
            "You can enter next."              turn=1;
            "I don't want to enter any more."  flag[0]=false;

La différence semble être le point où "You can enter next."se produit et le fait que "if it's your turn I don't want to enter any more."se produit chez Dekker.

Dans l'algorithme de Peterson, les deux processus semblent être dominants. Un processus semble forcer à entrer dans la section critique à moins que ce soit à son tour.

À l'inverse, dans l'algorithme de Dekker, les deux processus semblent être soumis et polis. Si les deux processus veulent entrer dans la section critique et que c'est au tour de l'autre, le processus décide de ne plus vouloir entrer. (Est-ce nécessaire pour la liberté de famine? Pourquoi?)

En quoi ces algorithmes diffèrent-ils exactement? J'imagine que lorsque les deux processus tentent d'entrer dans la section critique, chez Peterson, le processus dit "j'entre", tandis que dans Dekker, le processus indique "vous pouvez entrer". Quelqu'un peut-il clarifier le comportement des processus dans chaque algorithme? Est-ce que ma façon de le dire en termes informels est correcte?

Vos descriptions informelles des algorithmes sont merveilleuses.

Je pense que dans les deux cas, l'auteur essayait de trouver la solution la plus simple qui soit, qui garantisse à la fois l'exclusion mutuelle et la liberté de blocage. Aucun des algorithmes n'est libre ou équitable.[ed: comme indiqué dans les commentaires, l'algorithme de Peterson est libre et juste de la famine]. La solution de Dekker était le premier algorithme d'exclusion mutuelle utilisant uniquement des instructions de chargement et de stockage. Il a été introduit à Dijkstra, Edsger W .; "Coopération des processus séquentiels", in F. Genuys, ed., Langages de programmation: Institut d'études avancées de l'OTAN , p. 43-112, Academic Press, 1968 . Si vous lisez le journal, vous verrez que Dijkstra essaie plusieurs tentatives, en reconnaissant le problème avec chacune d’elles, puis en ajoutant un peu plus pour la prochaine version. Une partie de l'inefficacité de son algorithme provient du fait qu'il commence par un algorithme de prise de tour, puis qu'il tente de le modifier pour permettre aux processus de progresser dans n'importe quel ordre. (Pas seulement 0,1,0,1, ...)

L'algorithme de Peterson a été publié en 1981, après plus d'une décennie d'expérience et de recul sur l'algorithme de Dekker. Peterson voulait un algorithme beaucoup plus simple que Dekker, de sorte que la preuve de l'exactitude est beaucoup plus facile. Vous pouvez voir qu'il ressentait une certaine frustration à l'égard de la communauté d'après le titre de son document. Peterson, GL; "Les mythes sur le problème de l'exclusion mutuelle", Inf. Proc. Lett. , 12 (3): 115-116, 1981. Très rapide lecture et très bien écrit. (Et les remarques sournoises sur les méthodes formelles sont inestimables.) Le papier de Peterson décrit également le processus par lequel il a construit sa solution à partir de tentatives plus simples. (Comme sa solution est plus simple, elle nécessite moins d'étapes intermédiaires.) Notez que la principale différence (ce que vous appelez "dominance" plutôt que "soumission") est que Peterson a débuté à l’origine (pas à partir de l’algorithme de prise de tour par lequel Dijkstra a commencé ) sa boucle d’attente est plus simple et plus efficace. Il se rend compte qu'il peut tout simplement se passer de simples tests en boucle pendant que Dijkstra devait reculer et réessayer à chaque fois.

Je pense que je dois également mentionner le papier classique de l'algorithme de Bakery de Lamport : Lamport, Leslie; "Une nouvelle solution du problème de programmation concurrente de Dijkstra", Comm ACM 17 (8): 453-455, 1974 . L'algorithme Bakery est sans doute plus simple que l'algorithme de Dekker (et certainement plus simple dans le cas de plus de 2 processeurs) et est spécifiquement conçu pour être tolérant aux pannes. Je le mentionne spécifiquement pour deux raisons. D'abord, parce qu'il donne un peu d'histoire sur la définition du problème de l'exclusion mutuelle et tente de le résoudre jusqu'en 1974. Deuxièmement, parce que l'algorithme de Bakery démontre qu'aucune atomicité matérielle n'est nécessaire pour résoudre le problème de l'exclusion mutuelle.

Enfin, un de mes préférés est Lamport, Leslie; "Un algorithme d'exclusion mutuelle rapide", ACM Trans. Comp. Sys. 5 (1): 1 à 11, 1987. Dans cet article, Lamport essayait d'optimiser une solution au problème de l'exclusion mutuelle dans le cas (commun) où il y avait peu de conflit pour la section critique. Encore une fois, cela garantit l'exclusion mutuelle et la liberté de blocage, mais pas l'équité. C'est (je crois) le premier algorithme d'exclusion mutuelle n'utilisant que des lectures et des écritures normales pouvant synchroniser N processeurs en un temps O (1) lorsqu'il n'y a pas de conflit. (En cas de conflit, le test se base sur un test O (N).) Il donne une démonstration informelle que, dans le cas d'un conflit sans contention, le mieux que vous puissiez faire est de disposer de sept accès en mémoire. (Dekker et Peterson le font tous les deux avec 4, mais ils ne peuvent gérer que 2 processeurs. Lorsque vous étendez leurs algorithmes sur N, ils doivent ajouter un accès supplémentaire en O (N).)

Dans l'ensemble: je dirais que l'algorithme de Dekker lui-même est intéressant principalement d'un point de vue historique. L'article de Dijkstra expliquait l'importance du problème de l'exclusion mutuelle et démontrait qu'il pouvait être résolu. Mais avec de nombreuses années de recul, des solutions plus simples (et plus efficaces) que celles de Dekker ont été trouvées.

Dans l'article suivant, nous donnons des modèles formels pour les algorithmes de Peterson et de Dekker (et quelques autres) et nous avons utilisé le vérificateur de modèles pour prouver leurs propriétés. Veuillez trouver nos résultats dans le tableau ci-dessous (les colonnes "Blocage" et "Divergent" renvoient à nos modèles, "ME" = VRAI signifie que l'algorithme est correct, "Overtaking" = VRAI signifie qu'il est juste).

R. Meolic, T. Kapus, Z. Brezočnik. ACTLW - Une logique d'arborescence de calcul basée sur les actions avec un opérateur différent. Sciences de l'information, 178 (6), p. 1542-1557, 2008.

https://doi.org/10.1016/j.ins.2007.10.023

L' algorithme de Peterson a une pression plus stricte pour entrer dans la section critique, alors que l'algorithme de dekker est relativement plus doux et moins agressif. Pour être plus clair, voyons un exemple de la culture iranienne. Avant d'entrer dans cet exemple, il est bon de savoir que les iraniens ont un comportement vraiment doux les uns envers les autres lorsqu'ils entrent quelque part! Je suppose que deux hommes iraniens vont entrer dans une maison et cette maison n’a qu’une porte.

Imaginons maintenant deux hommes d'une autre culture (culture zombienne ) auxquels ils ne s'intéressent pas vraiment l'un l'autre en entrant quelque part ( c'est une question de respect de demander à quelqu'un s'il veut entrer ou non ).

Pour clarifier les informations sur le problème, nous pouvons dire que:

• Deux Iraniens = Deux processus utilisant l'algorithme Dekker
• Deux zombiens = deux processus utilisant l'algorithme de Peterson

Découvrons donc ce qui est fait dans chaque algorithme ( culture ). Les commentaires suivants s’appliquent au premier homme iranien qui va entrer dans la maison en utilisant l’ algorithme Dekker :

p0:
   wants_to_enter[0] ← true // Goes through the house entrance
   while wants_to_enter[1] { // If the other man wants to enter too
      if turn ≠ 0 { // Then see if it is your turn or not
         wants_to_enter[0] ← false // If it is not your turn don't go furthur
         while turn ≠ 0 { // and wait until it is your turn
           // busy wait
         }
         wants_to_enter[0] ← true // when it is your turn go through the door
      }
   }

   // critical section
   ...
   turn ← 1
   wants_to_enter[0] ← false // Set the turn for the other man
   // remainder section

Nous avons également deux Zombiens qui vont entrer dans la maison en utilisant l' algorithme de Peterson . Celui-ci va comme suit:

P0:     
  flag[0] = true; // Goes through the house entrance
  turn = 1; // Set the turn for himself
  while (flag[1] && turn == 1) // Wait until the other one is going in
  {
   // busy wait
  }
   // critical section
      ...
   // end of critical section
  flag[0] = false; // Done going inside

Il est important de mentionner que les deux ne vont pas à l'intérieur alors que l'autre le fait ( exclusion mutuelle ), mais les Iraniens sont beaucoup plus douces.