Đối chiếu thuật toán của Peterson và Dekker's

Tôi đang cố gắng để hiểu các thuật toán của Peterson và Dekker rất giống nhau và hiển thị rất nhiều đối xứng.

Tôi đã cố gắng xây dựng các thuật toán bằng ngôn ngữ không chính thức như sau:

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;

Sự khác biệt dường như là điểm "You can enter next."xảy ra và thực tế "if it's your turn I don't want to enter any more."xảy ra trong Dekker's.

Trong thuật toán của Peterson, hai quá trình dường như chiếm ưu thế. Một quá trình dường như buộc anh ta vào phần quan trọng trừ khi đến lượt người khác.

Ngược lại, trong thuật toán của Dekker, hai quy trình dường như là phục tùng và lịch sự. Nếu cả hai quá trình đều muốn vào phần quan trọng và đến lượt của người khác, quy trình sẽ quyết định không còn muốn vào nữa. (Điều này có cần thiết cho sự tự do đói khát không? Tại sao?)

Chính xác thì các thuật toán này khác nhau như thế nào? Tôi tưởng tượng rằng khi cả hai quá trình cố gắng vào phần quan trọng, trong Peterson, quy trình nói "Tôi nhập", trong khi trong Dekker, quy trình nói "Bạn có thể nhập". Ai đó có thể làm rõ cách các quy trình ứng xử trong mỗi thuật toán? Là cách của tôi để đặt nó trong điều khoản không chính thức?

Mô tả không chính thức của bạn về các thuật toán là tuyệt vời.

Tôi nghĩ trong cả hai trường hợp, tác giả đã cố gắng đưa ra giải pháp đơn giản nhất mà họ có thể nghĩ về điều đó đảm bảo cả sự loại trừ lẫn nhau và tự do bế tắc. Không phải thuật toán là chết đói miễn phí hoặc công bằng.[ed: như đã chỉ ra trong các bình luận, thuật toán của Peterson là chết đói và công bằng]. Giải pháp của Dekker là thuật toán loại trừ lẫn nhau đầu tiên chỉ sử dụng các hướng dẫn tải và lưu trữ. Nó được giới thiệu trong Dijkstra, Edsger W.; "Hợp tác các quy trình tuần tự", trong F. Genuys, chủ biên, Ngôn ngữ lập trình: Viện nghiên cứu nâng cao NATO , trang 43-112, Nhà xuất bản học thuật, năm 1968 . Nếu bạn đọc qua bài báo, bạn sẽ thấy Dijkstra hoạt động thông qua một số lần thử, nhận ra vấn đề với từng vấn đề, và sau đó thêm một chút nữa cho phiên bản tiếp theo. Một phần của sự kém hiệu quả của thuật toán của anh ta xuất phát từ việc anh ta bắt đầu với một thuật toán theo lượt và sau đó cố gắng sửa đổi nó để cho phép các quá trình tiến triển theo bất kỳ thứ tự nào. (Không chỉ 0,1,0,1, ...)

Thuật toán của Peterson được xuất bản năm 1981, sau hơn một thập kỷ kinh nghiệm và nhận thức sâu sắc về thuật toán của Dekker. Peterson muốn một thuật toán đơn giản hơn nhiều so với Dekker để việc chứng minh tính chính xác dễ dàng hơn nhiều. Bạn có thể thấy rằng anh ấy đã cảm thấy một số thất vọng với cộng đồng từ tiêu đề của bài báo của mình. Peterson, GL; "Những lầm tưởng về vấn đề loại trừ lẫn nhau," Inf. Proc. Lett. , 12 (3): 115-116, 1981. Đọc rất nhanh và viết rất tốt. (Và những nhận xét về những phương pháp chính thức là vô giá.) Bài viết của Peterson cũng thảo luận về quá trình ông xây dựng giải pháp của mình từ những nỗ lực đơn giản hơn. (Vì giải pháp của anh ta đơn giản hơn, nó yêu cầu ít bước trung gian hơn.) Lưu ý rằng sự khác biệt chính (cái mà bạn gọi là "sự thống trị" chứ không phải là "sự phục tùng") là do Peterson bắt đầu mới (không phải từ thuật toán quay đầu Dijkstra bắt đầu với ) vòng lặp chờ đợi của anh ta đơn giản và hiệu quả hơn. Anh ta nhận ra rằng anh ta có thể thoát khỏi thử nghiệm đơn giản trong khi Dijkstra phải lùi lại và thử lại mỗi lần.

Tôi cảm thấy tôi cũng phải đề cập đến bài viết thuật toán Bakery cổ điển của Lamport : Lamport, Leslie; "Một giải pháp mới cho vấn đề lập trình đồng thời của Dijkstra", Comm ACM 17 (8): 453-455, 1974 . Thuật toán Bakery đơn giản hơn thuật toán của Dekker (và chắc chắn đơn giản hơn trong trường hợp có hơn 2 bộ xử lý) và được thiết kế đặc biệt để có khả năng chịu lỗi. Tôi đặc biệt đề cập đến nó vì hai lý do. Thứ nhất, vì nó đưa ra một chút lịch sử về định nghĩa của vấn đề loại trừ lẫn nhau và cố gắng giải quyết nó đến năm 1974. Thứ hai bởi vì thuật toán Bakery chứng minh rằng không cần nguyên tử phần cứng để giải quyết vấn đề loại trừ lẫn nhau.

Cuối cùng, một sở thích đặc biệt của tôi là Lamport, Leslie; "Thuật toán loại trừ lẫn nhau nhanh", ACM Trans. Comp. Sys. , 5 (1): 1-11, 1987. Trong bài báo này, Lamport đã cố gắng tối ưu hóa một giải pháp cho vấn đề loại trừ lẫn nhau trong trường hợp (phổ biến) rằng có rất ít sự tranh chấp cho phần quan trọng. Một lần nữa, nó đảm bảo loại trừ lẫn nhau và tự do bế tắc, nhưng không công bằng. Đó là (tôi tin) thuật toán loại trừ lẫn nhau đầu tiên chỉ sử dụng đọc và ghi thông thường có thể đồng bộ hóa bộ xử lý N trong thời gian O (1) khi không có tranh chấp. (Khi có sự tranh chấp, nó lại rơi vào bài kiểm tra O (N).) Anh ta đưa ra một minh chứng không chính thức rằng điều tốt nhất bạn có thể làm trong trường hợp tranh chấp là bảy lần truy cập bộ nhớ. (Dekker và Peterson đều làm điều đó với 4, nhưng họ chỉ có thể xử lý 2 bộ xử lý, khi bạn mở rộng thuật toán của họ thành N, họ phải thêm một lượt truy cập O (N).)

Nói chung, tôi muốn nói rằng thuật toán của Dekker rất thú vị chủ yếu từ góc độ lịch sử. Bài viết của Dijkstra đã giải thích tầm quan trọng của vấn đề loại trừ lẫn nhau và chứng minh rằng nó có thể được giải quyết. Nhưng với nhiều năm, các giải pháp đơn giản hơn (và hiệu quả hơn) đã được tìm thấy.

Trong bài báo sau, chúng tôi đưa ra các mô hình chính thức cho thuật toán của Peterson và Dekker (và một số người khác) và chúng tôi đã sử dụng trình kiểm tra mô hình để chứng minh các thuộc tính của chúng. Vui lòng tìm kết quả của chúng tôi trong bảng bên dưới (các cột "Bế tắc" và "Phân kỳ" đề cập đến các mô hình của chúng tôi, "ME" = TRUE có nghĩa là thuật toán này là chính xác, "Vượt qua" = TRUE có nghĩa là nó công bằng).

R. Meolic, T. Kapus, Z. Brezočnik. ACTLW - Logic cây tính toán dựa trên hành động với toán tử trừ khi toán tử. Khoa học thông tin, 178 (6), trang 1542-1557, 2008.

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

Thuật toán Peterson có một áp lực nghiêm ngặt hơn khi vào phần quan trọng, trong đó thuật toán của dekker tương đối nhẹ nhàng và ít gây hấn hơn. Để làm cho nó rõ ràng hơn, hãy xem một ví dụ về văn hóa Iran. Trước khi đi vào ví dụ này, thật tốt khi biết rằng người Iran có hành vi mềm mỏng thực sự với nhau khi đi vào một nơi nào đó! Đoán hai người đàn ông Iran sẽ vào một ngôi nhà, và ngôi nhà đó chỉ có một cửa để vào.

Bây giờ hãy tưởng tượng hai người đàn ông từ một nền văn hóa khác ( Văn hóa Zombian ) mà họ không thực sự quan tâm quá nhiều về nhau khi đi vào một nơi nào đó ( Đó là vấn đề tôn trọng để hỏi ai đó liệu anh ta có muốn vào hay không ).

Để làm rõ thông tin về vấn đề chúng ta có thể nói rằng:

• Hai người Iran = Hai quy trình sử dụng thuật toán Dekker
• Hai Zombian = Hai quy trình sử dụng thuật toán Peterson

Vì vậy, hãy tìm hiểu những gì được thực hiện trong mỗi thuật toán ( văn hóa ). Các ý kiến ​​sau đây dành cho người đàn ông Iran đầu tiên sẽ vào nhà trong khi sử dụng thuật toán 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

Chúng tôi cũng có hai người Zombi sẽ vào nhà bằng thuật toán Peterson . Điều này diễn ra như sau:

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

Điều quan trọng cần đề cập là cả hai người họ sẽ không đi vào bên trong trong khi người kia đang làm như vậy ( Mutual Exlusion ) nhưng, người Iran nhẹ nhàng hơn nhiều.