1. Course Syllabus
1. Introduction - History; Views; Concepts; Structure
2. Process Management - Processes; State + Resources; Threads; Unix implementation of Processes
3. Process Scheduling – Paradigms; Unix; Modeling
4. Process Synchronization - Synchronization primitives and their equivalence; Deadlocks
5. Memory Management - Virtual memory; Page replacement algorithms; Segmentation
6. File Systems - Implementation; Directory and space management; Unix file system; Distributed file systems (NFS)
7. Security – General policies and mechanisms; protection models; authentication
8. Distributed issues – Synchronization; Mutual exclusion
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

2. Mutual exclusion: motivation
Race Conditions:
Example: Spooler directory with slots; index variables; two processes attempt concurrent access. In points to the next empty slot, Out points to entry holding name of file to print next.
Process A 4 5 6 7
. . .
. . .
abc.doc
f.ps
paper.ps
In=7
Out = 4
Process B
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

3. Code using reads/writes only
Add-file-to-print-spool (char *name)
Local-in := In
StoreName(Spool-dir[local-in], name)
In := (local-in+1) mod DIR-LEN
A scenario proving the above code wrong
Process A performs line 1
Process A is preempted by Process B
Process B performs Add-file-to-print-spool to completion
Process A is re-scheduled, completes lines 2-3.
Process B's file is never printed.
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

4. The mutual exclusion problem (Dijkstra, 1965)
How can we avoid such race conditions?
We need to devise a protocol that guarantees
mutually exclusive access by processes to a
shared resource (such as a file, printer, etc.) or,
more generally, a critical section of code
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

5. The problem model Multiple processes
Processes can apply read, write, or stronger operations to shared memory
Completely asynchronous
We assume processes do not fail-stop
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

6. Mutual exclusion: formal definition
loop forever
Remainder code
Entry code
Critical section (CS)
Exit code
end loop
Remainder code
Entry code CS
Exit code
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

7. Mutex Requirements
Mutual exclusion: No two processes are at the critical section (CS) at the same time
Deadlock-freedom: If processes are trying to enter their critical section, then some process eventually enters the critical section
Starvation-freedom: If a process is trying to enter its critical section, then this process must eventually enter its critical section
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

8. Mutual exclusion using critical regions
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

9. Brute force solution: disabling interrupts
Disable interrupts
Do your stuff
Enable interrupts
Problems
User processes are not allowed to disable interrupts
Disabling interrupts must be done for a very short period of time
Does not solve the problem in a multi-processor system
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

10. 2-process Mutual Exclusion with a lock variable
initially: lock=0
Program for both processes
await lock=0
lock:=1 CS
lock:=0 No
Does the algorithm satisfy mutex?
Does it satisfy deadlock-freedom?
Does it satisfy starvation-freedom?
Yes No
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

11. Mutual Exclusion: strict alternation
initially: turn=0
Program for process 0
await turn=0 CS
turn:=1
Program for process 1
await turn=1 CS
turn:=0
Yes
Does the algorithm satisfy mutex?
Does it satisfy deadlock-freedom?
Does it satisfy starvation-freedom? No No
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

12. Mutual Exclusion: flag array
bool flags[2] initially {false, false}
Program for process 0
flags[0]:=true
await flags[1]=false CS
flags[0]:=false
Program for process 1
flags[1]:=true
await flags[0]=false CS
flags[1]:=false
Yes
Does the algorithm satisfy mutex?
Does it satisfy deadlock-freedom?
Does it satisfy starvation-freedom? No No
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

13. Peterson’s 2-process algorithm (Peterson, 1981)
initially: b[0]:=false, b[1]:=false, value of turn immaterial
Program for process 0
b[0]:=true
turn:=0
await (b[1]=false or turn=1) CS
b[0]:=false
Program for process 1
b[1]:=true
turn:=1
await (b[0]=false or turn=0) CS
b[1]:=false
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

14. Schema for Peterson’s 2-process algorithm
Indicate participation b[i]:=true
Barrier turn:=i
no, maybe
Is there contention? b[1-i]=true?
yes
First to cross barrier? turn=1-i? no
yes
Critical Section
Exit code b[i]:=false
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels
Synchronization Algorithms and Concurrent Programming , Gadi Taubenfeld © 2006

15. Peterson’s 2-process algorithm satisfies both mutual-exclusion and starvation-freedom
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

16. Observations
Shared register: turn (2-valued) read & write by both processes
Two boolean registers: b[0], b[1]
process 0 can write b[0], process 1 can write b[1]
both can read b[0] & b[1]
Can the algorithm be modified to use only single-writer registers ?
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

17. Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels
Kessels’ 2-process algorithm (1982)
encode turn=0: as turn[0] = turn[1]
turn=1: as turn[0] ≠ turn[1]
initially: b[0]:=false, b[1]:=false, value of turn[i] immaterial
Program for process 0
b[0]:=true
local[0]:=turn[1]
turn[0]:=local[0]
await (b[1]=false or local[0] ≠ turn[1]) CS
b[0]:=false
Program for process 1
b[1]:=true
local[1]:=1 – turn[0]
turn[1]:=local[1]
await (b[0]=false or local[1] = turn[0]) CS
b[1]:=false
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

18. Mutual exclusion for n processes: A tournament tree
Level 2 1 2 3 4 5 6 7
Level 1
Level 0
Processes
A tree-node is identified by: [level, node#]
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels
Synchronization Algorithms and Concurrent Programming , Gadi Taubenfeld © 2006

19. N-process mutual exclusion: a tournament tree
Variables Per node: b[level, 2node], b[level, 2node+1], turn[level,node]
Per process (local): level, node, id.
Program for process i
node:=i
For level = 0 to log n-1 do
id:=node mod 2
node:= node/2
b[level,2node+id]:=true
turn[level,node]:=id
await (b[level,2node+1-id]=false or turn[level,node]=1-id) od CS
for level=log n –1 downto 0 do
node:=  i/2level
b[level,node]:=false
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

20. Fairness: First in First Out (FIFO)
Mutual Exclusion
Deadlock-freedom
Starvation-freedom
remainder
doorway
waiting
entry code
critical
section
exit code
FIFO: if process p is waiting and process q has not yet started the doorway, then q will not enter the CS before p
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels
Synchronization Algorithms and Concurrent Programming , Gadi Taubenfeld © 2006

21. Lamport’s Bakery Algorithm1 2 3 4 5 n
remainder 1 3 2 2 4
doorway
entry
waiting 1 3 2 4 2 1 2 2 CS
time 1 2 2
exit
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels
Synchronization Algorithms and Concurrent Programming , Gadi Taubenfeld © 2006

22. Implementation 1 code of process i , i  {1 ,..., n}
number[i] := 1 + max {number[j] | (1  j  n)}
for j := 1 to n (<> i) {
await (number[j] = 0)  (number[j] > number[i]) }
critical section
number[i] := 0 1 2 3 4 n
number
integer
Does this implementation work?
Answer: No, it can deadlock!
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels
Synchronization Algorithms and Concurrent Programming , Gadi Taubenfeld © 2006

23. Implementation 1: deadlock2 3 4 5 n
remainder 1 2 2
doorway
entry
waiting 1 2 2 1
deadlock CS
time 1
exit
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels
Synchronization Algorithms and Concurrent Programming , Gadi Taubenfeld © 2006

24. Implementation 2 code of process i , i  {1 ,..., n}
number[i] := 1 + max {number[j] | (1  j  n)}
for j := 1 to n (<> i) {
await (number[j] = 0)  (number[j],j) < number[i],i)
// lexicographical order }
critical section
number[i] := 0 1 2 3 4 n
number
integer
Does this implementation work?
Answer: It does not satisfy mutual exclusion!
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels
Synchronization Algorithms and Concurrent Programming , Gadi Taubenfeld © 2006

25. Implementation 2: no mutual exclusion1 2 3 4 5 n
remainder 1 2 2
doorway
entry
waiting 1 2 2 1 2 2 CS
time 1
exit
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels
Synchronization Algorithms and Concurrent Programming , Gadi Taubenfeld © 2006

26. The Bakery Algorithm code of process i, i  {1 ,..., n}
1: choosing[i] := true
2: number[i] := 1 + max {number[j] | (1  j  n)}
3: choosing[i] := false
4: for j := 1 to n do
5: await choosing[j] = false
6: await (number[j] = 0)  (number[j],j)  (number[i],i)
7: od
8: critical section
9: number[i] := 0
Doorway
Waiting
Bakery 1 2 3 4 n
choosing
false
false
false
false
false
false
bits
number
integer
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

27. Lamport’s bakery algorithm satisfies mutual-exclusion, starvation-freedom, and FIFO
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

28. The test-and-set instruction
initially: v:=0
Test-and-set(w)
do atomically
prev:=w
w:=1
return prev
Program for process i
await test&set(v) = 0
Critical Section
v:=0
Mutual exclusion?
Yes
Deadlock-freedom?
Yes
Starvation-freedom? No
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels

29. Starvation-free mutex using test-and-set
boolean lock initially 0, interested[n] initially false
program for process i
interested[i]:=true
await ( (test-and-set(lock) = 0) || (interested[i]=false) ) CS
interested[i]:=false
j:=(i+1) % n
while (j != i && !interested[j]) j:=++j % n
if (j=i)
lock:=0
else
interested[j]:=false
Operating Systems, 2013, Meni Adler, Michael Elhadad & Amnon Meisels