M.

Ben-Ari

Principles of Concurrent and Distributed Programming

Second Edition

Addison-Wesley, 2006

c Mordechai Ben-Ari 2006

­
 Computer Time

 -
0 100 200 300 400 500
time (nanoseconds) →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 1.1
 Human Time

 -
0 100 200 300 400 500
time (seconds) →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 1.2
 Concurrency in an Operating System

I/O

Computation
6 6
start I/O end I/O

time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 1.3
 Interleaving as Choosing Among Processes

p3, . . .
cpp
6

p1, r1, p2, q1  q2, . . .

cpq
6
I
@
@
@ r2, . . .

cpr
6

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.1
 Possible Interleavings

p1→q1→p2→q2,
p1→q1→q2→p2,
p1→p2→q1→q2,
q1→p1→q2→p2,
q1→p1→p2→q2,
q1→q2→p1→p2.

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.2
 Algorithm 2.1: Trivial concurrent program
integer n ← 0
p q
integer k1 ← 1 integer k2 ← 2
p1: n ← k1 q1: n ← k2

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.3
 Algorithm 2.2: Trivial sequential program
integer n ← 0
integer k1 ← 1
integer k2 ← 2
p1: n ← k1
p2: n ← k2

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.4
 State Diagram for a Sequential Program

' $' $' $

s- p1: n ← k1 p2: n ← k2 (end)
k1 = 1, k2 = 2 k1 = 1, k2 = 2
- -
k1 = 1, k2 = 2
& n=0 %& n=1 %& n=2 %

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.5
 State Diagram for a Concurrent Program
r
' ? $
p1: n ← k1
q1: n ← k2
k1 = 1, k2 = 2
n=0
& %
@
@
' $ '@ $
@
R
(end) p1: n ← k1
q1: n ← k2 (end)
k1 = 1, k2 = 2 k1 = 1, k2 = 2
&n = 1 % &n = 2 %

' ? $ ' ? $
(end) (end)
(end) (end)
k1 = 1, k2 = 2 k1 = 1, k2 = 2
&n = 2 % &n = 1 %

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.6
 Scenario for a Concurrent Program

Process p Process q n k1 k2
p1: n←k1 q1: n←k2 0 1 2
(end) q1: n←k2 1 1 2
(end) (end) 2 1 2

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.7
 Multitasking System

R Operating R R R R
e e Program 1 e Program 2 e Program 3 e Program 4
g System g g g g
XXX *


XXX 
XXX  
XXX 
XXz 
R
e CPU
g

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.8
 Multiprocessor Computer

Global
Memory

CPU CPU CPU

Local Local Local

Memory Memory Memory

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.9
 Inconsistency Caused by Overlapped Execution

Global memory

0000 0000 0000 0011


* YH
H

0000 0000 0000 0001 0000 0000 0000 0010

Local memory Local memory

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.10
 Distributed Systems Architecture

-
Node  Node Node  Node

6@I@@  6 6
@ @
@ @
@ @R ?
? @ ?

Node - Node Node - Node

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.11
 Algorithm 2.3: Atomic assignment statements
integer n ← 0
p q
p1: n ← n + 1 q1: n ← n + 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.12
 Scenario for Atomic Assignment Statements

Process p Process q n Process p Process q n

p1: n←n+1 q1: n←n+1 0 p1: n←n+1 q1: n←n+1 0
(end) q1: n←n+1 1 p1: n←n+1 (end) 1
(end) (end) 2 (end) (end) 2

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.13
 Algorithm 2.4: Assignment statements with one global reference
integer n ← 0
p q
integer temp integer temp
p1: temp ← n q1: temp ← n
p2: n ← temp + 1 q2: n ← temp + 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.14
 Correct Scenario for Assignment Statements

Process p Process q n p.temp q.temp

p1: temp←n q1: temp←n 0 ? ?
p2: n←temp+1 q1: temp←n 0 0 ?
(end) q1: temp←n 1 0 ?
(end) q2: n←temp+1 1 0 1
(end) (end) 2 0 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.15
 Incorrect Scenario for Assignment Statements

Process p Process q n p.temp q.temp

p1: temp←n q1: temp←n 0 ? ?
p2: n←temp+1 q1: temp←n 0 0 ?
p2: n←temp+1 q2: n←temp+1 0 0 0
(end) q2: n←temp+1 1 0 0
(end) (end) 1 0 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.16
 Algorithm 2.5: Stop the loop A
integer n ← 0
boolean flag ← false
p q
p1: while flag = false q1: flag ← true
p2: n←1−n q2:

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.17
 Algorithm 2.6: Assignment statement for a register machine
integer n ← 0
p q
p1: load R1,n q1: load R1,n
p2: add R1,#1 q2: add R1,#1
p3: store R1,n q3: store R1,n

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.18
 Register Machine

Memory Memory Memory

··· 0 ··· ··· 0 ··· ··· 1 ···

Load 6Store
?
0 1 1

Registers Registers Registers

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.19
 Scenario for a Register Machine

Process p Process q n p.R1 q.R1

p1: load R1,n q1: load R1,n 0 ? ?
p2: add R1,#1 q1: load R1,n 0 0 ?
p2: add R1,#1 q2: add R1,#1 0 0 0
p3: store R1,n q2: add R1,#1 0 1 0
p3: store R1,n q3: store R1,n 0 1 1
(end) q3: store R1,n 1 1 1
(end) (end) 1 1 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.20
 Algorithm 2.7: Assignment statement for a stack machine
integer n ← 0
p q
p1: push n q1: push n
p2: push #1 q2: push #1
p3: add q3: add
p4: pop n q4: pop n

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.21
 Stack Machine

Memory Memory Memory

··· 0 ··· ··· 0 ··· ··· 1 ···

Push A A Pop
K
AU A
··· 0 1 ··· 1 ··· 1

Stack Stack Stack

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.22
 Algorithm 2.8: Volatile variables
integer n ← 0
p q
integer local1, local2 integer local
p1: n ← some expression q1: local ← n + 6
p2: computation not using n q2:
p3: local1 ← (n + 5) ∗ 7 q3:
p4: local2 ← n + 5 q4:
p5: n ← local1 * local2 q5:

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.23
 Algorithm 2.9: Concurrent counting algorithm
integer n ← 0
p q
integer temp integer temp
p1: do 10 times q1: do 10 times
p2: temp ← n q2: temp ← n
p3: n ← temp + 1 q3: n ← temp + 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.24
 Concurrent Program in Pascal
1 program count;
2 var n: integer := 0;
3

4 procedure p;
5 var temp, i : integer;
6 begin
7 for i := 1 to 10 do
8 begin
9 temp := n;
10 n := temp + 1
11 end
12 end;
13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.25
 Concurrent Program in Pascal

16 procedure q;
17 var temp, i : integer;
18 begin
19 for i := 1 to 10 do
20 begin
21 temp := n;
22 n := temp + 1
23 end
24 end;
25

26 begin
27 cobegin p; q coend;
28 writeln(’ The value of n is ’ , n)
29 end.

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.26
 Concurrent Program in C
1 int n = 0;
2

3 void p() {
4 int temp, i ;
5 for (i = 0; i < 10; i ++) {
6 temp = n;
7 n = temp + 1;
8 }
9 }
10

11

12

13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.27
 Concurrent Program in C

16 void q() {
17 int temp, i ;
18 for (i = 0; i < 10; i ++) {
19 temp = n;
20 n = temp + 1;
21 }
22 }
23

24 void main() {
25 cobegin { p(); q(); }
26 cout << "The value of n is " << n << "\n";
27 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.28
 Concurrent Program in Ada
1 with Ada.Text_IO; use Ada.Text_IO;
2 procedure Count is
3 N: Integer := 0;
4 pragma Volatile(N);
5

6 task type Count_Task;

7 task body Count_Task is
8 Temp: Integer;
9 begin
10 for I in 1..10 loop
11 Temp := N;
12 N := Temp + 1;
13 end loop;
14 end Count_Task;
15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.29
 Concurrent Program in Ada

16 begin
17 declare
18 P, Q: Count_Task;
19 begin
20 null ;
21 end;
22 Put_Line("The value of N is " & Integer’ Image(N));
23 end Count;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.30
 Concurrent Program in Java
1 class Count extends Thread {
2 static volatile int n = 0;
3

4 public void run() {

5 int temp;
6 for (int i = 0; i < 10; i ++) {
7 temp = n;
8 n = temp + 1;
9 }
10 }
11

12

13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.31
 Concurrent Program in Java

16 public static void main(String[] args ) {

17 Count p = new Count();
18 Count q = new Count();
19 p. start ();
20 q. start ();
21 try {
22 p. join ();
23 q. join ();
24 }
25 catch (InterruptedException e) { }
26 System.out.println ("The value of n is " + n);
27 }
28 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.32
 Concurrent Program in Promela
1 #include "for.h"
2 #define TIMES 10
3 byte n = 0;
4

5 proctype P() {
6 byte temp;
7 for (i ,1, TIMES)
8 temp = n;
9 n = temp + 1
10 rof (i )
11 }
12

13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.33
 Concurrent Program in Promela

16 init {
17 atomic {
18 run P();
19 run P()
20 }
21 (_nr_pr == 1);
22 printf ("MSC: The value is %d\n", n)
23 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.34
 Frog Puzzle


M→ M→ M→ M→ ←F ←F ←F ←F


c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.35
 One Step of the Frog Puzzle


M→ M→ M→ M→ ←F ←F ←F ←F


c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.36
 Final State of the Frog Puzzle


←F ←F ←F ←F M→ M→ M→ M→


c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.37
 (Partial) State Diagram for the Frog Puzzle
 
 
MM t FF 
H XXX
   HH X
z
 
9  
  
  j
H
t MMFF  
 M t MFF  ···
×
 ? 

MFM t F 
 HH

 
  HH
j 


MF t MF 
HH 
MFMF t 

 
  HH
j   ? 
t FMMF 
 
MFFM t  

MF t FM 

  
 
  ?  
 


F t MMF  MFF t M   t FMFM 
× ×
 ? 

F t MFM 

 ? 

FFM t M 

 ? 

FF t MM 
×
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.38
 Algorithm 2.10: Incrementing and decrementing
integer n ← 0
p q
integer temp integer temp
p1: do K times q1: do K times
p2: temp ← n q2: temp ← n
p3: n ← temp + 1 q3: n ← temp − 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.39
 Algorithm 2.11: Zero A
boolean found
p q
integer i ← 0 integer j ← 1
p1: found ← false q1: found ← false
p2: while not found q2: while not found
p3: i←i+1 q3: j←j−1
p4: found ← f(i) = 0 q4: found ← f(j) = 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.40
 Algorithm 2.12: Zero B
boolean found ← false
p q
integer i ← 0 integer j ← 1
p1: while not found q1: while not found
p2: i←i+1 q2: j←j−1
p3: found ← f(i) = 0 q3: found ← f(j) = 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.41
 Algorithm 2.13: Zero C
boolean found ← false
p q
integer i ← 0 integer j ← 1
p1: while not found q1: while not found
p2: i←i+1 q2: j←j−1
p3: if f(i) = 0 q3: if f(j) = 0
p4: found ← true q4: found ← true

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.42
 Algorithm 2.14: Zero D
boolean found ← false
integer turn ← 1
p q
integer i ← 0 integer j ← 1
p1: while not found q1: while not found
p2: await turn = 1 q2: await turn = 2
turn ← 2 turn ← 1
p3: i←i+1 q3: j←j−1
p4: if f(i) = 0 q4: if f(j) = 0
p5: found ← true q5: found ← true

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.43
 Algorithm 2.15: Zero E
boolean found ← false
integer turn ← 1
p q
integer i ← 0 integer j ← 1
p1: while not found q1: while not found
p2: await turn = 1 q2: await turn = 2
turn ← 2 turn ← 1
p3: i←i+1 q3: j←j−1
p4: if f(i) = 0 q4: if f(j) = 0
p5: found ← true q5: found ← true
p6: turn ← 2 q6: turn ← 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.44
 Algorithm 2.16: Concurrent algorithm A
integer array [1..10] C ← ten distinct initial values
integer array [1..10] D
integer myNumber, count
p1: myNumber ← C[i]
p2: count ← number of elements of C less than myNumber
p3: D[count + 1] ← myNumber

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.45
 Algorithm 2.17: Concurrent algorithm B
integer n ← 0
p q
p1: while n < 2 q1: n ← n + 1
p2: write(n) q2: n ← n + 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.46
 Algorithm 2.18: Concurrent algorithm C
integer n ← 1
p q
p1: while n < 1 q1: while n >= 0
p2: n←n+1 q2: n←n−1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.47
 Algorithm 2.19: Stop the loop B
integer n ← 0
boolean flag ← false
p q
p1: while flag = false q1: while flag = false
p2: n←1−n q2: if n = 0
p3: q3: flag ← true

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.48
 Algorithm 2.20: Stop the loop C
integer n ← 0
boolean flag ← false
p q
p1: while flag = false q1: while n = 0 // Do nothing
p2: n←1−n q2: flag ← true

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.49
 Algorithm 2.21: Welfare crook problem
integer array[0..N] a, b, c ← . . . (as required)
integer i ← 0, j ← 0, k ← 0
loop
p1: if condition-1
p2: i←i+1
p3: else if condition-2
p4: j←j+1
p5: else if condition-3
p6: k←k+1
else exit loop

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 2.50
 Algorithm 3.1: Critical section problem
global variables
p q
local variables local variables
loop forever loop forever
non-critical section non-critical section
preprotocol preprotocol
critical section critical section
postprotocol postprotocol

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.1
 Critical Section

fff

HH
H

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.2
 Algorithm 3.2: First attempt
integer turn ← 1
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: await turn = 1 q2: await turn = 2
p3: critical section q3: critical section
p4: turn ← 2 q4: turn ← 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.3
 Algorithm 3.3: History in a sequential algorithm
integer a ← 1, b ← 2
p1: Millions of statements
p2: a ← (a+b)*5
p3: . . .

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.4
 Algorithm 3.4: History in a concurrent algorithm
integer a ← 1, b ← 2
p q
p1: Millions of statements q1: Millions of statements
p2: a ← (a+b)*5 q2: b ← (a+b)*5
p3: . . . q3: . . .

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.5
 First States of the State Diagram

   
t - p1,q1,1 - p1,q2,1  
   
 

?  ? 
p2,q1,1 - p2,q2,1  
   
 

? ?

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.6
 State Diagram for the First Attempt
r- 
 p1,q1,1 

 ?
 
p1,q2,1 


- p2,q1,1 H
HH
? Hj ?
p2,q2,1 
H
p3,q1,1 H
HH
? j ?
H
p3,q2,1 
H
p4,q1,1 H
HH
? j ?
H
p4,q2,1 
H
p1,q1,2 H
HH
? j ?
H
H
- p2,q1,2  p1,q2,2

 ?
 
? 
- p2,q2,2  p1,q3,2

 ?
 
? 
- p2,q3,2  p1,q4,2


 
? 
- p2,q4,2

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.7
 Alternate Layout for the First Attempt (Not in the Book)
s

? ?   ?   ? 
p1,q1,1 - p1,q2,1  p1,q1,2 - p1,q2,2
       


? ?  ?   ?   ?
p2,q1,1 - p2,q2,1  
- p2,q1,2 p1,q3,2
       
 

?   ?   ? ?  ?
p3,q1,1 - p3,q2,1  
- p2,q2,2 p1,q4,2
       
 

?   ?   ? ?  ? 
p4,q1,1 - p4,q2,1  
- p2,q3,2 
- p2,q4,2
       
  

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.8
 Algorithm 3.5: First attempt (abbreviated)
integer turn ← 1
p q
loop forever loop forever
p1: await turn = 1 q1: await turn = 2
p2: turn ← 2 q2: turn ← 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.9
 State Diagram for the Abbreviated First Attempt

t
' ? $ ' ? ? $
p1: await turn=1, p1: await turn=1,
'- q1: await turn=2, q1: await turn=2,  $
turn = 2 turn = 1
& % & %

& % & %

' ? $ '? $
p1: await turn=1, p2: turn←2,
'- q2: turn←1, q1: await turn=2,  $
turn = 2 turn = 1
& % & %

& % & %

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.10
 Fragment of the State Diagram for the First Attempt

' $ ' $
p1: NCS, - p1: NCS, -
q1: NCS, q2: await turn=2,
turn = 2 turn = 2
& % & %

'? $ '? $
p2: await turn=1, p2: await turn=1,
'- q1: NCS, '-
- q2: await turn=2, -
turn = 2 turn = 2
& % & %

& % & %

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.11
 Algorithm 3.6: Second attempt
boolean wantp ← false, wantq ← false
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: await wantq = false q2: await wantp = false
p3: wantp ← true q3: wantq ← true
p4: critical section q4: critical section
p5: wantp ← false q5: wantq ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.12
 Algorithm 3.7: Second attempt (abbreviated)
boolean wantp ← false, wantq ← false
p q
loop forever loop forever
p1: await wantq = false q1: await wantp = false
p2: wantp ← true q2: wantq ← true
p3: wantp ← false q3: wantq ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.13
 Fragment of the State Diagram for the Second Attempt

' $ ' $ ' $

p1: await !wantq, - p2: wantp←true, p2: wantp←true,
q1: await !wantp, q1: await !wantp, - q2: wantq←true,
& false,false % & false,false % & false,false %
r
6

' $'? $
p3: wantp←false, p3: wantp←false,
q3: wantq←false,  q2: wantq←true,
& true,true % & true,false %

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.14
 Scenario Showing that Mutual Exclusion Does Not Hold

Process p Process q wantp wantq

p1: await wantq=false q1: await wantp=false false false
p2: wantp←true q1: await wantp=false false false
p2: wantp←true q2: wantq←true false false
p3: wantp←false q3: wantq←true true false
p3: wantp←false q3: wantq←false true true

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.15
 Algorithm 3.8: Third attempt
boolean wantp ← false, wantq ← false
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: wantp ← true q2: wantq ← true
p3: await wantq = false q3: await wantp = false
p4: critical section q4: critical section
p5: wantp ← false q5: wantq ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.16
 Scenario Showing Deadlock in the Third Attempt

Process p Process q wantp wantq

p1: non-critical section q1: non-critical section false false
p2: wantp←true q1: non-critical section false false
p2: wantp←true q2: wantq←true false false
p3: await wantq=false q2: wantq←true true false
p3: await wantq=false q3: await wantp=false true true

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.17
 Fragment of the State Diagram Showing Deadlock

' $ ' $ ' $

p2: wantp←true, - p3: await !wantq,
p3: await !wantq,
q2: wantq←true, q2: wantq←true, - q3: await !wantp,
-  
& false,false % & true,false % & true,true %
r
6    

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.18
 Algorithm 3.9: Fourth attempt
boolean wantp ← false, wantq ← false
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: wantp ← true q2: wantq ← true
p3: while wantq q3: while wantp
p4: wantp ← false q4: wantq ← false
p5: wantp ← true q5: wantq ← true
p6: critical section q6: critical section
p7: wantp ← false q7: wantq ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.19
 Cycle in the State Diagram for the Fourth Attempt

r
'? $ ' $ ' $
p3: while wantq, p3: while wantq, p4: wantp←false,
q3: while wantp, - q4: wantq←false, - q4: wantq←false,
true,true true,true true,true
& % & % & %
6

' $ ' $ '? $

p5: wantp←true,  p5: wantp←true,  p4: wantp←false,
q3: while wantp, q5: wantq←true, q5: wantq←true,
false,true false,false true,false
& % & % & %

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.20
 Algorithm 3.10: Dekker’s algorithm
boolean wantp ← false, wantq ← false
integer turn ← 1
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: wantp ← true q2: wantq ← true
p3: while wantq q3: while wantp
p4: if turn = 2 q4: if turn = 1
p5: wantp ← false q5: wantq ← false
p6: await turn = 1 q6: await turn = 2
p7: wantp ← true q7: wantq ← true
p8: critical section q8: critical section
p9: turn ← 2 q9: turn ← 1
p10: wantp ← false q10: wantq ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.21
 Algorithm 3.11: Critical section problem with test-and-set
integer common ← 0
p q
integer local1 integer local2
loop forever loop forever
p1: non-critical section q1: non-critical section
repeat repeat
p2: test-and-set( q2: test-and-set(
common, local1) common, local2)
p3: until local1 = 0 q3: until local2 = 0
p4: critical section q4: critical section
p5: common ← 0 q5: common ← 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.22
 Algorithm 3.12: Critical section problem with exchange
integer common ← 1
p q
integer local1 ← 0 integer local2 ← 0
loop forever loop forever
p1: non-critical section q1: non-critical section
repeat repeat
p2: exchange(common, local1) q2: exchange(common, local2)
p3: until local1 = 1 q3: until local2 = 1
p4: critical section q4: critical section
p5: exchange(common, local1) q5: exchange(common, local2)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.23
 Algorithm 3.13: Peterson’s algorithm
boolean wantp ← false, wantq ← false
integer last ← 1
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: wantp ← true q2: wantq ← true
p3: last ← 1 q3: last ← 2
p4: await wantq = false or q4: await wantp = false or
last = 2 last = 1
p5: critical section q5: critical section
p6: wantp ← false q6: wantq ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.24
 Algorithm 3.14: Manna-Pnueli algorithm
integer wantp ← 0, wantq ← 0
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: if wantq = −1 q2: if wantp = −1
wantp ← −1 wantq ← 1
else wantp ← 1 else wantq ← −1
p3: await wantq 6= wantp q3: await wantp 6= − wantq
p4: critical section q4: critical section
p5: wantp ← 0 q5: wantq ← 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.25
 Algorithm 3.15: Doran-Thomas algorithm
boolean wantp ← false, wantq ← false
integer turn ← 1
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: wantp ← true q2: wantq ← true
p3: if wantq q3: if wantp
p4: if turn = 2 q4: if turn = 1
p5: wantp ← false q5: wantq ← false
p6: await turn = 1 q6: await turn = 2
p7: wantp ← true q7: wantq ← true
p8: await wantq = false q8: await wantp = false
p9: critical section q9: critical section
p10: wantp ← false q10: wantq ← false
p11: turn ← 2 q11: turn ← 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 3.26
 Algorithm 4.1: Third attempt
boolean wantp ← false, wantq ← false
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: wantp ← true q2: wantq ← true
p3: await wantq = false q3: await wantp = false
p4: critical section q4: critical section
p5: wantp ← false q5: wantq ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.1
 2A

true

false

6
i time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.2
 3A

true

false

6
i time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.3
 Duality: ¬ 2A

true

false

6
i time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.4
 Duality: ¬ 3A

true

false

6
i time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.5
 32A

true

false

6
i time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.6
 23A

true

false

6
i time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.7
 AU B

A, B

true

false

6
i time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.8
 32A1 ∧ 32A2

A1,A2 s k2 s k1

? ?
true

false

6
i time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.9
 23A1 ∧ 23A2

A1,A2

true

false

6
i time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.10
 Overtaking: tryp → (¬ csq ) W (csq ) W (¬ csq ) W (csp )

p, q

cs

try

ncs

0 1 2 3 4 5 6 7 8 9 10 11 12 13
time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.11
 Algorithm 4.2: Dekker’s algorithm
boolean wantp ← false, wantq ← false
integer turn ← 1
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: wantp ← true q2: wantq ← true
p3: while wantq q3: while wantp
p4: if turn = 2 q4: if turn = 1
p5: wantp ← false q5: wantq ← false
p6: await turn = 1 q6: await turn = 2
p7: wantp ← true q7: wantq ← true
p8: critical section q8: critical section
p9: turn ← 2 q9: turn ← 1
p10: wantp ← false q10: wantq ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.12
 Dekker’s Algorithm in Promela

1 bool wantp = false, wantq = false; byte turn = 1;

2 active proctype p() {
3 do :: wantp = true;
4 do :: ! wantq −> break;
5 :: else −>
6 if :: (turn == 1)
7 :: (turn == 2) −>
8 wantp = false; (turn == 1); wantp = true
9 fi
10 od;
11 printf ("MSC: p in CS\n") ;
12 turn = 2; wantp = false
13 od
14 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.13
 Specifying Correctness in Promela
1 byte critical = 0;
2

3 bool PinCS = false;

4 #define nostarve PinCS /∗ LTL claim <> nostarve ∗/
5

6 active proctype p() {

7 do ::
8 /∗ preprotocol ∗/
9 critical ++;
10 assert(critical <= 1);
11 PinCS = true;
12 critical −−;
13 /∗ postprotocol ∗/
14 od
15 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.14
 LTL Translation to Never Claims
1 never { /∗ !(<>nostarve) ∗/
2 accept_init :
3 T0_init:
4 if
5 :: (! (( nostarve ))) −> goto T0_init
6 fi ;
7 }
8

10

11

12

13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.15
 LTL Translation to Never Claims

16 never { /∗ !([]<>nostarve) ∗/
17 T0_init:
18 if
19 :: (! (( nostarve ))) −> goto accept_S4
20 :: (1) −> goto T0_init
21 fi ;
22 accept_S4:
23 if
24 :: (! (( nostarve ))) −> goto accept_S4
25 fi ;
26 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 4.16
 Algorithm 5.1: Bakery algorithm (two processes)
integer np ← 0, nq ← 0
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: np ← nq + 1 q2: nq ← np + 1
p3: await nq = 0 or np ≤ nq q3: await np = 0 or nq < np
p4: critical section q4: critical section
p5: np ← 0 q5: nq ← 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.1
 Algorithm 5.2: Bakery algorithm (N processes)
integer array[1..n] number ← [0,. . . ,0]
loop forever
p1: non-critical section
p2: number[i] ← 1 + max(number)
p3: for all other processes j
p4: await (number[j] = 0) or (number[i] ¼ number[j])
p5: critical section
p6: number[i] ← 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.2
 Algorithm 5.3: Bakery algorithm without atomic assignment
boolean array[1..n] choosing ← [false,. . . ,false]
integer array[1..n] number ← [0,. . . ,0]
loop forever
p1: non-critical section
p2: choosing[i] ← true
p3: number[i] ← 1 + max(number)
p4: choosing[i] ← false
p5: for all other processes j
p6: await choosing[j] = false
p7: await (number[j] = 0) or (number[i] ¼ number[j])
p8: critical section
p9: number[i] ← 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.3
 Algorithm 5.4: Fast algorithm for two processes (outline)
integer gate1 ← 0, gate2 ← 0
p q
loop forever loop forever
non-critical section non-critical section
p1: gate1 ← p q1: gate1 ← q
p2: if gate2 6= 0 goto p1 q2: if gate2 6= 0 goto q1
p3: gate2 ← p q3: gate2 ← q
p4: if gate1 6= p q4: if gate1 6= q
p5: if gate2 6= p goto p1 q5: if gate2 6= q goto q1
critical section critical section
p6: gate2 ← 0 q6: gate2 ← 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.4
 Fast Algorithm - No Contention (1)

pi p pi-
@ - @

@ @
(a) (b)

p pi p p  pi p
@ @ -

@ @
(c) (d)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.5
 Fast Algorithm - No Contention (2)

p p pi pi p
@ @

@ @
(e) (f)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.6
 Fast Algorithm - Contention At Gate 2

pi q p pi- q
@ - @

@ @
(a) (b)

p pi q pi p q
 @ @ -

@ @
(c) (d)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.7
 Fast Algorithm - Contention At Gate 1 (1)

pi p pi-
@ - @

@ @
(a) (b)

p pi p q  pi p
@ @

@ @
(c) (d)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.8
 Fast Algorithm - Contention At Gate 1 (2)

q pi- p q pi- q
@ -  @

@ @
(e) (f)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.9
 Algorithm 5.5: Fast algorithm for two processes (outline)
integer gate1 ← 0, gate2 ← 0
p q
loop forever loop forever
non-critical section non-critical section
p1: gate1 ← p q1: gate1 ← q
p2: if gate2 6= 0 goto p1 q2: if gate2 6= 0 goto q1
p3: gate2 ← p q3: gate2 ← q
p4: if gate1 6= p q4: if gate1 6= q
p5: if gate2 6= p goto p1 q5: if gate2 6= q goto q1
critical section critical section
p6: gate2 ← 0 q6: gate2 ← 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.10
 Algorithm 5.6: Fast algorithm for two processes
integer gate1 ← 0, gate2 ← 0
boolean wantp ← false, wantq ← false
p q
p1: gate1 ← p q1: gate1 ← q
wantp ← true wantq ← true
p2: if gate2 6= 0 q2: if gate2 6= 0
wantp ← false wantq ← false
goto p1 goto q1
p3: gate2 ← p q3: gate2 ← q
p4: if gate1 6= p q4: if gate1 6= q
wantp ← false wantq ← false
await wantq = false await wantp = false
p5: if gate2 6= p goto p1 q5: if gate2 6= q goto q1
else wantp ← true else wantq ← true
critical section critical section
p6: gate2 ← 0 q6: gate2 ← 0
wantp ← false wantq ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.11
 Algorithm 5.7: Fisher’s algorithm
integer gate ← 0
loop forever
non-critical section
loop
p1: await gate = 0
p2: gate ← i
p3: delay
p4: until gate = i
critical section
p5: gate ← 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.12
 Algorithm 5.8: Lamport’s one-bit algorithm
boolean array[1..n] want ← [false,. . . ,false]
loop forever
non-critical section
p1: want[i] ← true
p2: for all processes j < i
p3: if want[j]
p4: want[i] ← false
p5: await not want[j]
goto p1
p6: for all processes j > i
p7: await not want[j]
critical section
p8: want[i] ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.13
 Algorithm 5.9: Manna-Pnueli central server algorithm
integer request ← 0, respond ← 0
client process i
loop forever
non-critical section
p1: while respond 6= i
p2: request ← i
critical section
p3: respond ← 0
server process
loop forever
p4: await request 6= 0
p5: respond ← request
p6: await respond = 0
p7: request ← 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 5.14
 State Changes of a Process


ready - running
inactive - - completed

YH
H
HH
?
HH
H blocked

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.1
 Algorithm 6.1: Critical section with semaphores (two processes)
binary semaphore S ← (1, ∅)
p q
loop forever loop forever
p1: non-critical section q1: non-critical section
p2: wait(S) q2: wait(S)
p3: critical section q3: critical section
p4: signal(S) q4: signal(S)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.2
 Algorithm 6.2: Critical section with semaphores (two proc., abbrev.)
binary semaphore S ← (1, ∅)
p q
loop forever loop forever
p1: wait(S) q1: wait(S)
p2: signal(S) q2: signal(S)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.3
 State Diagram for the Semaphore Solution

' $' $' $

p1: wait(S), - p2: signal(S), p2: signal(S),
q1: wait(S),  q1: wait(S), - q1: blocked,
(1, ∅) (0, ∅) (0, {q})
& %
I
@ & %
@
I p& %
@@ @
@@ @
@@' $ @' $
@@ q@
R p1: wait(S),
@ p1: blocked,
q2: signal(S), - q2: signal(S),
(0, ∅) (0, {p})
& %& %

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.4
 Algorithm 6.3: Critical section with semaphores (N proc.)
binary semaphore S ← (1, ∅)
loop forever
p1: non-critical section
p2: wait(S)
p3: critical section
p4: signal(S)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.5
 Algorithm 6.4: Critical section with semaphores (N proc., abbrev.)
binary semaphore S ← (1, ∅)
loop forever
p1: wait(S)
p2: signal(S)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.6
 Scenario for Starvation

n Process p Process q Process r S

1 p1: wait(S) q1: wait(S) r1: wait(S) (1, ∅)
2 p2: signal(S) q1: wait(S) r1: wait(S) (0, ∅)
3 p2: signal(S) q1: blocked r1: wait(S) (0, {q})
4 p1: signal(S) q1: blocked r1: blocked (0, {q, r})
5 p1: wait(S) q1: blocked r2: signal(S) (0, {q})
6 p1: blocked q1: blocked r2: signal(S) (0, {p, q})
7 p2: signal(S) q1: blocked r1: wait(S) (0, {q})

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.7
 Algorithm 6.5: Mergesort
integer array A
binary semaphore S1 ← (0, ∅)
binary semaphore S2 ← (0, ∅)
sort1 sort2 merge
p1: sort 1st half of A q1: sort 2nd half of A r1: wait(S1)
p2: signal(S1) q2: signal(S2) r2: wait(S2)
p3: q3: r3: merge halves of A

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.8
 Algorithm 6.6: Producer-consumer (infinite buffer)
infinite queue of dataType buffer ← empty queue
semaphore notEmpty ← (0, ∅)
producer consumer
dataType d dataType d
loop forever loop forever
p1: d ← produce q1: wait(notEmpty)
p2: append(d, buffer) q2: d ← take(buffer)
p3: signal(notEmpty) q3: consume(d)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.9
 Partial State Diagram for Producer-Consumer with Infinite Buffer

' $' $' $

p1: append, p2: signal(S), p1: append,
q1: wait(S), - q1: wait(S), - q1: wait(S), -
(0, ∅), [ ] (0, ∅), [x] (1, ∅), [x]
& %& %& %
6
'? $ '? $ '? $
p1: append, p2: signal(S), p1: append,
q1: blocked, - q1: blocked, - q2: take, -
(0, {con}), [ ] (0, {con}), [x] (0, ∅), [x]
& %& %& %

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.10
 Algorithm 6.7: Producer-consumer (infinite buffer, abbreviated)
infinite queue of dataType buffer ← empty queue
semaphore notEmpty ← (0, ∅)
producer consumer
dataType d dataType d
loop forever loop forever
p1: append(d, buffer) q1: wait(notEmpty)
p2: signal(notEmpty) q2: d ← take(buffer)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.11
 Algorithm 6.8: Producer-consumer (finite buffer, semaphores)
finite queue of dataType buffer ← empty queue
semaphore notEmpty ← (0, ∅)
semaphore notFull ← (N, ∅)
producer consumer
dataType d dataType d
loop forever loop forever
p1: d ← produce q1: wait(notEmpty)
p2: wait(notFull) q2: d ← take(buffer)
p3: append(d, buffer) q3: signal(notFull)
p4: signal(notEmpty) q4: consume(d)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.12
 Scenario with Busy Waiting

n Process p Process q S
1 p1: wait(S) q1: wait(S) 1
2 p2: signal(S) q1: wait(S) 0
3 p2: signal(S) q1: wait(S) 0
4 p1: wait(S) q1: wait(S) 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.13
 Algorithm 6.9: Dining philosophers (outline)

loop forever
p1: think
p2: preprotocol
p3: eat
p4: postprotocol

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.14
 The Dining Philosophers

....... .............................................................
........ ...................... ..........
........ ..... ........
.
. . ... . . ... .......
... .. .
. .
.. .....
... ..
... phil4 ... . .....
... ... . . ....
. . ..... .. ....
.. .
. H .... ......  ....
. fork4 H H ..................  fork3 .....

.....
j 
.... ............................. ....................... .....
.... ... ... ............ .....
... .. ... .... ..
... ...
. .. .
. ..... ........ .
. ... ...
..... ..... phil5 ..... . ..... .....
... .
.. phil3 . ....
... .. ... .
.... .
. ...
.....
. ..... .. .... .... .
. ... ...... ...
.................... . . ......................
... .... Spaghetti .. .
...
.
... ... .
.. ..
... ... .. .
.
... ....
. . .. ...
. .
...
... *
 ......... . Y
H
........................
...
 HH ..

... fork5 ....................... ..
..... ...... .
...
... .. ..... ...... . ....... fork2 ..
.. ... . . .... ..
... .
. .
. .
. ..
...
.... ..... phil1 .... ..... phil2 .... .. ..
....
.... ......
.
.... 6 ...
. . ..
. .....
..... ......... ........... ..... .... ........
...... . ..... ...
............. ....
....... ..........
.........
........... fork1 .... ..........
................. .....
..........................................

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.15
 Algorithm 6.10: Dining philosophers (first attempt)
semaphore array [0..4] fork ← [1,1,1,1,1]
loop forever
p1: think
p2: wait(fork[i])
p3: wait(fork[i+1])
p4: eat
p5: signal(fork[i])
p6: signal(fork[i+1])

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.16
 Algorithm 6.11: Dining philosophers (second attempt)
semaphore array [0..4] fork ← [1,1,1,1,1]
semaphore room ← 4
loop forever
p1: think
p2: wait(room)
p3: wait(fork[i])
p4: wait(fork[i+1])
p5: eat
p6: signal(fork[i])
p7: signal(fork[i+1])
p8: signal(room)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.17
 Algorithm 6.12: Dining philosophers (third attempt)
semaphore array [0..4] fork ← [1,1,1,1,1]
philosopher 4
loop forever
p1: think
p2: wait(fork[0])
p3: wait(fork[4])
p4: eat
p5: signal(fork[0])
p6: signal(fork[4])

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.18
 Algorithm 6.13: Barz’s algorithm for simulating general semaphores
binary semaphore S ← 1
binary semaphore gate ← 1
integer count ← k
loop forever
non-critical section
p1: wait(gate)
p2: wait(S) // Simulated wait
p3: count ← count − 1
p4: if count > 0 then
p5: signal(gate)
p6: signal(S)
critical section
p7: wait(S) // Simulated signal
p8: count ← count + 1
p9: if count = 1 then
p10: signal(gate)
p11: signal(S)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.19
 Algorithm 6.14: Udding’s starvation-free algorithm
semaphore gate1 ← 1, gate2 ← 0
integer numGate1 ← 0, numGate2 ← 0
p1: wait(gate1)
p2: numGate1 ← numGate1 + 1
p3: signal(gate1)
p4: wait(gate1)
p5: numGate2 ← numGate2 + 1
numGate1 ← numGate1 − 1 // Statement is missing in the book
p6: if numGate1 > 0
p7: signal(gate1)
p8: else signal(gate2)
p9: wait(gate2)
p10: numGate2 ← numGate2 − 1
critical section
p11: if numGate2 > 0
p12: signal(gate2)
p13: else signal(gate1)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.20
 Udding’s Starvation-Free Algorithm

numGate1 gate1 numGate2 gate2 CS

m
mm m
m

@
@@@
@@ @
@@@

@
@@@
@@ @
@@@

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.21
 Scenario for Starvation in Udding’s Algorithm

n Process p Process q gate1 gate2 nGate1 nGate2

1 p4: wait(g1) q4: wait(g1) 1 0 2 0
2 p9: wait(g2) q9: wait(g2) 0 1 0 2
3 CS q9: wait(g2) 0 0 0 1
4 p12: signal(g2) q9: wait(g2) 0 0 0 1
5 p1: wait(g1) CS 0 0 0 0
6 p1: wait(g1) q13: signal(g1) 0 0 0 0
7 p1: blocked q13: signal(g1) 0 0 0 0
8 p4: wait(g1) q1: wait(g1) 1 0 1 0
9 p4: wait(g1) q4: wait(g1) 1 0 2 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.22
 Semaphores in Java
1 import java.util . concurrent. Semaphore;
2 class CountSem extends Thread {
3 static volatile int n = 0;
4 static Semaphore s = new Semaphore(1);
5

6 public void run() {

7 int temp;
8 for (int i = 0; i < 10; i ++) {
9 try {
10 s. acquire ();
11 }
12 catch (InterruptedException e) {}
13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.23
 Semaphores in Java

16 temp = n;
17 n = temp + 1;
18 s. release ();
19 }
20 }
21

22 public static void main(String[] args ) {

23 /∗ As before ∗/
24 }
25 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.24
 Semaphores in Ada
1 protected type Semaphore(Initial : Natural) is
2 entry Wait;
3 procedure Signal;
4 private
5 Count: Natural := Initial ;
6 end Semaphore;
7

10

11

12

13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.25
 Semaphores in Ada

16 protected body Semaphore is

17 entry Wait when Count > 0 is
18 begin
19 Count := Count − 1;
20 end Wait;
21

22 procedure Signal is
23 begin
24 Count := Count + 1;
25 end Signal;
26 end Semaphore;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.26
 Busy-Wait Semaphores in Promela

1 /∗ Copyright (C) 2006 M. Ben−Ari. See copyright.txt ∗/

2 /∗ Definition of busy−wait semaphores ∗/
3 inline wait( s ) {
4 atomic { s > 0 ; s−− }
5 }
6

7 inline signal ( s ) { s++ }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.27
 Weak Semaphores in Promela (three processes)
1 /∗ Copyright (C) 2006 M. Ben−Ari. See copyright.txt ∗/
2 /∗ Weak semaphore ∗/
3 /∗ NPROCS − the number of processes − must be defined. ∗/
4 /∗ THIS VERSION is specialized for exactly THREE processes ∗/
5

6 /∗ A semaphore is a count plus an array of blocked processes ∗/

7 typedef Semaphore {
8 byte count;
9 bool blocked[NPROCS];
10 };
11

12 /∗ Initialize semaphore to n ∗/
13 inline initSem(S, n) {
14 S.count = n
15 }
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.28
 Weak Semaphores in Promela (three processes)
16 /∗ Wait operation: ∗/
17 /∗ If count is zero, set blocked and wait for unblocked ∗/
18 inline wait(S) {
19 atomic {
20 if
21 :: S.count >= 1 −> S.count−−
22 :: else −> S.blocked[_pid−1] = true; !S.blocked[_pid−1]
23 fi
24 }
25 }
26

27 /∗ Signal operation : ∗/
28 /∗ If there are blocked processes , remove one nondeterministically ∗/
29 inline signal (S) {
30 atomic {
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.29
 Weak Semaphores in Promela (three processes)

31 if
32 :: S.blocked[0] −> S.blocked[0] = false
33 :: S.blocked[1] −> S.blocked[1] = false
34 :: S.blocked[2] −> S.blocked[2] = false
35 :: else −> S.count++
36 fi
37 }
38 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.30
 Weak Semaphores in Promela (N processes)
1 /∗ Copyright (C) 2006 M. Ben−Ari. See copyright.txt ∗/
2 /∗ Weak semaphore ∗/
3 /∗ NPROCS − the number of processes − must be defined. ∗/
4

5 /∗ A semaphore is a count plus an array of blocked processes ∗/

6 typedef Semaphore {
7 byte count;
8 bool blocked[NPROCS];
9 byte i , choice ;
10 };
11

12 /∗ Initialize semaphore to n ∗/
13 inline initSem(S, n) {
14 S.count = n
15 }
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.31
 Weak Semaphores in Promela (N processes)
16 /∗ Wait operation: ∗/
17 /∗ If count is zero, set blocked and wait for unblocked ∗/
18 inline wait(S) {
19 atomic {
20 if
21 :: S.count >= 1 −> S.count−−
22 :: else −> S.blocked[_pid−1] = true; !S.blocked[_pid−1]
23 fi
24 }
25 }
26

27 /∗ Signal operation : ∗/
28 /∗ If there are blocked processes , remove each one and ∗/
29 /∗ nondeterministically decide whether to replace it in the channel ∗/
30 /∗ or exit the operation . ∗/
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.32
 Weak Semaphores in Promela (N processes)
31 inline signal (S) {
32 atomic {
33 S.i = 0;
34 S.choice = 255;
35 do
36 :: (S.i == NPROCS) −> break
37 :: (S.i < NPROCS) && !S.blocked[S.i] −> S.i++
38 :: else −>
39 if
40 :: (S.choice == 255) −> S.choice = S.i
41 :: (S.choice != 255) −> S.choice = S.i
42 :: (S.choice != 255) −>
43 fi ;
44 S.i ++
45 od;
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.33
 Weak Semaphores in Promela (N processes)

46 if
47 :: S.choice == 255 −> S.count++
48 :: else −> S.blocked[S.choice] = false
49 fi
50 }
51 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.34
 Barz’s Algorithm in Promela
1 #define NPROCS 3
2 #define K 2
3 byte gate = 1;
4 int count = K;
5 byte critical = 0;
6 active [ NPROCS] proctype P () {
7 do ::
8 atomic { gate > 0; gate−−; }
9 d_step {
10 count−−;
11 if
12 :: count > 0 −> gate++
13 :: else
14 fi
15 }
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.35
 Barz’s Algorithm in Promela

16 critical ++;
17 assert (critical <= 1);
18 critical −−;
19 d_step {
20 count++;
21 if
22 :: count == 1 −> gate++
23 :: else
24 fi
25 }
26 od
27 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.36
 Algorithm 6.15: Semaphore algorithm A
semaphore S ← 1, semaphore T ← 0
p q
p1: wait(S) q1: wait(T)
p2: write("p") q2: write("q")
p3: signal(T) q3: signal(S)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.37
 Algorithm 6.16: Semaphore algorithm B
semaphore S1 ← 0, S2 ← 0
p q r
p1: write("p") q1: wait(S1) r1: wait(S2)
p2: signal(S1) q2: write("q") r2: write("r")
p3: signal(S2) q3: r3:

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.38
 Algorithm 6.17: Semaphore algorithm with a loop
semaphore S ← 1
boolean B ← false
p q
p1: wait(S) q1: wait(S)
p2: B ← true q2: while not B
p3: signal(S) q3: write("*")
p4: q4: signal(S)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.39
 Algorithm 6.18: Critical section problem (k out of N processes)
binary semaphore S ← 1, delay ← 0
integer count ← k
integer m
loop forever
p1: non-critical section
p2: wait(S)
p3: count ← count − 1
p4: m ← count
p5: signal(S)
p6: if m ≤ −1 wait(delay)
p7: critical section
p8: wait(S)
p9: count ← count + 1
p10: if count ≤ 0 signal(delay)
p11: signal(S)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.40
 Circular Buffer

 
       
       
6 6
in out


     
     
6 6
out in

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.41
 Algorithm 6.19: Producer-consumer (circular buffer)
dataType array [0..N] buffer
integer in, out ← 0
semaphore notEmpty ← (0, ∅)
semaphore notFull ← (N, ∅)
producer consumer
dataType d dataType d
loop forever loop forever
p1: d ← produce q1: wait(notEmpty)
p2: wait(notFull) q2: d ← buffer[out]
p3: buffer[in] ← d q3: out ← (out+1) modulo N
p4: in ← (in+1) modulo N q4: signal(notFull)
p5: signal(notEmpty) q5: consume(d)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.42
 Algorithm 6.20: Simulating general semaphores
binary semaphore S ← 1, gate ← 0
integer count ← 0
wait
p1: wait(S)
p2: count ← count − 1
p3: if count < 0
p4: signal(S)
p5: wait(gate)
p6: else signal(S)
signal
p7: wait(S)
p8: count ← count + 1
p9: if count ≤ 0
p10: signal(gate)
p11: signal(S)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.43
 Weak Semaphores in Promela with Channels
1 /∗ Weak semaphore ∗/
2 /∗ NPROCS − the number of processes − must be defined. ∗/
3

4 /∗ A semaphore is a count plus a channel ∗/

5 /∗ plus a couple of local variables ∗/
6 typedef Semaphore {
7 byte count;
8 chan ch = [NPROCS] of { pid };
9 byte temp, i ;
10 };
11

12 /∗ Initialize semaphore to n ∗/
13 inline initSem(S, n) {
14 S.count = n
15 }
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.44
 Weak Semaphores in Promela with Channels
16 /∗ Wait operation: ∗/
17 /∗ If count is zero, place your _pid in the channel ∗/
18 /∗ and block until it is removed. ∗/
19 inline wait(S) {
20 atomic {
21 if
22 :: S.count >= 1 −> S.count−−;
23 :: else −> S.ch ! _pid; !( S.ch ?? [ eval(_pid)])
24 fi
25 }
26 }
27 /∗ Signal operation : ∗/
28 /∗ If there are blocked processes , remove each one and ∗/
29 /∗ nondeterministically decide whether to replace it in the channel ∗/
30 /∗ or exit the operation . ∗/
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.45
 Weak Semaphores in Promela with Channels
31 inline signal (S) {
32 atomic {
33 S.i = len(S.ch);
34 if
35 :: S.i == 0 −> S.count++ /∗No blocked process, increment count∗/
36 :: else −>
37 do
38 :: S.i == 1 −> S.ch ? _; break /∗Remove only blocked process∗/
39 :: else −> S.i−−;
40 S.ch ? S.temp;
41 if :: break :: S.ch ! S.temp fi
42 od
43 fi
44 }
45 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.46
 Algorithm 6.21: Readers and writers with semaphores
semaphore readerSem ← 0, writerSem ← 0
integer delayedReaders ← 0, delayedWriters ← 0
semaphore entry ← 1
integer readers ← 0, writers ← 0
SignalProcess
if writers = 0 or delayedReaders > 0
delayedReaders ← delayedReaders − 1
signal(readerSem)
else if readers = 0 and writers = 0 and delayedWriters > 0
delayedWriters ← delayedWriters − 1
signal(writerSem)
else signal(entry)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.47
 Algorithm 6.21: Readers and writers with semaphores

StartRead
p1: wait(entry)
p2: if writers > 0
p3: delayedReaders ← delayedReaders + 1
p4: signal(entry)
p5: wait(readerSem)
p6: readers ← readers + 1
p7: SignalProcess
EndRead
p8: wait(entry)
p9: readers ← readers − 1
p10: SignalProcess

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.48
 Algorithm 6.21: Readers and writers with semaphores

StartWrite
p11: wait(entry)
p12: if writers > 0 or readers > 0
p13: delayedWriters ← delayedWriters + 1
p14: signal(entry)
p15: wait(writerSem)
p16: writers ← writers + 1
p17: SignalProcess
EndWrite
p18: wait(entry)
p19: writers ← writers − 1
p20: SignalProcess

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 6.49
 Algorithm 7.1: Atomicity of monitor operations

monitor CS
integer n ← 0

operation increment
integer temp
temp ← n
n ← temp + 1
p q
p1: CS.increment q1: CS.increment

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.1
 Executing a Monitor Operation

fff

HH
H

monitor CS
f

n 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.2
 Algorithm 7.2: Semaphore simulated with a monitor

monitor Sem
integer s ← k
condition notZero
operation wait
if s = 0
waitC(notZero)
s←s−1
operation signal
s←s+1
signalC(notZero)
p q
loop forever loop forever
non-critical section non-critical section
p1: Sem.wait q1: Sem.wait
critical section critical section
p2: Sem.signal q2: Sem.signal

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.3
 Condition Variable in a Monitor

fff

HH
H

monitor Sem notZero

f




fff

s 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.4
 State Diagram for the Semaphore Simulation

# # #
p1: Sem.wait, - p2: Sem.signal, p2: Sem.signal,
q1: Sem.wait,  q1: Sem.wait, - blocked,
1, <> 0, <> 0, < q >
" ! " !
  "
 !
6 6 
  
 

# ?     #
p1: Sem.wait, blocked,
9

q2: Sem.signal, - q2: Sem.signal
0, <> 0, < p >
" ! " !

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.5
 Algorithm 7.3: Producer-consumer (finite buffer, monitor)

monitor PC
bufferType buffer ← empty
condition notEmpty
condition notFull
operation append(datatype V)
if buffer is full
waitC(notFull)
append(V, buffer)
signalC(notEmpty)
operation take()
datatype W
if buffer is empty
waitC(notEmpty)
W ← head(buffer)
signalC(notFull)
return W

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.6
 Algorithm 7.3: Producer-consumer (finite buffer, monitor) (continued)

producer consumer
datatype D datatype D
loop forever loop forever
p1: D ← produce q1: D ← PC.take
p2: PC.append(D) q2: consume(D)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.7
 The Immediate Resumption Requirement

fff
HH
condition 1 H waiting

fff ff
A

AA monitor



f

condition 2 signaling
A

ff AA

f

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.8
 Algorithm 7.4: Readers and writers with a monitor

monitor RW
integer readers ← 0
integer writers ← 0
condition OKtoRead, OKtoWrite
operation StartRead
if writers 6= 0 or not empty(OKtoWrite)
waitC(OKtoRead)
readers ← readers + 1
signalC(OKtoRead)
operation EndRead
readers ← readers − 1
if readers = 0
signalC(OKtoWrite)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.9
 Algorithm 7.4: Readers and writers with a monitor (continued)

operation StartWrite
if writers 6= 0 or readers 6= 0
waitC(OKtoWrite)
writers ← writers + 1

operation EndWrite
writers ← writers − 1
if empty(OKtoRead)
then signalC(OKtoWrite)
else signalC(OKtoRead)
reader writer
p1: RW.StartRead q1: RW.StartWrite
p2: read the database q2: write to the database
p3: RW.EndRead q3: RW.EndWrite

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.10
 Algorithm 7.5: Dining philosophers with a monitor

monitor ForkMonitor
integer array[0..4] fork ← [2, . . . , 2]
condition array[0..4] OKtoEat
operation takeForks(integer i)
if fork[i] 6= 2
waitC(OKtoEat[i])
fork[i+1] ← fork[i+1] − 1
fork[i−1] ← fork[i−1] − 1

operation releaseForks(integer i)
fork[i+1] ← fork[i+1] + 1
fork[i−1] ← fork[i−1] + 1
if fork[i+1] = 2
signalC(OKtoEat[i+1])
if fork[i−1] = 2
signalC(OKtoEat[i−1])

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.11
 Algorithm 7.5: Dining philosophers with a monitor (continued)

philosopher i
loop forever
p1: think
p2: takeForks(i)
p3: eat
p4: releaseForks(i)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.12
 Scenario for Starvation of Philosopher 2

n phil1 phil2 phil3 f0 f1 f2 f3 f4

1 take(1) take(2) take(3) 2 2 2 2 2
2 release(1) take(2) take(3) 1 2 1 2 2
3 release(1) take(2) and release(3) 1 2 0 2 1
waitC(OK[2])
4 release(1) (blocked) release(3) 1 2 0 2 1
5 take(1) (blocked) release(3) 2 2 1 2 1
6 release(1) (blocked) release(3) 1 2 0 2 1
7 release(1) (blocked) take(3) 1 2 1 2 2

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.13
 Readers and Writers in C
1 monitor RW {
2 int readers = 0, writing = 1;
3 condition OKtoRead, OKtoWrite;
4

5 void StartRead() {
6 if (writing || ! empty(OKtoWrite))
7 waitc(OKtoRead);
8 readers = readers + 1;
9 signalc(OKtoRead);
10 }
11 void EndRead() {
12 readers = readers − 1;
13 if (readers == 0)
14 signalc(OKtoWrite);
15 }
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.14
 Readers and Writers in C

16 void StartWrite () {
17 if (writing || (readers != 0))
18 waitc(OKtoWrite);
19 writing = 1;
20 }
21

22 void EndWrite() {
23 writing = 0;
24 if (empty(OKtoRead))
25 signalc(OKtoWrite);
26 else
27 signalc(OKtoRead);
28 }
29 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.15
 Algorithm 7.6: Readers and writers with a protected object

protected object RW
integer readers ← 0
boolean writing ← false
operation StartRead when not writing
readers ← readers + 1
operation EndRead
readers ← readers − 1
operation StartWrite when not writing and readers = 0
writing ← true

operation EndWrite
writing ← false
reader writer
loop forever loop forever
p1: RW.StartRead q1: RW.StartWrite
p2: read the database q2: write to the database
p3: RW.EndRead q3: RW.EndWrite

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.16
 Context Switches in a Monitor

Process reader Process writer

waitC(OKtoRead) operation EndWrite
(blocked) writing ← false
(blocked) signalC(OKtoRead)
readers ← readers + 1 return from EndWrite
signalC(OKtoRead) return from EndWrite
read the data return from EndWrite
read the data ...

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.17
 Context Switches in a Protected Object

Process reader Process writer

when not writing operation EndWrite
(blocked) writing ← false
(blocked) when not writing
(blocked) readers ← readers + 1
read the data ...

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.18
 Simple Readers and Writers in Ada
1 protected RW is
2 procedure Write(I: Integer );
3 function Read return Integer ;
4 private
5 N: Integer := 0;
6 end RW;
7

10

11

12

13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.19
 Simple Readers and Writers in Ada

16 protected body RW is
17 procedure Write(I: Integer ) is
18 begin
19 N := I;
20 end Write;
21 function Read return Integer is
22 begin
23 return N;
24 end Read;
25 end RW;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.20
 Readers and Writers in Ada
1 protected RW is
2 entry StartRead;
3 procedure EndRead;
4 entry Startwrite ;
5 procedure EndWrite;
6 private
7 Readers: Natural :=0;
8 Writing: Boolean := false ;
9 end RW;
10

11

12

13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.21
 Readers and Writers in Ada
16 protected body RW is
17 entry StartRead
18 when not Writing is
19 begin
20 Readers := Readers + 1;
21 end StartRead;
22

23 procedure EndRead is
24 begin
25 Readers := Readers − 1;
26 end EndRead;
27

28

29

30

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.22
 Readers and Writers in Ada

31 entry StartWrite
32 when not Writing and Readers = 0 is
33 begin
34 Writing := true;
35 end StartWrite;
36

37 procedure EndWrite is
38 begin
39 Writing := false ;
40 end EndWrite;
41 end RW;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.23
 Producer-Consumer in Java
1 class PCMonitor {
2 final int N = 5;
3 int Oldest = 0, Newest = 0;
4 volatile int Count = 0;
5 int Buffer [] = new int[N];
6 synchronized void Append(int V) {
7 while (Count == N)
8 try {
9 wait();
10 } catch (InterruptedException e) {}
11 Buffer [ Newest] = V;
12 Newest = (Newest + 1) % N;
13 Count = Count + 1;
14 notifyAll ();
15 }
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.24
 Producer-Consumer in Java

16 synchronized int Take() {

17 int temp;
18 while (Count == 0)
19 try {
20 wait();
21 } catch (InterruptedException e) {}
22 temp = Buffer[Oldest];
23 Oldest = (Oldest + 1) % N;
24 Count = Count − 1;
25 notifyAll ();
26 return temp;
27 }
28 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.25
 A Monitor in Java With notifyAll

fff
HH @
I
H @

@
ff
@
f f






object waiting

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.26
 Java Monitor for Readers and Writers
1 class RWMonitor {
2 volatile int readers = 0;
3 volatile boolean writing = false;
4 synchronized void StartRead() {
5 while (writing )
6 try {
7 wait();
8 } catch (InterruptedException e) {}
9 readers = readers + 1;
10 notifyAll ();
11 }
12 synchronized void EndRead() {
13 readers = readers − 1;
14 if (readers == 0) notifyAll ();
15 }
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.27
 Java Monitor for Readers and Writers

16 synchronized void StartWrite() {

17 while (writing || (readers != 0))
18 try {
19 wait();
20 } catch (InterruptedException e) {}
21 writing = true;
22 }
23 synchronized void EndWrite() {
24 writing = false;
25 notifyAll ();
26 }
27 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.28
 Simulating Monitors in Promela
1 /∗ Copyright (C) 2006 M. Ben−Ari. See copyright.txt ∗/
2 /∗ Definitions for monitor ∗/
3 bool lock = false;
4

5 typedef Condition {
6 bool gate;
7 byte waiting ;
8 }
9

10 inline enterMon() {
11 atomic {
12 ! lock;
13 lock = true;
14 }
15 }
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.29
 Simulating Monitors in Promela
16

17 inline leaveMon() {
18 lock = false;
19 }
20

21 inline waitC(C) {
22 atomic {
23 C.waiting ++;
24 lock = false; /∗ Exit monitor ∗/
25 C.gate; /∗ Wait for gate ∗/
26 lock = true; /∗ IRR ∗/
27 C.gate = false; /∗ Reset gate ∗/
28 C.waiting −−;
29 }
30 }
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.30
 Simulating Monitors in Promela
31

32 inline signalC (C) {

33 atomic {
34 if
35 /∗ Signal only if waiting ∗/
36 :: (C.waiting > 0) −>
37 C.gate = true;
38 ! lock ; /∗ IRR − wait for released lock ∗/
39 lock = true; /∗ Take lock again ∗/
40 :: else
41 fi ;
42 }
43 }
44

45 #define emptyC(C) (C.waiting == 0)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.31
 Readers and Writers in Ada (1)

1 protected RW is
2

3 entry Start_Read;
4 procedure End_Read;
5 entry Start_Write;
6 procedure End_Write;
7

8 private
9 Waiting_To_Read : integer := 0;
10 Readers : Natural := 0;
11 Writing : Boolean := false ;
12

13 end RW;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.32
 Readers and Writers in Ada (2)
1 protected RW is
2

3 entry StartRead;
4 procedure EndRead;
5 entry Startwrite ;
6 procedure EndWrite;
7 function NumberReaders return Natural;
8

9 private
10 entry ReadGate;
11 entry WriteGate;
12 Readers: Natural :=0;
13 Writing: Boolean := false ;
14

15 end RW;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 7.33
 Algorithm 8.1: Producer-consumer (channels)
channel of integer ch
producer consumer
integer x integer y
loop forever loop forever
p1: x ← produce q1: ch ⇒ y
p2: ch ⇐ x q2: consume(y)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.1
 Algorithm 8.2: Conway’s problem
constant integer MAX ← 9
constant integer K ← 4
channel of integer inC, pipe, outC
compress output
char c, previous ← 0 char c
integer n ← 0 integer m ← 0
inC ⇒ previous
loop forever loop forever
p1: inC ⇒ c q1: pipe ⇒ c
p2: if (c = previous) and q2: outC ⇐ c
(n < MAX − 1)
p3: n←n+1 q3: m←m+1
else
p4: if n > 0 q4: if m >= K
p5: pipe ⇐ intToChar(n+1) q5: outC ⇐ newline
p6: n←0 q6: m←0
p7: pipe ⇐ previous q7:
p8: previous ← c q8:

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.2
 Conway’s Problem

inC - pipe outC -

compress - output

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.3
 Process Array for Matrix Multiplication

Source Source Source

2 2 0
0 1 0
1
? 0
? 1
?
4,2,6 3,2,4 3,0,0 0,0,0
Result  1  2  3  Zero

2 2 0
0 1 0
1
? 0
? 1
?
10,5,18 6,5,10 6,0,0 0,0,0
Result  4  5  6  Zero

2 2 0
0 1 0
1
? 0
? 1
?
16,8,30 9,8,16 9,0,0 0,0,0
Result  7  8  9  Zero

2 2 0
0 1 0
1
? 0
? 1
?
Sink Sink Sink

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.4
 Computation of One Element

2 2 0
? ? ?
30  16  0  0
Result  7 8 9 Zero

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.5
 Algorithm 8.3: Multiplier process with channels
integer FirstElement
channel of integer North, East, South, West
integer Sum, integer SecondElement
loop forever
p1: North ⇒ SecondElement
p2: East ⇒ Sum
p3: Sum ← Sum + FirstElement · SecondElement
p4: South ⇐ SecondElement
p5: West ⇐ Sum

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.6
 Algorithm 8.4: Multiplier with channels and selective input
integer FirstElement
channel of integer North, East, South, West
integer Sum, integer SecondElement
loop forever
either
p1: North ⇒ SecondElement
p2: East ⇒ Sum
or
p3: East ⇒ Sum
p4: North ⇒ SecondElement
p5: South ⇐ SecondElement
p6: Sum ← Sum + FirstElement · SecondElement
p7: West ⇐ Sum

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.7
 Algorithm 8.5: Dining philosophers with channels
channel of boolean forks[5]
philosopher i fork i
boolean dummy boolean dummy
loop forever loop forever
p1: think q1: forks[i] ⇐ true
p2: forks[i] ⇒ dummy q2: forks[i] ⇒ dummy
p3: forks[i+1] ⇒ dummy q3:
p4: eat q4:
p5: forks[i] ⇐ true q5:
p6: forks[i+1] ⇐ true q6:

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.8
 Conway’s Problem in Promela
1 #define N 9
2 #define K 4
3 chan inC, pipe, outC = [0] of { byte };
4

5 active proctype Compress() {

6 byte previous , c, count = 0;
7 inC ? previous ;
8 do
9 :: inC ? c −>
10 if
11 :: (c == previous) && (count < N−1) −> count++
12 :: else −>
13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.9
 Conway’s Problem in Promela
16 if
17 :: count > 0 −>
18 pipe ! count+1;
19 count = 0
20 :: else
21 fi ;
22 pipe ! previous ;
23 previous = c;
24 fi
25 od
26 }
27

28

29

30

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.10
 Conway’s Problem in Promela

31 active proctype Output() {

32 byte c, count = 0;
33 do
34 :: pipe ? c;
35 outC ! c;
36 count++;
37 if
38 :: count >= K −>
39 outC ! ’ \n’;
40 count = 0
41 :: else
42 fi
43 od
44 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.11
 Multiplier Process in Promela

1 proctype Multiplier (byte Coeff;

2 chan North; chan East; chan South; chan West) {
3 byte Sum, X;
4 for (i ,0, SIZE−1)
5 if :: North ? X −> East ? Sum;
6 :: East ? Sum −> North ? X;
7 fi ;
8 South ! X;
9 Sum = Sum + X∗Coeff;
10 West ! Sum;
11 rof (i )
12 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.12
 Algorithm 8.6: Rendezvous

client server
integer parm, result integer p, r
loop forever loop forever
p1: parm ← . . . q1:
p2: server.service(parm, result) q2: accept service(p, r)
p3: use(result) q3: r ← do the service(p)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.13
 Timing Diagram for a Rendezvous

t1 t2 t3
calling
6

parameters results

accepting ?

time →

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.14
 Bounded Buffer in Ada
1 task body Buffer is
2 B: Buffer_Array;
3 In_Ptr, Out_Ptr, Count: Index := 0;
4

5 begin
6 loop
7 select
8 when Count < Index’Last =>
9 accept Append(I: in Integer ) do
10 B(In_Ptr) := I;
11 end Append;
12 Count := Count + 1; In_Ptr := In_Ptr + 1;
13 or
14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.15
 Bounded Buffer in Ada

16 when Count > 0 =>

17 accept Take(I: out Integer ) do
18 I := B(Out_Ptr);
19 end Take;
20 Count := Count − 1; Out_Ptr := Out_Ptr + 1;
21 or
22 terminate;
23 end select;
24 end loop;
25 end Buffer;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.16
 Remote Procedure Call

Remote Client program Server program Remote

interface interface

Sending stub Receiving stub

Communications - Communications

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.17
 Pipeline Sort

- - - ··· - - -

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.18
 Hoare’s Game

@
@
@
@
y @
@

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 8.19
 A Space

 
(’a’,30)
   
(’a’,true,50)
 
 
  (’a’,false,40)
(’a’,10,20)  
 

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.1
 Algorithm 9.1: Critical section problem in Linda

loop forever
p1: non-critical section
p2: removenote(’s’)
p3: critical section
p4: postnote(’s’)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.2
 Algorithm 9.2: Client-server algorithm in Linda

client server
constant integer me ← . . . integer client
serviceType service serviceType s
dataType result, parm dataType r, p
p1: service ← // Service requested q1: removenote(’S’, client, s, p)
p2: postnote(’S’, me, service, parm) q2: r ← do (s, p)
p3: removenote(’R’, me, result) q3: postnote(’R’, client, r)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.3
 Algorithm 9.3: Specific service

client server
constant integer me ← . . . integer client
serviceType service serviceType s
dataType result, parm dataType r, p
p1: service ← // Service requested q1: s ← // Service provided
p2: postnote(’S’, me, service, parm) q2: removenote(’S’, client, s=, p)
p3: q3: r ← do (s, p)
p4: removenote(’R’, me, result) q4: postnote(’R’, client, r)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.4
 Algorithm 9.4: Buffering in a space

producer consumer
integer count ← 0 integer count ← 0
integer v integer v
loop forever loop forever
p1: v ← produce q1: removenote(’B’, count=, v)
p2: postnote(’B’, count, v) q2: consume(v)
p3: count ← count + 1 q3: count ← count + 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.5
 Algorithm 9.5: Multiplier process with channels in Linda
parameters: integer FirstElement
parameters: integer North, East, South, West
integer Sum, integer SecondElement
integer Sum, integer SecondElement
loop forever
p1: removenote(’E’, North=, SecondElement)
p2: removenote(’S’, East=, Sum)
p3: Sum ← Sum + FirstElement · SecondElement
p4: postnote(’E’, South, SecondElement)
p5: postnote(’S’, West, Sum)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.6
 Algorithm 9.6: Matrix multiplication in Linda
constant integer n ← . . .
master worker
integer i, j, result integer r, c, result
integer r, c integer array[1..n] vec1, vec2
loop forever
p1: for i from 1 to n q1: removenote(’T’, r, c)
p2: for j from 1 to n q2: readnote(’A’, r=, vec1)
p3: postnote(’T’, i, j) q3: readnote(’B’, c=, vec2)
p4: for i from 1 to n q4: result ← vec1 · vec2
p5: for j from 1 to n q5: postnote(’R’, r, c, result)
p6: removenote(’R’, r, c, result) q6:
p7: print r, c, result q7:

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.7
 Algorithm 9.7: Matrix multiplication in Linda with granularity
constant integer n ← . . .
constant integer chunk ← . . .
master worker
integer i, j, result integer r, c, k, result
integer r, c integer array[1..n] vec1, vec2
loop forever
p1: for i from 1 to n q1: removenote(’T’, r, k)
p2: for j from 1 to n step by chunk q2: readnote(’A’, r=, vec1)
p3: postnote(’T’, i, j) q3: for c from k to k+chunk-1
p4: for i from 1 to n q4: readnote(’B’, c=, vec2)
p5: for j from 1 to n q5: result ← vec1 · vec2
p6: removenote(’R’, r, c, result) q6: postnote(’R’, r, c, result)
p7: print r, c, result q7:

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.8
 Definition of Notes in Java
1 public class Note {
2 public String id ;
3 public Object[] p;
4

5 // Constructor for an array of objects

6 public Note (String id , Object[] p) {
7 this . id = id;
8 if (p != null) this . p = p.clone();
9 }
10

11 // Constructor for a single integer

12 public Note (String id , int p1) {
13 this (id , new Object[]{new Integer(p1)});
14 }
15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.9
 Definition of Notes in Java

16 // Accessor for a single integer value

17 public int get(int i ) {
18 return (( Integer )p[i ]). intValue ();
19 }
20 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.10
 Matrix Multiplication in Java
1 private class Worker extends Thread {
2 public void run() {
3 Note task = new Note("task");
4 while (true) {
5 Note t = space.removenote(task);
6 int row = t.get(0), col = t.get(1);
7 Note r = space.readnote(match("a", row));
8 Note c = space.readnote(match("b", col));
9 int ip = 0;
10 for (int i = 1; i <= SIZE; i++)
11 ip = ip + r.get(i )∗c. get(i );
12 space. postnote(new Note("result", row, col , ip ));
13 }
14 }
15 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.11
 Matrix Multiplication in Promela

1 chan space = [25] of { byte, short, short, short, short };

2

3 active[ WORKERS] proctype Worker() {

4 short row, col , ip , r1, r2, r3, c1, c2, c3;
5 do
6 :: space ?? ’ t’ , row, col , _, _;
7 space ?? <’a’, eval(row), r1, r2, r3>;
8 space ?? <’b’, eval(col ), c1, c2, c3>;
9 ip = r1∗c1 + r2∗c2 + r3∗c3;
10 space ! ’ r ’ , row, col , ip , 0;
11 od;
12 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.12
 Algorithm 9.8: Matrix multiplication in Linda (exercise)
constant integer n ← . . .
master worker
integer i, j, result integer i, r, c, result
integer r, c integer array[1..n] vec1, vec2
loop forever
p1: postnote(’T’, 0) q1: removenote(’T’ i)
p2: q2: if i < (n · n) − 1
p3: q3: postnote(’T’, i+1)
p4: q4: r ← (i / n) + 1
p5: q5: c ← (i modulo n) + 1
p6: for i from 1 to n q6: readnote(’A’, r=, vec1)
p7: for j from 1 to n q7: readnote(’B’, c=, vec2)
p8: removenote(’R’, r, c, result) q8: result ← vec1 · vec2
p9: print r, c, result q9: postnote(’R’, r, c, result)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 9.13
 Sending and Receiving Messages

node 5 node 3
integer k ← 20 - integer m, n
send(request, 3, k, 30) receive(request, m, n)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.1
 Sending a Message and Expecting a Reply

node 5 node 3
integer source
send(request, 3, myID) -
receive(request, source)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.2
 Algorithm 10.1: Ricart-Agrawala algorithm (outline)
integer myNum ← 0
set of node IDs deferred ← empty set
main
p1: non-critical section
p2: myNum ← chooseNumber
p3: for all other nodes N
p4: send(request, N, myID, myNum)
p5: await reply’s from all other nodes
p6: critical section
p7: for all nodes N in deferred
p8: remove N from deferred
p9: send(reply, N, myID)
receive
integer source, reqNum
p10: receive(request, source, reqNum)
p11: if reqNum < myNum
p12: send(reply,source,myID)
p13: else add source to deferred

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.3
 RA Algorithm (1)

Aaron 10

 @@ @
I
req req req @req
@ @
@ @R
Becky  req
5 Chloe 15
-
req

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.4
 RA Algorithm (2)

Aaron 10

Chloe
@
I
reply @ reply
@
@
Becky • 5 reply Chloe 15

Aaron, Chloe

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.5
 Virtual Queue in the RA Algorithm

Becky  Aaron  Chloe

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.6
 RA Algorithm (3)

Aaron • 10

Chloe

reply

Becky 5 reply Chloe 15

-

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.7
 RA Algorithm (4)

Aaron 10

@
@ reply
@R
@
Becky 5 Chloe • 15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.8
 Equal Ticket Numbers

Becky 5

req Aaron 5
-
req

Becky 5 Aaron 5

Aaron Becky

Note: This figure is not in the book.

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.9
 Choosing Ticket Numbers (1)

Becky

5 req Aaron 10
-
req

Becky • 5

reply Aaron 10

Aaron

Becky 5 Aaron • 10
-
reply

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.10
 Choosing Ticket Numbers (2)

Becky 8 Aaron • 10
-
req

Becky •

8 reply Aaron • 10

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.11
 Quiescent Nodes

Becky 5 Aaron 0
-
req

Becky 5 Aaron 0
Becky

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.12
 Algorithm 10.2: Ricart-Agrawala algorithm
integer myNum ← 0
set of node IDs deferred ← empty set
integer highestNum ← 0
boolean requestCS ← false
Main
loop forever
p1: non-critical section
p2: requestCS ← true
p3: myNum ← highestNum + 1
p4: for all other nodes N
p5: send(request, N, myID, myNum)
p6: await reply’s from all other nodes
p7: critical section
p8: requestCS ← false
p9: for all nodes N in deferred
p10: remove N from deferred
p11: send(reply, N, myID)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.13
 Algorithm 10.2: Ricart-Agrawala algorithm (continued)

Receive
integer source, requestedNum
loop forever
p1: receive(request, source, requestedNum)
p2: highestNum ← max(highestNum, requestedNum)
p3: if not requestCS or requestedNum ¼ myNum
p4: send(reply, source, myID)
p5: else add source to deferred

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.14
 Correct of the RA Algorithm (Case 1)

i choose - send
request

j - receive - reply - choose

request

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.15
 Correct of the RA Algorithm (Case 2)

i main choose - send

request

i receive - receive - reply

request

j main choose - send

request

j receive - receive - reply

request

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.16
 Channels in RA Algorithm in Promela

node i H
HH ch[id]
··· H

- node id


node j 

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.17
 RA Algorithm in Promela – Main Process
1 proctype Main( byte myID ) {
2 do ::
3 atomic {
4 requestCS[myID] = true ;
5 myNum[myID] = highestNum[myID] + 1 ;
6 }
7

8 for (J,0, NPROCS−1)

9 if
10 :: J != myID −>
11 ch[J] ! request , myID, myNum[myID];
12 :: else
13 fi
14 rof (J);
15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.18
 RA Algorithm in Promela – Main Process

16

17 for (K,0,NPROCS−2)
18 ch[myID] ?? reply , _ , _;
19 rof (K);
20 critical_section ();
21 requestCS[myID] = false;
22

23 byte N;
24 do
25 :: empty(deferred[myID]) −> break;
26 :: deferred [ myID] ? N −> ch[N] ! reply, 0, 0
27 od
28 od
29 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.19
 RA Algorithm in Promela – Receive Process
1 proctype Receive( byte myID ) {
2 byte reqNum, source;
3 do ::
4 ch[myID] ?? request, source, reqNum;
5 highestNum[myID] =
6 (( reqNum > highestNum[myID]) −>
7 reqNum : highestNum[myID]);
8 atomic {
9 if
10 :: requestCS[myID] &&
11 ( (myNum[myID] < reqNum) ||
12 ( (myNum[myID] == reqNum) &&
13 (myID < source)
14 ) ) −>
15 deferred [ myID] ! source
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.20
 RA Algorithm in Promela – Receive Process

16 :: else −>
17 ch[source] ! reply , 0, 0
18 fi
19 }
20 od
21 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.21
 Algorithm 10.3: Ricart-Agrawala token-passing algorithm
boolean haveToken ← true in node 0, false in others
integer array[NODES] requested ← [0,. . . ,0]
integer array[NODES] granted ← [0,. . . ,0]
integer myNum ← 0
boolean inCS ← false
sendToken
if exists N such that requested[N] > granted[N]
for some such N
send(token, N, granted)
haveToken ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.22
 Algorithm 10.3: Ricart-Agrawala token-passing algorithm (continued)

Main
loop forever
p1: non-critical section
p2: if not haveToken
p3: myNum ← myNum + 1
p4: for all other nodes N
p5: send(request, N, myID, myNum)
p6: receive(token, granted)
p7: haveToken ← true
p8: inCS ← true
p9: critical section
p10: granted[myID] ← myNum
p11: inCS ← false
p12: sendToken

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.23
 Algorithm 10.3: Ricart-Agrawala token-passing algorithm (continued)

Receive
integer source, reqNum
loop forever
p13: receive(request, source, reqNum)
p14: requested[source] ← max(requested[source], reqNum)
p15: if haveToken and not inCS
p16: sendToken

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.24
 Data Structures for RA Token-Passing Algorithm

requested 4 3 0 5 1

granted 4 2 2 4 1

Aaron Becky Chloe Danielle Evan

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.25
 Distributed System for Neilsen-Mizuno Algorithm

?
- Danielle 
- Evan
6 I@
@
@  6
@R@
@
Chloe

@@
I
@
? @ @ ?
 R
@
Aaron - Becky 
6

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.26
 Spanning Tree in Neilsen-Mizuno Algorithm

Danielle  Evan
@
R
@
Chloe
@
I
@
Aaron - Becky

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.27
 Neilsen-Mizuno Algorithm (1)

Aaron Becky - Chloe  Danielle  Evan

Aaron  Becky Chloe  Danielle  Evan

?
Aaron  Becky  Chloe  Danielle  Evan

?
Aaron Becky - Chloe - Danielle - Evan

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.28
 Neilsen-Mizuno Algorithm (2)

?
Aaron - Becky - Chloe - Danielle - Evan
6

Aaron - Becky - Chloe - Danielle - Evan

6

Aaron - Becky - Chloe - Danielle - Evan

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.29
 Algorithm 10.4: Neilsen-Mizuno token-passing algorithm
integer parent ← (initialized to form a tree)
integer deferred ← 0
boolean holding ← true in the root, false in others
Main
loop forever
p1: non-critical section
p2: if not holding
p3: send(request, parent, myID, myID)
p4: parent ← 0
p5: receive(token)
p6: holding ← false
p7: critical section
p8: if deferred 6= 0
p9: send(token, deferred)
p10: deferred ← 0
p11: else holding ← true

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.30
 Algorithm 10.4: Neilsen-Mizuno token-passing algorithm (continued)

Receive
integer source, originator
loop forever
p12: receive(request, source, originator)
p13: if parent = 0
p14: if holding
p15: send(token, originator)
p16: holding ← false
p17: else deferred ← originator
p18: else send(request, parent, myID, originator)
p19: parent ← source

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 10.31
 Distributed System with an Environment Node

node2 H
*
 HH
 
6 HH
 j
H
node1 node4
HH  
HH ? 
 
Hj
H 

node3

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.1
 Back Edges

 node2 Y
H
HHH
  * HHH
  
6 6 HH

  Hj
HHH
node1 node4
YH
H HH  *

H H
HHHH ? ? 
HHj 


H node3 

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.2
 Algorithm 11.1: Dijkstra-Scholten algorithm (preliminary)
integer array[incoming] inDeficit ← [0,. . . ,0]
integer inDeficit ← 0, integer outDeficit ← 0
send message
p1: send(message, destination, myID)
p2: increment outDeficit
receive message
p3: receive(message, source)
p4: increment inDeficit[source] and inDeficit
send signal
p5: when inDeficit > 1 or
(inDeficit = 1 and isTerminated and outDeficit = 0)
p6: E ← some edge E with inDeficit[E] 6= 0
p7: send(signal, E, myID)
p8: decrement inDeficit[E] and inDeficit
receive signal
p9: receive(signal, _)
p10: decrement outDeficit

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.3
 Algorithm 11.2: Dijkstra-Scholten algorithm (env., preliminary)
integer outDeficit ← 0
computation
p1: for all outgoing edges E
p2: send(message, E, myID)
p3: increment outDeficit
p4: await outDeficit = 0
p5: announce system termination
receive signal
p6: receive(signal, source)
p7: decrement outDeficit

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.4
 The Preliminary DS Algorithm is Unsafe

node2
*

 e2 6

node1
HH
HHe3 ?
Hj
H
node3

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.5
 Spanning Tree

node2 HH
*

  HH
 H j
H
node1 node4

?
node3

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.6
 Algorithm 11.3: Dijkstra-Scholten algorithm
integer array[incoming] inDeficit ← [0,. . . ,0]
integer inDeficit ← 0
integer outDeficit ← 0
integer parent ← −1
send message
p1: when parent 6= −1 // Only active nodes send messages
p2: send(message, destination, myID)
p3: increment outDeficit
receive message
p4: receive(message,source)
p5: if parent = −1
p6: parent ← source
p7: increment inDeficit[source] and inDeficit

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.7
 Algorithm 11.3: Dijkstra-Scholten algorithm (continued)

send signal
p8: when inDeficit > 1
p9: E ← some edge E for which
(inDeficit[E] > 1) or (inDeficit[E] = 1 and E 6= parent)
p10: send(signal, E, myID)
p11: decrement inDeficit[E] and inDeficit
p12: or when inDeficit = 1 and isTerminated and outDeficit = 0
p13: send(signal, parent, myID)
p14: inDeficit[parent] ← 0
p15: inDeficit ← 0
p16: parent ← −1
receive signal
p17: receive(signal, _)
p18: decrement outDeficit

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.8
 Partial Scenario for DS Algorithm

Action node1 node2 node3 node4

1⇒2 (-1,[ ],0) (-1,[0,0],0) (-1,[0,0,0],0) (-1,[0],0)
2⇒4 (-1,[ ],1) (1,[1,0],0) (-1,[0,0,0],0) (-1,[0],0)
2⇒3 (-1,[ ],1) (1,[1,0],1) (-1,[0,0,0],0) (2,[1],0)
2⇒4 (-1,[ ],1) (1,[1,0],2) (2,[0,1,0],0) (2,[1],0)
1⇒3 (-1,[ ],1) (1,[1,0],3) (2,[0,1,0],0) (2,[2],0)
3⇒2 (-1,[ ],2) (1,[1,0],3) (2,[1,1,0],0) (2,[2],0)
4⇒3 (-1,[ ],2) (1,[1,1],3) (2,[1,1,0],1) (2,[2],0)
(-1,[ ],2) (1,[1,1],3) (2,[1,1,1],1) (2,[2],1)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.9
 Data Structures After Completion of Partial Scenario

1
* node2 (3) H
 HH
  1
6 HH 2
 j
H
node1 (2) node4 (1)
HH 
HH 1 
? 
H 
j node3 (1) 
H 
1 1

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.10
 Algorithm 11.4: Credit-recovery algorithm (environment node)
float weight ← 1.0
computation
p1: for all outgoing edges E
p2: weight ← weight / 2.0
p3: send(message, E, weight)
p4: await weight = 1.0
p5: announce system termination
receive signal
p6: receive(signal, w)
p7: weight ← weight + w

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.11
 Algorithm 11.5: Credit-recovery algorithm (non-environment node)
constant integer parent ← 0 // Environment node
boolean active ← false
float weight ← 0.0
send message
p1: if active // Only active nodes send messages
p2: weight ← weight / 2.0
p3: send(message, destination, myID, weight)
receive message
p4: receive(message, source, w)
p5: active ← true
p6: weight ← weight + w
send signal
p7: when terminated
p8: send(signal, parent, weight)
p9: weight ← 0.0
p10: active ← false

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.12
 Messages on a Channel

m14, m13, m12, m11, m10

node1 - node2

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.13
 Sending a Marker

m14, m13, m12, marker, m11, m10

node1 - node2

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.14
 Algorithm 11.6: Chandy-Lamport algorithm for global snapshots
integer array[outgoing] lastSent ← [0, . . . , 0]
integer array[incoming] lastReceived ← [0, . . . , 0]
integer array[outgoing] stateAtRecord ← [−1, . . . , −1]
integer array[incoming] messageAtRecord ← [−1, . . . , −1]
integer array[incoming] messageAtMarker ← [−1, . . . , −1]
send message
p1: send(message, destination, myID)
p2: lastSent[destination] ← message
receive message
p3: receive(message,source)
p4: lastReceived[source] ← message

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.15
 Algorithm 11.6: Chandy-Lamport algorithm for global snapshots (continued)

receive marker
p6: receive(marker, source)
p7: messageAtMarker[source] ← lastReceived[source]
p8: if stateAtRecord = [−1,. . . ,−1] // Not yet recorded
p9: stateAtRecord ← lastSent
p10: messageAtRecord ← lastReceived
p11: for all outgoing edges E
p12: send(marker, E, myID)
record state
p13: await markers received on all incoming edges
p14: recordState

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.16
 Messages and Markers for a Scenario

node2
 @
M,3,2,1 @ M,3,2,1
@
R
@
M,3,2,1
node1 - node3

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.17
 Scenario for CL Algorithm (1)

Action node1 node2

ls lr st rc mk ls lr st rc mk
[3,3] [3] [3]
1M⇒2 [3,3] [3,3] [3] [3]
1M⇒3 [3,3] [3,3] [3] [3]
2⇐1M [3,3] [3,3] [3] [3]
2M⇒3 [3,3] [3,3] [3] [3] [3] [3] [3]

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.18
 Scenario for CL Algorithm (2)

Action node3
ls lr st rc mk
3⇐2
3⇐2 [0,1]
3⇐2 [0,2]
3⇐2M [0,3]
3⇐1 [0,3] [0,3] [0,3]
3⇐1 [1,3] [0,3] [0,3]
3⇐1 [2,3] [0,3] [0,3]
3⇐1M [3,3] [0,3] [0,3]
[3,3] [0,3] [3,3]

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 11.19
 Architecture for a Reliable System

Temperature


- CPU
 Q HH
JQ  Throttle
j  
HH
J Q
J Qs
CPU - Comparator -
Pressure J3   
  *

 J 
 ^
J
- CPU 


c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.1
 Algorithm 12.1: Consensus - one-round algorithm
planType finalPlan
planType array[generals] plan
p1: plan[myID] ← chooseAttackOrRetreat
p2: for all other generals G
p3: send(G, myID, plan[myID])
p4: for all other generals G
p5: receive(G, plan[G])
p6: finalPlan ← majority(plan)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.2
 Messages Sent in a One-Round Algorithm

Basil A
I
@
 @ @
– A A@ @ R
@ @
 R R @
@
Zoe A - Leo R
A

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.3
 Data Structures in a One-Round Algorithm

Leo Zoe
general plan general plans
Basil A Basil –
Leo R Leo R
Zoe A Zoe A
majority A majority R

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.4
 Algorithm 12.2: Consensus - Byzantine Generals algorithm
planType finalPlan
planType array[generals] plan, majorityPlan
planType array[generals, generals] reportedPlan
p1: plan[myID] ← chooseAttackOrRetreat
p2: for all other generals G // First round
p3: send(G, myID, plan[myID])
p4: for all other generals G
p5: receive(G, plan[G])
p6: for all other generals G // Second round
p7: for all other generals G’ except G
p8: send(G’, myID, G, plan[G])
p9: for all other generals G
p10: for all other generals G’ except G
p11: receive(G, G’, reportedPlan[G, G’])
p12: for all other generals G // First vote
p13: majorityPlan[G] ← majority(plan[G] ∪ reportedPlan[*, G])
p14: majorityPlan[myID] ← plan[myID] // Second vote
p15: finalPlan ← majority(majorityPlan)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.5
 Data Structure for Crash Failure - First Scenario (Leo)

Leo
general plan reported by majority
Basil Zoe
Basil A – A
Leo R R
Zoe A – A
majority A

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.6
 Data Structure for Crash Failure - First Scenario (Zoe)

Zoe
general plan reported by majority
Basil Leo
Basil – A A
Leo R – R
Zoe A A
majority A

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.7
 Data Structure for Crash Failure - Second Scenario (Leo)

Leo
general plan reported by majority
Basil Zoe
Basil A A A
Leo R R
Zoe A A A
majority A

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.8
 Data Structure for Crash Failure - Second Scenario (Zoe)

Zoe
general plan reported by majority
Basil Leo
Basil A A A
Leo R – R
Zoe A A
majority A

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.9
 Knowledge Tree about Basil for Crash Failure - First Scenario

Basil A
  HH

HH
Zoe A Leo A

Leo A Zoe A

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.10
 Knowledge Tree about Basil for Crash Failure - Second Scenario

Basil X
HH
H
H
Leo X

Zoe X

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.11
 Knowledge Tree about Leo for Crash Failure

Leo X
  HH

HH
Zoe X Basil X

Basil X

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.12
 Messages Sent for Byzantine Failure with Three Generals

Basil
I
@
 @ @
R A A@ @ R
@ @
 R R @
@
Zoe A - Leo R
A

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.13
 Data Stuctures for Leo and Zoe After First Round

Leo Zoe
general plans general plans
Basil A Basil R
Leo R Leo R
Zoe A Zoe A
majority A majority R

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.14
 Data Stuctures for Leo After Second Round

Leo
general plans reported by majority
Basil Zoe
Basil A A A
Leo R R
Zoe A R R
majority R

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.15
 Data Stuctures for Zoe After Second Round

Zoe
general plans reported by majority
Basil Leo
Basil A A A
Leo R R R
Zoe A A
majority A

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.16
 Knowledge Tree About Zoe

Zoe A
  HH

HH
Leo A Basil A

Basil A Leo R

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.17
 Four Generals: Data Structure of Basil (1)

Basil
general plan reported by majority
John Leo Zoe
Basil A A
John A A ? A
Leo R R ? R
Zoe ? ? ? ?
majority ?

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.18
 Four Generals: Data Structure of Basil (2)

Basil
general plans reported by majority
John Leo Zoe
Basil A A
John A A ? A
Leo R R ? R
Zoe R A R R
R

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.19
 Knowledge Tree About Loyal General Leo

Leo X
 HH
 HH

  HH
 HH
Basil X John X Zoe X

A
A
A

A
A
A
John X Zoe X Basil X Zoe X Basil Y John Z

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.20
 Knowledge Tree About Traitor Zoe

Zoe
 HH
 HH

  HH
 HH
Basil X John Y Leo Z

A
A
A

A
A
A
John X Leo X Basil Y Leo Y Basil Z John Z

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.21
 Complexity of the Byzantine Generals Algorithm

traitors generals messages

1 4 36
2 7 392
3 10 1790
4 13 5408

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.22
 Algorithm 12.3: Consensus - flooding algorithm
planType finalPlan
set of planType plan ← { chooseAttackOrRetreat }
set of planType receivedPlan
p1: do t + 1 times
p2: for all other generals G
p3: send(G, plan)
p4: for all other generals G
p5: receive(G, receivedPlan)
p6: plan ← plan ∪ receivedPlan
p7: finalPlan ← majority(plan)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.23
 Flooding Algorithm with No Crash: Knowledge Tree About Leo

Leo X

? ?
Zoe X  Basil X John X
@ @
@R
@ @R
@
Zoe X  Zoe X John X Zoe X Basil X

? ? ? ?
Zoe X  Zoe X Zoe X Zoe X Zoe X

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.24
 Flooding Algorithm with Crash: Knowledge Tree About Leo (1)

Leo X

?
Basil X
@
@
R
@
Zoe X John X

? ?
Zoe X Zoe X

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.25
 Flooding Algorithm with Crash: Knowledge Tree About Leo (2)

Leo X

?
Basil X
@
@
R
@
John X

?
Zoe X

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.26
 Algorithm 12.4: Consensus - King algorithm
planType finalPlan, myMajority, kingPlan
planType array[generals] plan
integer votesMajority
p1: plan[myID] ← chooseAttackOrRetreat

p2: do two times

p3: for all other generals G // First and third rounds
p4: send(G, myID, plan[myID])
p5: for all other generals G
p6: receive(G, plan[G])
p7: myMajority ← majority(plan)
p8: votesMajority ← number of votes for myMajority

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.27
 Algorithm 12.4: Consensus - King algorithm (continued)

p9: if my turn to be king // Second and fourth rounds

p10: for all other generals G
p11: send(G, myID, myMajority)
p12: plan[myID] ← myMajority
else
p13: receive(kingID, kingPlan)
p14: if votesMajority > 3
p15: plan[myID] ← myMajority
else
p16: plan[myID] ← kingPlan

p17: finalPlan ← plan[myID] // Final decision

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.28
 Scenario for King Algorithm - First King Loyal General Zoe (1)
Basil
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A A R R R R 3

John
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A A R A R A 3

Leo
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A A R A R A 3

Zoe
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A A R R R R 3
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.29
 Scenario for King Algorithm - First King Loyal General Zoe (2)
Basil
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R R

John
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R R

Leo
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R R

Zoe
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.30
 Scenario for King Algorithm - First King Loyal General Zoe (3)
Basil
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R R R ? R R 4–5

John
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R R R ? R R 4–5

Leo
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R R R ? R R 4–5

Zoe
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R R R ? R R 4–5
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.31
 Scenario for King Algorithm - First King Traitor Mike (1)
Basil
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R R

John
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A A

Leo
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A A

Zoe
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R R
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.32
 Scenario for King Algorithm - First King Traitor Mike (2)
Basil
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R A A ? R ? 3

John
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R A A ? R ? 3

Leo
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R A A ? R ? 3

Zoe
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
R A A ? R ? 3
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.33
 Scenario for King Algorithm - First King Traitor Mike (3)
Basil
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A A

John
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A A

Leo
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A A

Zoe
Basil John Leo Mike Zoe myMajority votesMajority kingPlan
A
c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.34
 Complexity of Byzantine Generals and King Algorithms

traitors generals messages traitors generals messages

1 4 36 1 5 48
2 7 392 2 9 240
3 10 1790 3 13 672
4 13 5408 4 17 1440

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.35
 Impossibility with Three Generals (1)

Zoe X Leo Y
@
@ @
@
@ @
Leo John Zoe John
x1 , . . . , xn y1 , . . . , yn

Leo Zoe
u1 , . . . , um v1 , . . . , vm

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.36
 Impossibility with Three Generals (2)

John
@
@
@
Leo Zoe
x1 , . . . , xn y1 , . . . , yn

Zoe Leo
x1 , . . . , xn y1 , . . . , yn

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.37
 Exercise for Byzantine Generals Algorithm

Zoe
general plan reported by majority
Basil John Leo
Basil R A R ?
John A R A ?
Leo R R R ?
Zoe A A
?

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 12.38
 Release Time, Execution Time and Relative Deadline

 D -

r  e -

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.1
 Periodic Task

 p - p - p -

r r r r

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.2
 Deadline is a Multiple of the Period

 D -

r  e -

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.3
 Architecture of Ariane Control System

Main
Sensors - INS -
Computer
- Actuators

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.4
 Synchronization Window in the Space Shuttle

0 225 240 1000

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.5
 Synchronous System

Sample

Compute

Control
T1 T2 T1 T2

Telemetry

Self-test

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.6
 Synchronous System Scheduling Table

0 1 2 3 4
Sample Compute Control Telemetry 1 Self-test

5 6 7 8 9
Sample Compute Control Telemetry 2 Telemetry 1

10 11 12 13 14
Sample Compute Control Telemetry 2 Self-test

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.7
 Algorithm 13.1: Synchronous scheduler
taskAddressType array[0..numberFrames-1] tasks ←
[task address,. . . ,task address]
integer currentFrame ← 0
p1: loop
p2: await beginning of frame
p3: invoke tasks[currentFrame]
p4: increment currentFrame modulo numberFrames

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.8
 Algorithm 13.2: Producer-consumer (synchronous system)
queue of dataType buffer1, buffer2
sample compute control
dataType d dataType d1, d2 dataType d
p1: d ← sample q1: d1 ← take(buffer1) r1: d ← take(buffer2)
p2: append(d, buffer1) q2: d2 ← compute(d1) r2: control(d)
p3: q3: append(d2, buffer2) r3:

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.9
 Asynchronous System

Data management

Communications

Telemetry

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.10
 Algorithm 13.3: Asynchronous scheduler
queue of taskAddressType readyQueue ← . . .
taskAddressType currentTask
loop forever
p1: await readyQueue not empty
p2: currentTask ← take head of readyQueue
p3: invoke currentTask

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.11
 Algorithm 13.4: Preemptive scheduler
queue of taskAddressType readyQueue ← . . .
taskAddressType currentTask
loop forever
p1: await a scheduling event
p2: if currentTask.priority < highest priority of a task on readyQueue
p3: save partial computation of currentTask and place on readyQueue
p4: currentTask ← take task of highest priority from readyQueue
p5: invoke currentTask
p6: else if currentTask’s timeslice is past and
currentTask.priority = priority of some task on readyQueue
p7: save partial computation of currentTask and place on readyQueue
p8: currentTask ← take a task of the same priority from readyQueue
p9: invoke currentTask
p10: else resume currentTask

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.12
 Preemptive Scheduling

Watchdog

Data management

Communications

Telemetry

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.13
 Algorithm 13.5: Watchdog supervision of response time
boolean ran ← false
data management watchdog
loop forever loop forever
p1: do data management q1: await ninth frame
p2: ran ← true q2: if ran is false
p3: rejoin readyQueue q3: notify response-time overflow
p4: q4: ran ← false
p5: q5: rejoin readyQueue

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.14
 Algorithm 13.6: Real-time buffering - throw away new data
queue of dataType buffer ← empty queue
sample compute
dataType d dataType d
loop forever loop forever
p1: d ← sample q1: await buffer not empty
p2: if buffer is full do nothing q2: d ← take(buffer)
p3: else append(d,buffer) q3: compute(d)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.15
 Algorithm 13.7: Real-time buffering - overwrite old data
queue of dataType buffer ← empty queue
sample compute
dataType d dataType d
loop forever loop forever
p1: d ← sample q1: await buffer not empty
p2: append(d, buffer) q2: d ← take(buffer)
p3: q3: compute(d)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.16
 Interrupt Overflow on Apollo 11

Watchdog

Counter increments

Main task

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.17
 Priority Inversion (1)

 CS -

Data management

 CS -

Telemetry

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.18
 Priority Inversion (2)

 CS -

Data management

Communications

 CS -

Telemetry

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.19
 Priority Inheritance

 CS -

Data management

Telemetry

Communications

 CS -

Telemetry

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.20
 Priority Inversion in Promela (1)
1 mtype = { idle, blocked, nonCS, CS, long };
2 mtype data = idle, comm = idle, telem = idle;
3 #define ready(p) (p != idle && p != blocked)
4

5 active proctype Data() {

6 do
7 :: data = nonCS;
8 enterCS(data);
9 exitCS(data);
10 data = idle ;
11 od
12 }
13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.21
 Priority Inversion in Promela (1)
16 active proctype Comm() provided (!ready(data)) {
17 do
18 :: comm = long;
19 comm = idle;
20 od
21 }
22 active proctype Telem()
23 provided (!ready(data) && !ready(comm)) {
24 do
25 :: telem = nonCS;
26 enterCS(telem);
27 exitCS(telem);
28 telem = idle ;
29 od
30 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.22
 Priority Inversion in Promela (2)
1 bit sem = 1;
2

3 inline enterCS(state ) {
4 atomic {
5 if
6 :: sem == 0 −>
7 state = blocked;
8 sem != 0;
9 :: else −>
10 fi ;
11 sem = 0;
12 state = CS;
13 }
14 }
15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.23
 Priority Inversion in Promela (2)

16 inline exitCS(state ) {
17 atomic {
18 sem = 1;
19 state = idle
20 }
21 }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.24
 Priority Inheritance in Promela
1 #define inherit (p) (p == CS)
2 active proctype Data() {
3 do
4 :: data = nonCS;
5 assert( ! (telem == CS && comm == long) );
6 enterCS(data); exitCS(data);
7 data = idle ;
8 od
9 }
10 active proctype Comm()
11 provided (!ready(data) && !inherit (telem))
12 { ... }
13 active proctype Telem()
14 provided (! ready(data) && !ready(comm) || inherit (telem))
15 { ... }

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.25
 Data Structures in Simpson’s Algorithm

lastWrittenPair lastReadPair
@
@
R
@
0 1 0 1

0 1
I
@ 
@
@
@ 0 1
@
@

currentSlot

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.26
 Algorithm 13.8: Simpson’s four-slot algorithm
dataType array[0..1,0..1] data ← default initial values
bit array[0..1] currentSlot ← { 0, 0 }
bit lastWrittenPair ← 1, lastReadPair ← 1
writer
bit writePair, writeSlot
dataType item
loop forever
p1: item ← produce
p2: writePair ← 1− lastReadPair
p3: writeSlot ← 1− currentSlot[writePair]
p4: data[writePair, writeSlot] ← item
p5: currentSlot[writePair] ← writeSlot
p6: lastWrittenPair ← writePair

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.27
 Algorithm 13.8: Simpson’s four-slot algorithm (continued)

reader
bit readPair, readSlot
dataType item
loop forever
p7: readPair ← lastWrittenPair
p8: lastReadPair ← readPair
p9: readSlot ← currentSlot[readPair]
p10: item ← data[readPair, readSlot]
p11: consume(item)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.28
 Algorithm 13.9: Event signaling
binary semaphore s ← 0
p q
p1: if decision is to wait for event q1: do something to cause event
p2: wait(s) q2: signal(s)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.29
 Suspension Objects in Ada

1 package Ada.Synchronous_Task_Control is
2 type Suspension_Object is limited private;
3 procedure Set_True(S : in out Suspension_Object);
4 procedure Set_False(S : in out Suspension_Object);
5 function Current_State(S : Suspension_Object)
6 return Boolean;
7 procedure Suspend_Until_True(
8 S : in out Suspension_Object);
9 private
10 −− not specified by the language
11 end Ada.Synchronous_Task_Control;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.30
 Algorithm 13.10: Suspension object - event signaling
Suspension_Object SO ← (false by default)
p q
p1: if decision is to wait for event q1: do something to cause event
p2: Suspend_Until_True(SO) q2: Set_True(SO)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.31
 Transition in UPPAAL

 
clk >= 12, ch ?, n := n + 1 -
 

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.32
 Feasible Priority Assignment

P1

P2

0 1 2 3 4 5

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.33
 Infeasible Priority Assignment

P2

P1

0 1 2 3 4 5

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.34
 Algorithm 13.11: Periodic task
constant integer period ← . . .
integer next ← currentTime
loop forever
p1: delay next − currentTime
p2: compute
p3: next ← next + period

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide 13.35
 Semantics of Propositional Operators

A v(A1 ) v(A2 ) v(A)

¬ A1 T F
¬ A1 F T
A1 ∨ A2 F F F
A1 ∨ A2 otherwise T
A1 ∧ A2 T T T
A1 ∧ A2 otherwise F
A1 → A2 T F F
A1 → A2 otherwise T
A1 ↔ A2 v(A1 ) = v(A2 ) T
A1 ↔ A2 v(A1 ) 6= v(A2 ) F

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide B.1
 Wason Selection Task

p3 p5 flag = 1 flag = 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide B.2
 Algorithm B.1: Verification example
integer x1, integer x2
integer y1 ← 0, integer y2 ← 0, integer y3
p1: read(x1,x2)
p2: y3 ← x1
p3: while y3 6= 0
p4: if y2+1 = x2
p5: y1 ← y1 + 1
p6: y2 ← 0
p7: else
p8: y2 ← y2 + 1
p9: y3 ← y3 − 1
p10: write(y1,y2)

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide B.3
 Spark Program for Integer Division
1 −−# main_program;
2 procedure Divide(X1,X2: in Integer ; Q,R : out Integer )
3 −−# derives Q, R from X1,X2;
4 −−# pre (X1 >= 0) and (X2 > 0);
5 −−# post (X1 = Q ∗ X2 + R) and (X2 > R) and (R >= 0);
6 is
7 N: Integer ;
8

10

11

12

13

14

15

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide B.4
 Spark Program for Integer Division

16 begin
17 Q := 0; R := 0; N := X1;
18 while N /= 0
19 −−# assert (X1 = Q∗X2+R+N) and (X2 > R) and (R >= 0);
20 loop
21 if R+1 = X2 then
22 Q := Q + 1; R := 0;
23 else
24 R := R + 1;
25 end if ;
26 N := N − 1;
27 end loop;
28 end Divide;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide B.5
 Integer Division
1 procedure Divide(X1,X2: in Integer ; Q,R : out Integer ) is
2 N: Integer ;
3 begin
4 −− pre (X1 >= 0) and (X2 > 0);
5 Q := 0; R := 0; N := X1;
6 while N /= 0
7 −− assert (X1 = Q∗X2+R+N) and (X2 > R) and (R >= 0);
8 loop
9 if R+1 = X2 then Q := Q + 1; R := 0;
10 else R := R + 1;
11 end if ;
12 N := N − 1;
13 end loop;
14 −− post (X1 = Q ∗ X2 + R) and (X2 > R) and (R >= 0);
15 end Divide;

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide B.6
 Verification Conditions for Integer Division
Precondition to assertion:

(X1 ≥ 0) ∧ (X2 > 0) →

(X1 = Q · X2 + R + N) ∧ (X2 > R) ∧ (R ≥ 0).

Assertion to postcondition:

(X1 = Q · X2 + R + N) ∧ (X2 > R) ∧ (R ≥ 0) ∧ (N = 0) →

(X1 = Q · X2 + R) ∧ (X2 > R) ∧ (R ≥ 0).

Assertion to assertion by then branch:

(X1 = Q · X2 + R + N) ∧ (X2 > R) ∧ (R ≥ 0) ∧ (R + 1 = X2) →

(X1 = Q0 · X2 + R0 + N 0 ) ∧ (X2 > R0 ) ∧ (R0 ≥ 0).

Assertion to assertion by else branch:

(X1 = Q · X2 + R + N) ∧ (X2 > R) ∧ (R ≥ 0) ∧ (R + 1 6= X2) →

(X1 = Q0 · X2 + R0 + N 0 ) ∧ (X2 > R0 ) ∧ (R0 ≥ 0).

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide B.7
 The Sleeping Barber

n producer consumer Buffer notEmpty

1 append(d, Buffer) wait(notEmpty) [] 0
2 signal(notEmpty) wait(notEmpty) [1] 0
3 append(d, Buffer) wait(notEmpty) [1] 1
4 append(d, Buffer) d ← take(Buffer) [1] 0
5 append(d, Buffer) wait(notEmpty) [] 0

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide C.1
 Synchronizing Precedence

node2 H
*
 HH
 
HH
 j
H
node1 node4
HH  
HH ? 
 
Hj
H 

node3

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide C.2
 Algorithm C.1: Barrier synchronization
global variables for synchronization
loop forever
p1: wait to be released
p2: computation
p3: wait for all processes to finish their computation

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide C.3
 The Stable Marriage Problem

Man List of women Woman List of men

1 2 4 1 3 1 2 1 4 3
2 3 1 4 2 2 4 3 1 2
3 2 3 1 4 3 1 4 3 2
4 4 1 3 2 4 2 1 4 3

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide C.4
 Algorithm C.2: Gale-Shapley algorithm for stable marriage
integer list freeMen ← {1,. . . ,n}
integer list freeWomen ← {1,. . . ,n}
integer pair-list matched ← ∅
integer array[1..n, 1..n] menPrefs ← . . .
integer array[1..n, 1..n] womenPrefs ← . . .
integer array[1..n] next ← 1
p1: while freeMen 6= ∅, choose some m from freeMen
p2: w ← menPrefs[m, next[m]]
p3: next[m] ← next[m] + 1
p4: if w in freeWomen
p5: add (m,w) to matched, and remove w from freeWomen
p6: else if w prefers m to m’ // where (m’,w) in matched
p7: replace (m’,w) in matched by (m,w), and remove m’ from freeMen
p8: else // w rejects m, and nothing is changed

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide C.5
 The n-Queens Problem

1 Q

2 Q

3 Q

4 Q

5 Q

6 Q

7 Q

8 Q

1 2 3 4 5 6 7 8

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide C.6
 The Architecture of BACI

Pascal - Pascal
source compiler @

R
@ - Interpreter
Editor P-code
@ 
R
@ C - C
source compiler

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide D.1
 The Architecture of Spin

Promela Parser/
source
- Trail
Generator

6 ? 6

Editor LTL Verifier Computer

translator C source
@
@ 6 ? 6
R
@
LTL C - Verifier
formula Compiler Executable

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide D.2
 Cycles in a State Diagram

' $ ' $ ' $

··· ··· ···
criticalp = 0 - criticalp = 0 - criticalp = 0
criticalq = 0 criticalq = 1 criticalq = 0
& % & % & %

' $ ' $ ' ? ? $

··· ··· ···
criticalp = 0  criticalp = 0  criticalp = 0
criticalq = 0 criticalq = 1 criticalq = 0
& % & % & %

c M. Ben-Ari 2006
M. Ben-Ari. Principles of Concurrent and Distributed Programming, Second edition ­ Slide D.3