Peterson ve Dekker algoritmalarına zıtlık

Çok benzer simetri gösteren ve Peterson ve Dekker'in algoritmalarını anlamaya çalışıyorum.

Algoritmaları gayrı resmi bir dilde aşağıdaki gibi formüle etmeye çalıştım:

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;

Fark, "You can enter next."meydana geldiği nokta ve "if it's your turn I don't want to enter any more."Dekker'da meydana gelen gerçektir .

Peterson algoritmasında, iki işlem baskın görünüyor. Bir süreç, diğerinin sırası gelmediği sürece kritik bölüme girmeye zorlar gibi görünüyor.

Tersine, Dekker'ın algoritmasında, iki işlem itaatkâr ve kibar görünüyor. Her iki işlem de kritik bölüme girmek isterse ve diğeri sırası ise, işlem artık girmek istemediğine karar verir. (Bu açlık-özgürlük için gerekli midir? Neden?)

Bu algoritmalar tam olarak nasıl farklılık gösterir? Her iki işlem de kritik bölüme girmeye çalıştığında, Peterson'da, işlemin "giriyorum", Dekker'de işlem "Girebilirsiniz" yazdığını hayal ediyorum. Birisi işlemlerin her algoritmada nasıl davrandığını temizleyebilir mi? Gayri resmi olarak koyma yolum doğru mu?

Algoritmaların gayrı resmi açıklamaları harika.

Her iki durumda da, yazarın, hem karşılıklı dışlanma hem de kilitlenme özgürlüğü güvencesi verdiğini düşünebilecekleri en basit çözümü bulmaya çalıştığını düşünüyorum. Her iki algoritma da açlıktan arınmış veya adil değildir.[ed: yorumlarda belirtildiği gibi, Peterson algoritması açlıktan yoksun ve adil]. Dekker'ın çözümü sadece yükleme ve saklama talimatlarını kullanan ilk karşılıklı dışlama algoritmasıydı. Bu tanıtıldı Dijkstra, Edsger W .; F. Genuys, ed., Programlama Dilleri: NATO Gelişmiş Çalışma Enstitüsü , s. 43-112, Academic Press, 1968 . Makaleyi okursanız, Dijkstra'nın birkaç denemede çalıştığını, her birinin problemini tanıdığını ve daha sonra bir sonraki versiyon için biraz daha fazlasını eklediğini görürsünüz. Algoritmasının verimsizliğinin bir kısmı, bir dönüş algoritmasıyla başlaması ve süreçlerin herhangi bir sırada ilerlemesine izin vermek için onu değiştirmeye çalışmasından kaynaklanmaktadır. (Sadece 0,1,0,1, ...)

Peterson algoritması 1981 yılında, Dekker algoritması hakkında on yıldan fazla bir deneyime ve göreve açıklıktan sonra yayınlandı. Peterson, Dekker'den daha basit bir algoritma istedi, böylece doğruluğun ispatı daha kolaydı. Toplulukla ilgili makalesinin başlığından biraz sıkıntı duyduğunu görebilirsiniz. Peterson, GL; "Karşılıklı dışlanma sorunu hakkındaki efsaneler " Inf. Proc. Lett. , 12 (3): 115-116, 1981. Çok hızlı okundu ve çok iyi yazılmış. (Ve biçimsel yöntemlerle ilgili açık sözler paha biçilmezdir.) Peterson'nun makalesi, çözümünü daha basit denemelerle inşa ettiği süreci de tartışıyor. (Çözümü daha basit olduğu için, daha az ara adım gerektiriyordu.) Asıl farkın ("boyun eğebilme" yerine "baskınlık" dediğiniz şey), Peterson'nın yeni başladığı (Dijkstra'nın başlattığı algoritmadan değil) olduğunu söyledi. ) onun bekleme döngüsü daha basit ve daha verimlidir. Dijkstra'nın geri çekilip her seferinde yeniden denemek zorunda kalırken basit bir döngüsel testten kurtulabildiğini fark etti.

Ayrıca, Lamport'un klasik Fırıncılık algoritması kağıdından da bahsetmek zorunda olduğumu hissediyorum: Lamport, Leslie; "Dijkstra'nın Eşzamanlı Programlama Probleminin Yeni Bir Çözümü", Comm ACM 17 (8): 453-455, 1974 . Fırın algoritması, muhtemelen Dekker algoritmasından daha basittir (ve 2'den fazla işlemci durumunda kesinlikle basittir) ve özellikle hataya dayanıklı olacak şekilde tasarlanmıştır. Özellikle iki nedenden söz ediyorum. Birincisi, karşılıklı dışlama sorununun tanımı hakkında biraz tarih yazdığı ve bunu 1974'e kadar çözme girişiminde bulunduğundan.

Sonunda, belli bir favorim Lamport, Leslie; "Hızlı Bir Karşılıklı Dışlama Algoritması," ACM Trans. Zorunlu. Sist. , 5 (1): 1-11, 1987. Bu makalede, Lamport (ortak) durumunda karşılıklı dışlama sorununa yönelik bir çözümü optimize etmeye çalışıyordu ve kritik bölüm için çok az çekişme vardı. Yine, karşılıklı dışlanma ve kilitlenme özgürlüğünü garanti eder, ancak adaleti garanti etmez. Çekişme olmadığında N işlemcilerini O (1) zamanında eşitleyebilen yalnızca normal okuma ve yazma yöntemlerini kullanan ilk karşılıklı dışlama algoritmasıdır (inanıyorum). (Çekişme olduğunda, bir O (N) testine geri dönüyor.) Çekişme ücretsiz vakasında yapabileceğiniz en iyi şeyin yedi bellek erişimi olduğunu resmi olmayan bir şekilde gösteriyor. (Dekker ve Peterson, her ikisini de 4'le yaparlar, ancak algoritmalarını N'ye genişlettiğinizde sadece 2 işlemciyi kaldırabilirler, fazladan O (N) erişimi eklemek zorunda kalırlar.)

Sonuçta: Dekker'in algoritmasının kendisinin temelde tarihsel açıdan ilginç olduğunu söyleyebilirim. Dijkstra'nın makalesi karşılıklı dışlama sorununun önemini açıkladı ve çözülebileceğini gösterdi. Ancak uzun yıllar boyunca, Dekker'den daha basit (ve daha verimli) çözümler bulundu.

Aşağıdaki yazıda Peterson ve Dekker algoritmaları için resmi modeller (ve diğerleri) verdik ve özelliklerini kanıtlamak için model denetleyiciyi kullandık. Lütfen, sonuçlarımızı aşağıdaki tabloda bulun ("Kilitlenme" ve "Divergent" sütunları modellerimizle ilgilidir, "ME" = TRUE, algoritmanın doğru olduğu, "Sollama" = TRUE anlamına gelir).

R. Meolic, T. Kapus, Z. Brezočnik. ACTLW - Operatör Olmadan İşlem Tabanlı Hesaplama Ağacı Mantığı. Bilişim Bilimleri, 178 (6), s. 1542-1557, 2008.

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

Peterson algoritmasının, dekker'ın algoritmasının nispeten daha yumuşak ve daha az agresif olduğu kritik bölüme girme konusunda daha katı bir baskısı var . Daha açık hale getirmek için İran kültürü ile ilgili bir örneği inceleyelim. Bu örneğe girmeden önce, bir yere girerken İran halkının birbirlerine gerçek bir yumuşak davranışı olduğunu bilmek güzel! Sanırım iki İranlı adam bir eve girecek ve o evin girecek tek bir kapısı var.

Şimdi başka bir kültürden ( Zomb Kültürü ) iki adamı bir yere girerken aslında birbirleriyle çok fazla ilgilenmediklerini hayal edin ( Birine girmek isteyip istemediğini sormak bir saygı meselesidir ).

Sorunla ilgili bilgileri netleştirmek için şunu söyleyebiliriz:

• İki İranlı = Dekker algoritmasını kullanan iki süreç
• İki Zombian = Peterson algoritmasını kullanan iki süreç

Öyleyse her algoritmada ( kültür ) neler yapıldığını bulalım . Aşağıdaki yorumlar , Dekker algoritmasını kullanırken eve giren ilk İranlı adam içindir :

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

Ayrıca Peterson algoritmasını kullanarak eve girecek iki Zombimiz var . Bu, aşağıdaki gibi gider:

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

Her ikisinin de içeri girmeyeceğini, diğeri bunu yaparken ( Karşılıklı Dışlanma ) bahsetmek önemlidir, ancak İran halkı çok daha yumuşaktır.