อัลกอริทึมของ Peterson และ Dekker ที่ตัดกัน

ฉันพยายามที่จะเข้าใจอัลกอริทึมของ Peterson และ Dekker ซึ่งคล้ายกันมากและแสดงความสมมาตรมากมาย

ฉันพยายามกำหนดอัลกอริทึมในภาษานอกระบบดังนี้:

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;

ความแตกต่างน่าจะเป็นจุดที่"You can enter next."เกิดขึ้นและความจริงที่"if it's your turn I don't want to enter any more."เกิดขึ้นใน Dekker

ในอัลกอริทึมของ Peterson กระบวนการทั้งสองดูเหมือนจะโดดเด่น กระบวนการดูเหมือนจะบังคับให้เขาเข้าไปในส่วนที่สำคัญเว้นแต่จะเป็นกระบวนการของคนอื่น

ในทางกลับกันในอัลกอริทึมของ Dekker กระบวนการทั้งสองดูเหมือนจะยอมแพ้และสุภาพ หากทั้งสองกระบวนการต้องการเข้าสู่ส่วนที่สำคัญยิ่งและเป็นกระบวนการของอีกฝ่ายหนึ่งกระบวนการจะไม่ต้องการเข้าอีกต่อไป (สิ่งนี้จำเป็นสำหรับการอดอาหาร - อิสระทำไม?)

อัลกอริทึมเหล่านี้แตกต่างกันอย่างไร ฉันจินตนาการว่าเมื่อทั้งสองกระบวนการพยายามเข้าสู่ส่วนที่สำคัญใน Peterson ของกระบวนการบอกว่า "ฉันเข้า" ในขณะที่ Dekker เป็นกระบวนการที่บอกว่า "คุณอาจเข้าสู่" บางคนสามารถอธิบายวิธีที่กระบวนการทำงานในแต่ละอัลกอริทึมได้หรือไม่? วิธีการของฉันในการวางไว้ในเงื่อนไขที่ไม่เป็นทางการ?

คำอธิบายอย่างไม่เป็นทางการของอัลกอริทึมนั้นยอดเยี่ยม

ฉันคิดว่าในทั้งสองกรณีผู้เขียนพยายามหาวิธีแก้ปัญหาที่ง่ายที่สุดที่พวกเขาสามารถคิดได้ซึ่งรับประกันได้ว่าทั้งการกีดกันซึ่งกันและกันและอิสรภาพการหยุดชะงัก อัลกอริทึมไม่ว่างหรือไม่ยุติธรรม[ed: ตามที่ระบุไว้ในความคิดเห็นอัลกอริทึมของ Peterson นั้นปราศจากความอดอยากและยุติธรรม] โซลูชันของ Dekker เป็นอัลกอริธึมการแยกซึ่งกันและกันครั้งแรกโดยใช้เพียงคำแนะนำในการโหลดและจัดเก็บ มันถูกนำมาใช้ในDijkstra, Edsger W.; "กระบวนการให้ความร่วมมือตามลำดับ" ในเอฟ Genuys เอ็ด. การเขียนโปรแกรมภาษา: นาโต้ทุกประเภทสถาบันการศึกษา , PP 43-112, นักวิชาการสื่อมวลชน 1968. หากคุณอ่านเอกสารที่คุณเห็นว่า Dijkstra พยายามทำหลายครั้งให้ตระหนักถึงปัญหาที่เกิดขึ้นกับแต่ละคนแล้วเพิ่มอีกเล็กน้อยสำหรับเวอร์ชั่นถัดไป ส่วนหนึ่งของความไม่มีประสิทธิภาพของอัลกอริธึมมาจากความจริงที่ว่าเขาเริ่มต้นด้วยอัลกอริธึมหันกลับมาแล้วพยายามปรับเปลี่ยนเพื่อให้กระบวนการสามารถดำเนินการในลำดับใด (ไม่เพียง 0,1,0,1, ... )

อัลกอริทึมของ Peterson ถูกตีพิมพ์ในปี 1981 หลังจากใช้เวลานานกว่าทศวรรษและประสบการณ์ย้อนหลังเกี่ยวกับอัลกอริธึมของ Dekker Peterson ต้องการอัลกอริทึมที่ง่ายกว่า Dekker เพื่อให้การพิสูจน์ความถูกต้องง่ายขึ้นมาก คุณจะเห็นว่าเขารู้สึกหงุดหงิดกับชุมชนจากชื่อเรื่องของกระดาษ ปีเตอร์สัน, GL; "ความเชื่อเกี่ยวกับปัญหาการกีดกันซึ่งกันและกัน" Inf พร เลทท์ , 12 (3): 115-116, 1981. อ่านเร็วมากและเขียนได้ดีมาก (และคำพูดเยาะเย้ยเกี่ยวกับวิธีการที่เป็นทางการนั้นไม่มีค่ามากนัก) บทความของปีเตอร์สันยังกล่าวถึงกระบวนการที่เขาสร้างวิธีการแก้ปัญหาจากความพยายามที่ง่ายขึ้น (เนื่องจากวิธีการแก้ปัญหาของเขานั้นง่ายกว่านั้นจึงต้องใช้ขั้นตอนกลางน้อยกว่า) โปรดทราบว่าความแตกต่างหลัก (สิ่งที่คุณเรียกว่า "การปกครอง" มากกว่า "ความอ่อนน้อม") ก็คือเพราะปีเตอร์สันเริ่มต้นใหม่ ) วนรอบการรอของเขานั้นง่ายและมีประสิทธิภาพมากขึ้น เขาตระหนักดีว่าเขาสามารถหนีไปได้ด้วยการทดสอบลูปที่เรียบง่ายในขณะที่ Dijkstra ต้องถอยกลับและลองใหม่ทุกครั้ง

ฉันรู้สึกว่าต้องพูดถึงกระดาษอัลกอริทึมเบเกอรี่สุดคลาสสิคของLamport : Lamport, Leslie; "โซลูชั่นใหม่ของปัญหาการเขียนโปรแกรมของ Dijkstra พร้อมกัน" Comm ACM 17 (8): 453-455 1974 อัลกอริทึมของเบเกอรี่นั้นง่ายกว่าอัลกอริธึมของ Dekker (และง่ายกว่าในกรณีที่มีโปรเซสเซอร์มากกว่า 2 ตัว) และได้รับการออกแบบมาโดยเฉพาะเพื่อให้ทนต่อความผิดพลาด ฉันพูดถึงมันโดยเฉพาะด้วยเหตุผลสองประการ ข้อแรกเนื่องจากให้ประวัติเล็กน้อยเกี่ยวกับคำจำกัดความของปัญหาการแยกซึ่งกันและกันและพยายามที่จะแก้ปัญหาได้ถึงปี 1974 ข้อที่สองเนื่องจากอัลกอริทึม Bakery แสดงให้เห็นว่าไม่จำเป็นต้องมีอะตอมมิกฮาร์ดแวร์เพื่อแก้ไขปัญหาการแยกกัน

ในที่สุดสิ่งที่ฉันชอบคือLamport, Leslie; "อัลกอริทึมการยกเว้นร่วมกันอย่างรวดเร็ว" Trans ACM คอมพ์ Sys , 5 (1): 1-11, 1987. ในบทความนี้ Lamport พยายามเพิ่มประสิทธิภาพการแก้ปัญหาการแยกซึ่งกันและกันในกรณี (ทั่วไป) ที่มีการแย่งชิงเล็กน้อยสำหรับส่วนที่สำคัญ อีกครั้งมันรับประกันการกีดกันซึ่งกันและกันและเสรีภาพการหยุดชะงัก แต่ไม่ยุติธรรม เป็น (ฉันเชื่อว่า) อัลกอริทึมการแยกซึ่งกันและกันครั้งแรกโดยใช้เฉพาะการอ่านและการเขียนปกติที่สามารถซิงโครไนซ์โปรเซสเซอร์ N ในเวลา O (1) เมื่อไม่มีการช่วงชิง (เมื่อมีการช่วงชิงมันจะกลับไปทดสอบ O (N)) เขาให้การสาธิตอย่างไม่เป็นทางการว่าสิ่งที่ดีที่สุดที่คุณสามารถทำได้ในกรณีที่ไม่มีการช่วงชิงคือการเข้าถึงหน่วยความจำเจ็ดครั้ง (ทั้ง Dekker และ Peterson ทำได้ด้วย 4 แต่พวกมันสามารถรองรับโปรเซสเซอร์ได้ 2 ตัวเท่านั้นเมื่อคุณขยายอัลกอริธึมเป็น N พวกเขาจะต้องเพิ่มการเข้าถึง O (N) เพิ่มเติม)

ในทั้งหมด: ฉันว่าอัลกอริทึมของ Dekker นั้นน่าสนใจเป็นส่วนใหญ่จากมุมมองทางประวัติศาสตร์ กระดาษของ Dijkstra อธิบายถึงความสำคัญของปัญหาการกีดกันซึ่งกันและกันและแสดงให้เห็นว่ามันสามารถแก้ไขได้ แต่ด้วยวิธีแก้ปัญหาย้อนหลังหลายปีที่ง่ายกว่า (และมีประสิทธิภาพมากกว่า) กว่าที่ Dekker พบ

ในบทความต่อไปนี้เราให้แบบจำลองอย่างเป็นทางการสำหรับอัลกอริทึมของ Peterson และ Dekker (และอื่น ๆ ) และเราใช้ตัวตรวจสอบแบบจำลองเพื่อพิสูจน์คุณสมบัติของพวกเขา กรุณาค้นหาผลลัพธ์ของเราในตารางด้านล่าง (คอลัมน์ "Deadlock" และ "Divergent" อ้างถึงโมเดลของเรา "ME" = TRUE หมายความว่าอัลกอริทึมนั้นถูกต้อง "Overtaking" = TRUE หมายความว่ามันยุติธรรม)

R. Meolic, T. Kapus, Z. Brezočnik ACTLW - ลอจิกการคำนวณที่อิงแอคชั่นพร้อมด้วยตัวดำเนินการเว้นแต่ว่าไม่มี สารสนเทศศาสตร์, 178 (6), pp. 1542-1557, 2008

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

อัลกอริทึมPetersonมีแรงกดดันที่เข้มงวดมากขึ้นในการเข้าสู่ส่วนที่สำคัญซึ่งอัลกอริทึมของdekkerนั้นค่อนข้างนุ่มนวลและก้าวร้าวน้อยลง เพื่อให้ชัดเจนยิ่งขึ้นลองดูตัวอย่างเกี่ยวกับวัฒนธรรมของชาวอิหร่าน ก่อนที่จะเข้าสู่ตัวอย่างนี้เป็นการดีที่จะรู้ว่าคนอิหร่านมีพฤติกรรมที่นุ่มนวลต่อกันและกันในขณะที่เข้าหาที่ไหนสักแห่ง! เดาว่ามีชายชาวอิหร่านสองคนกำลังจะเข้าไปในบ้านและบ้านหลังนั้นมีเพียงประตูเดียวที่จะเข้าไป

ตอนนี้คิดว่าทั้งสองคนจากวัฒนธรรมอื่น ( Zombian วัฒนธรรม ) ซึ่งพวกเขาไม่จริงดูแลมากเกินไปเกี่ยวกับแต่ละอื่น ๆ ในขณะเข้าที่ไหนสักแห่ง ( มันเป็นเรื่องของการเคารพขอให้คนไม่ว่าเขาต้องการที่จะเข้าหรือไม่ )

เพื่อชี้แจงข้อมูลเกี่ยวกับปัญหาเราสามารถพูดได้ว่า:

• Two Iranians = สองกระบวนการโดยใช้อัลกอริทึม Dekker
• Two Zombians = สองกระบวนการโดยใช้อัลกอริทึม Peterson

ลองมาดูกันว่ามีอะไรที่ทำในแต่ละอัลกอริทึม ( วัฒนธรรม ) ความคิดเห็นต่อไปนี้สำหรับชายชาวอิหร่านคนแรกที่จะเข้ามาในบ้านในขณะที่ใช้อัลกอริทึม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

เรามีซอมบี้สองตัวที่จะเข้าสู่บ้านโดยใช้อัลกอริทึมปีเตอร์สัน อันนี้ไปดังนี้:

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

สิ่งสำคัญคือต้องกล่าวว่าทั้งคู่ไม่ได้เข้าไปข้างในในขณะที่อีกคนหนึ่งกำลังทำอยู่ (การรวมร่วมกัน ) แต่คนอิหร่านนั้นอ่อนกว่ามาก