1. Concurrency: Mutual Exclusion and Synchronization - Chapter 5 (Part 2)
tally Bounds for N Processes
Dekker’s Algorithm (HW Q2)
Mutual Exclusion
Dead Lock
Starvation
Peterson’s Algorithm (HW Q1)
Mutual Exclusion - Interrupt Disabling
Mutual Exclusion Machine Instructions (HW Q3)

2. tally Bounds for N Processes (1)
Consider the following program (next slide)
Assume processes can execute at any relative speed and that a value can only be incremented after it has been loaded into a register by a separate machine instruction.
Suppose that n number of these processes are permitted to execute in parallel. Determine the proper lower bound and upper bound on the final value of the shared variable tally output by this concurrent program.

3. const n = 50; * tally (2) *
var tally: integer;
procedure total;
var count: integer;
begin
for count :=1 to n do tally := tally + 1
end;
begin (*main program *)
tally := 0;
parbegin
total; total; …… total; * n number of total *
parend;
write (tally)
end.

4. Possible Solutions - tally Bounds for N Processes (3)
Upper bound on the final value of the shared variable tally output by this concurrent program should be n*50.
Lower bound of tally
- lack of mutual exclusion: n ???
- lack of mutual exclusion: 3 ???
- lack of mutual exclusion: 2 ???

5. Process P1 (Both share tally:=0) Process P2
for count:=1 to n for count:=1 to n
do tally:=tally do tally:=tally+1
n=1, P1 did tally+1
P1 losing processor
did not store this value
tally:= P2 did for loop to n=49
tally:=49
P2 losing processor
P1 regains control processor
replacing tally (49) with 1
tally:= *Solution of tally (4)*
P1 losing processor again

6. tally:=1 *Solution of tally (5)*
P1 losing processor again
P2 regains control Processor
load tally (1) to register
But no time to do tally+1
P2 losing control processor
P1 regains control processor
do for loop from n:=2 to 50
tally:=50
P3, P4, …, Pn do for loop
(n-2) times and
tally:= (n-1)*50
P2 is reactivated
using register value (1) and do tally:=tally(register value)+1
tally:=2

7. Dekker’s Algorithm
Mutual Exclusion ?
- Mutual exclusion is enforced in the Dekker’s Algorithm.
Dead Lock?
- No dead lock is happened in the Dekker’s Algorithm.
Starvation?
- No starvation in the Dekker’s Algorithm.

8. var flag:array[ 0.. 1]; * a shared global variable*
turn: 0..1; * a referee’s message*
procedure P0;
begin
repeat
flag[0]:= true; *attempt 3 mutual exclusion *
while flag[1] do if turn =1 then
begin *attempt 4 avoiding dead lock*
if turn=0 P0’s turn flag[0]:=false;
to check P1’s igloo while turn:=1 do{nothing};
avoid mutual courtesy flag[0]:=true
end;
<critical section> *flag[1]=false, P0 goes critical part*
turn:=1; *P1’s turn to check P0’s igloo *
flag[0]:=false; *P1 can go critical section *
<remainder>
forever

9. procedure P1;
begin
repeat
flag[1]:= true; *attempt 3 mutual exclusion *
while flag[0] do if turn =0 then
begin *attempt 4 avoiding dead lock*
if turn=1 P1’s turn flag[1]:=false;
to check P0’s igloo while turn:=0 do{nothing};
avoid mutual courtesy flag[1]:=true
end;
<critical section> *flag[0]=false, P1 goes critical part*
turn:=0; *P0’s turn to check P1’s igloo *
flag[1]:=false; *P0 can go critical section *
<remainder>
forever

10. Mutual Exclusion forced in Dekker’s Algorithm (1) - Question
Prove that mutual exclusion is enforced in the Dekker’s algorithm.
Hint: Show that when Pi enters its critical section, the following expression is true:
flag[i] and (not flag[1-i])
It means that we should prove following expressions:
(flag[1] and (not flag[0])) = true
(flag[0] and (not flag[1])) = true

11. No Dead Lock in Dekker’s Algorithm (1) - Question (HW Q2)
Prove that a process requiring access to its critical section will not be delayed indefinitely in the Dekker’s algorithm.
Hint: Consider the following cases:
(1) A single process is attempting to enter the critical section;
(2) both processes are attempting to enter the critical section, and
(2a) turn=0 and flag[0] = false, and
(2b) turn=0 and flag[0] = true.

12. No Starvation in Dekker’s Algorithm (1) - Program
var turn: integer; * turn:=0, 1, or 2 *
......
Begin
flag[0]:=false;
flag[1]:=false;
flag[2]:=false;
turn:=1;
parbegin
P0; P1; P2
parend
end.

13. var flag:array[ 0.. 1]; * a shared global variable*
turn: integer; * a referee’s message, turn:=0, 1, or 2*
procedure P0;
begin
repeat
flag[0]:= true; *attempt 3 mutual exclusion *
while (flag[1]or flag[2]) do if ( turn =1 or turn=2) then
begin *attempt 4 avoiding dead lock*
if turn=0 P0’s turn flag[0]:=false;
to check P1 & P2’s igloo while turn:=1 or 2 do{nothing};
avoid mutual courtesy flag[0]:=true
end; *flag[2]=false and
<critical section> *flag[1]=false, P0 goes critical part*
turn:=1; *P1’s turn to check P0’s igloo, or turn:=2*
flag[0]:=false; *P1, P2 can go critical section *
<remainder>
forever
end;
No Starvation in Dekker’s Algorithm (2) – P0 Algorithm

14. flag[1]:= true; *attempt 3 mutual exclusion *
procedure P1;
begin
repeat
flag[1]:= true; *attempt 3 mutual exclusion *
while (flag[0]or flag[2]) do if (turn =0 or turn=2)then
begin *attempt 4 avoiding dead lock*
if turn=1 P1’s turn flag[1]:=false;
to check P0 &P2’s igloo while turn:=2 or 0 do{nothing};
avoid mutual courtesy flag[1]:=true
end; *flag[2]=false and
<critical section> *flag[0]=false, P1 goes critical part*
turn:=2; *P2’s turn to check P1’s igloo, or turn:=0)*
flag[1]:=false; *P0, P2 can go critical section *
<remainder>
forever
end;
No Starvation in Dekker’s Algorithm (3) – P1 Algorithm

15. flag[2]:= true; *attempt 3 mutual exclusion *
procedure P2;
begin
repeat
flag[2]:= true; *attempt 3 mutual exclusion *
while (flag[0]or flag[1]) do if (turn =0 or turn=1)then
begin *attempt 4 avoiding dead lock*
if turn=2 P2’s turn flag[2]:=false;
to check P0 & P1’s igloo while turn:=0 or 1 do{nothing};
avoid mutual courtesy flag[2]:=true
end; *flag[1]=false and
<critical section> *flag[0]=false, P2 goes critical part*
turn:=0; *P0’s turn to check P1’s igloo,or turn:=1)*
flag[2]:=false; *P0 orP1 can go critical section *
<remainder>
forever
end;
No Starvation in Dekker’s Algorithm (4) – P2 Algorithm

16. var flag:array[ 0.. 1]; /* a shared global variable */
turn: integer; /* a referee’s message, turn:=0, 1, or 2*/
procedure P0; procedure P1;
begin begin
repeat repeat
flag[0]:= true; flag[1]:= true;
while (flag[1]or flag[2]) do while (flag[0]or flag[2]) do
if ( turn =1 or turn=2) then if ( turn =0 or turn=2) then
*avoiding dead lock* *avoiding dead lock*
end; end;
<critical section> <critical section>
turn:=1; turn:=2; /*P2 ->turn:=0*/
flag[0]:=false; flag[1]:=false;
<remainder> <remainder>
forever forever
end; end;
No Starvation in Dekker’s Algorithm (5) – P0 and P1 Algorithms

17. Peterson’s Algorithm (0)
2 Processed Peterson’s Algorithm
- Mutual exclusion is enforced in the Peterson’s Algorithm.
- No dead lock is happened in the Peterson’s Algorithm.
- No starvation in the Peterson’s Algorithm.
N Processed Peterson’s Algorithm

18. Peterson’s Algorithm - main (1)
var flag:array[0..1] of boolean
turn: 0 ..1;
......
Begin
flag[0]:=false;
flag[1]:=false;
turn:=1;
parbegin
P0; P1
parend
end.
* Main program is exactly the same as the Dekker’s algorithm

19. Peterson’s Algorithm - P0 (2)
procedure P0;
begin
repeat
flag[0]:= true; *attempt 3 mutual exclusion *
turn:= 1;
while flag[1] and turn =1 *attempt 4 mutual courtesy *
do{nothing};
<critical section> * flag[1]=false, or turn = 0 *
* P0 goes critical part *
flag[0]:=false; *P1 can go critical section *
<remainder>
forever
end;

20. Peterson’s Algorithm - P1 (3)
procedure P1;
begin
repeat
flag[1]:= true; *attempt 3 mutual exclusion *
turn:= 0;
while flag[0] and turn =0
do{nothing};
<critical section> * flag[0]=false, or turn = 1 *
* P1 goes critical part *
flag[1]:=false; *P0 can go critical section *
<remainder>
forever
end;

21. Peterson’s Algorithm - Mutual Exclusion (4)
procedure P0; procedure P1;
begin begin
repeat repeat
flag[0]:= true; flag[1]:= true;
turn:= 1; turn:= 0;
while flag[1] and turn = while flag[0] and turn =0
do{nothing}; do{nothing};
<critical section> <critical section>
flag[0]:=false; flag[1]:=false;
<remainder> <remainder>
forever forever
end; end;
Let turn:=0;
Once P0 has set flag[0] to true, P0 can enter its critical section and P1 can not enter its critical section.
If P1 already is in its critical section, then flag[1]=true and flag[0]=false, and P0 is blocked from entering its critical section.

22. Peterson’s Algorithm - Dead Lock (5)
procedure P0; procedure P1;
begin begin
repeat repeat
flag[0]:= true; flag[1]:= true;
turn:= 1; turn:= 0;
while flag[1] and turn = while flag[0] and turn =0
do{nothing}; do{nothing};
<critical section> <critical section>
flag[0]:=false; flag[1]:=false;
<remainder> <remainder>
forever forever
end; end;
P0 is blocked in its while loop. This means that flag[1] is true and turn=1.
Because turn = 1, P1 is not blocked its while loop. After critical section, P1 would set flag[1]:=false.
When flag[1]=false, P0 will go to critical section. P0 will not be blocked for ever.

23. Peterson’s Algorithm - three exhaustive cases (6)
P1 has no interest in its critical section
This case is impossible, because it implies flag[1] = false
P1 is waiting for its critical section
This case is also impossible, because if turn=1, P1 is able to enter its critical section
P1 is using its critical section repeatedly and therefore monopolizing access to it
This cannot happen, because P1 is obliged to give P0 an opportunity be setting turn to 0 before each attempt to enter its critical section.

24. Peterson’s Algorithm - N Processes Algorithm (7)
Procedure i
begin
repeat
1 for j=1 to N * j is the “stage” of the algorithm *
do { * at which process i executes *
2 q[i] = j; *q[i] indicates the stage of each process *
3 turn[j] = i; *turn[i] resolves simultaneity conflicts *
4 L: for k=1 to i-1, i+1 to N
5 if ( (q[k] >= j ) and (turn [j] = i)) goto L; }
6 q[i] = N; *a process enters critical phase, it passes to stage N*
critical section of process i;
7 q[i] = 0;
remainder section of process i;
until false
end

25. Peterson’s Algorithm - N Processes Algorithm (8)
var q:array[1..n] of integer;
turn: array[1..n-1] of integer;
......
Begin
q[1]:=0; q[2]:=0; ……; q[n]:=0;
turn[1]:=0; turn[2]:=0; ……; turn[n-1]:=0;
parbegin
P0; P1; P2; ……; Pn
parend
end.

26. Peterson’s Algorithm - N Processes Algorithm (8)
It has been proved that N processes Peterson’s algorithm provides mutual exclusion, deadlock freedom, and no starvation.
Horfi, M. “proof of a Mutual Exclusion Algorithm.” Operating Systems Review, January 1990.

27. Question 1 -Exercise/Home Work (1)
Consider the following program (This and next slides).
This is a software solution to the mutual exclusion problem proposed in [HYMA66]. Find a counterexample that demonstrates that this solution is incorrect
var blocked: array [0 ..1] of boolean;
turn: 0: 1;
procedure P (id: integer);
begin ( * main program *)
block[0] := false; blocked[1] := false; turn := 0;
parbegin
p(0); P(1)
parend
end.

28. Question 1 -Exercise/Home Work (2)
procedure P (id: integer);
begin
repeat
blocked[id] :=true;
while turn != id do
while blocked[1-id] do;
turn :=id
end;
<critical section>
blocked[id] :=false;
< remainder >
until false

29. Mutual Exclusion - Interrupt Disabling (1)
In an uniprocessor machine:
repeat
< disable interrupts >;
< critical section >;
<enable interrupts>;
< remainder>;
forever

30. Mutual Exclusion - Interrupt Disabling (2)
Disabling interrupts on one processor
- A process runs until it invokes an operating- system service or until it is interrupted
- On one processor, disabling interrupts guarantees mutual exclusion
- Efficiency of execution could be noticeably degraded
Disabling interrupts on more than two processors will not guarantee mutual exclusion

31. Mutual Exclusion Machine Instructions (1)
At a hardware level, access to a memory location exclude any other access to that same location.
One machine instruction is used to update a memory location so other instructions cannot interfere.
For mutual exclusion purpose, several machine instructions that carry out two actions of a single memory location with one instruction fetch cycle have been proposed.

32. Mutual Exclusion Machine Instructions (2)
Mutual exclusion machine instructions can be used for single and multiple processors
Mutual exclusion machine instructions can be used for multiple critical sections

33. Test and Set Instruction -Mutual Exclusion Machine Instructions (3)
Function testset (var i: integer): boolean
begin
if i = 0 then * if i is 0, i is replaced by 1 * begin * and return true to testset *
i := 1;
testset := true
end
else testset := false * if i is 1, *
end * return false to testset *

34. Test and Set Instruction -Mutual Exclusion Machine Instructions (4)
Program mutualexclusion;
const n=...;(*number of processes *)
var bolt: integer;
procedure P(i: integer);
begin
......
end;
begin (*main program *)
bolt := 0;
parbegin
P(1); P(2); P(n);
parend
end.

35. Test and Set Instruction -Mutual Exclusion Machine Instructions (5)
procedure P(i: integer);
begin
repeat
repeat {nothing} until testset(bolt); * if bolt = 0, *
<critical section>; * testset = true, P(i) goes to *
* critical section *
bolt:=0; * P(i) reset bolt:= *
<remainder> * Only one waiting processes *
forever *is granted access to its critical action*
end; *The choice of process depends on *
* which process happens to execute *
* the testset instruction next *

36. Mutual Exclusion Machine Instructions (6)
Disadvantages
Busy-waiting consumes processor time
Starvation is possible when a process leaves a critical section and more than one process is waiting. Who is next?
Deadlock
If a low priority process P1 has the critical region and a higher priority process P2 needs, P2 will be denied because of mutual exclusion. However P1 will never be dispatched because it is of lower priority.