Presentation is loading. Please wait.

Presentation is loading. Please wait.

Concurrency: Mutual Exclusion and Synchronization - Chapter 5 (Part 2) tally Bounds for N Processes Dekker’s Algorithm (HW Q2) Mutual Exclusion Dead Lock.

Similar presentations


Presentation on theme: "Concurrency: Mutual Exclusion and Synchronization - Chapter 5 (Part 2) tally Bounds for N Processes Dekker’s Algorithm (HW Q2) Mutual Exclusion Dead Lock."— Presentation transcript:

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 Dead Lock Starvation Mutual Exclusion - Interrupt Disabling Mutual Exclusion Machine Instructions (HW Q3)

2 tally Bounds for N Processes (1) zConsider the following program (next slide) zAssume 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. zSuppose 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) zUpper bound on the final value of the shared variable tally output by this concurrent program should be n*50. zLower 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+1 do tally:=tally+1 n=1, P1 did tally+1 P1 losing processor did not store this value tally:=0 P2 did for loop to n=49 tally:=49 P2 losing processor P1 regains control processor replacing tally (49) with 1 tally:=1 *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 zMutual Exclusion ? - Mutual exclusion is enforced in the Dekker’s Algorithm. zDead Lock? - No dead lock is happened in the Dekker’s Algorithm. zStarvation? - 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 turnflag[0]:=false; to check P1’s igloo while turn:=1 do{nothing}; avoid mutual courtesyflag[0]:=true end; *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 * forever end;

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 turnflag[1]:=false; to check P0’s igloo while turn:=0 do{nothing}; avoid mutual courtesyflag[1]:=true end; *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 * forever end;

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 turnflag[0]:=false; to check P1 & P2’s igloo while turn:=1 or 2 do{nothing}; avoid mutual courtesyflag[0]:=true end; *flag[2]=false and *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 * forever end; No Starvation in Dekker’s Algorithm (2) – P0 Algorithm

14 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 turnflag[1]:=false; to check P0 &P2’s igloo while turn:=2 or 0 do{nothing}; avoid mutual courtesyflag[1]:=true end; *flag[2]=false and *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 * forever end; No Starvation in Dekker’s Algorithm (3) – P1 Algorithm

15 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 turnflag[2]:=false; to check P0 & P1’s igloo while turn:=0 or 1 do{nothing}; avoid mutual courtesyflag[2]:=true end; *flag[1]=false and *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 * 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 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 begin begin *avoiding dead lock* *avoiding dead lock* end; end; turn:=1; turn:=2; /*P2 ->turn:=0*/ flag[0]:=false; flag[1]:=false; forever end; No Starvation in Dekker’s Algorithm (5) – P0 and P1 Algorithms

17 Peterson’s Algorithm (0) z 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. zN 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.

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 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}; * flag[1]=false, or turn = 0 * * P0 goes critical part * flag[0]:=false; *P1 can go critical section * forever end; Peterson’s Algorithm - P0 (2)

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

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

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

23 Peterson’s Algorithm - three exhaustive cases (6) zP1 has no interest in its critical section This case is impossible, because it implies flag[1] = false zP1 is waiting for its critical section This case is also impossible, because if turn=1, P1 is able to enter its critical section zP1 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-1 * j is the “stage” of the algorithm * do { * at which process i executes * 2q[i] = j; *q[i] indicates the stage of each process * 3turn[j] = i; *turn[i] resolves simultaneity conflicts * 4L: 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) zIt has been proved that N processes Peterson’s algorithm provides mutual exclusion, deadlock freedom, and no starvation. zHorfi, M. “proof of a Mutual Exclusion Algorithm.” Operating Systems Review, January 1990.

27 Question 1 -Exercise/Home Work (1) zConsider the following program (This and next slides). zThis 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 begin while blocked[1-id] do; turn :=id end; blocked[id] :=false; until false end;

29 Mutual Exclusion - Interrupt Disabling (1) In an uniprocessor machine: repeat ; forever

30 Mutual Exclusion - Interrupt Disabling (2) zDisabling 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 zDisabling interrupts on more than two processors will not guarantee mutual exclusion

31 Mutual Exclusion Machine Instructions (1) zAt a hardware level, access to a memory location exclude any other access to that same location. zOne machine instruction is used to update a memory location so other instructions cannot interfere. zFor 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) zMutual exclusion machine instructions can be used for single and multiple processors zMutual 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, * ; * testset = true, P(i) goes to * * critical section * bolt:=0; * P(i) reset bolt:=0 * * 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) zDisadvantages yBusy-waiting consumes processor time yStarvation is possible when a process leaves a critical section and more than one process is waiting. Who is next? yDeadlock 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.


Download ppt "Concurrency: Mutual Exclusion and Synchronization - Chapter 5 (Part 2) tally Bounds for N Processes Dekker’s Algorithm (HW Q2) Mutual Exclusion Dead Lock."

Similar presentations


Ads by Google