Concurrency

1
Concurrency
2
Bakery algorithm of Lamport

• Critical section algorithm for any ngt1
• Each time a process is requesting an entry to CS,
  assign it a ticket which is
• Unique and monotonically increasing
• Let the process into CS in the order of their
  numbers

3
Choosing a ticket
4
Bakery algorithm for n processes
5
Correctness
Lemma
Mutual exclusion is immediate from this lemma It
is easy to show that Progress and Fairness
hold as well (recitation)
6
Hardware primitives

• Elementary building blocks capable of performing
  certain steps atomically
• Should be universal to allow for solving
  versatile synchronization problems
• Numerous such primitives were identified
• Test-and-set
• Fetch-and-add
• Compare-and-swap

7
Test-and-Set (TS)

• boolean test-and-set(boolean lock)
• templock
• lockTRUE
• return temp
• reset(boolean lock)
• lockFALSE

8
Critical section using TS
Shared boolean lock, initially FALSE do
while(test-and-set(lock)) critical
section reset(lock) reminder section
while(1)

• Check yourself!
• Is mutual exclusion satisfied?
• Is progress satisfied?
• Is fairness satisfied?

9
Discussion

• Satisfies Mutual Exclusion and Progress
• Does not satisfies Fairness
• Provides exclusion among unbounded number of
  processes
• Process IDs and number are unknown
• Busy waiting
• Burning CPU cycles while being blocked

10
Fetch-and-Add (FAA)
s shared, a local int FAA(int s, int
a) temps ssa return temp
FAA can be used as a ticket machine
11
Critical section using FAA
Shared int s, turn Initially s 0
turn0 Process Pi code Entry me
FAA(s,1) while(turn lt me) // busy wait for my
turn Critical section Exit FAA(turn,1)

• Check yourself!
• Is mutual exclusion satisfied?
• Is progress satisfied?
• Is fairness satisfied?

12
Discussion

• Satisfies all three properties
• Supports unbounded number of processes
• Unbounded counter
• Busy waiting

13
Problems with studied synchronization methods

• Critical section framework is inconvenient for
  programming
• Performance penalty
• Busy waiting
• Too coarse synchronization
• Using hardware primitives directly results in
  non-portable code

14
Higher Level Abstractions

• Higher level software abstractions are
  represented by
• Semaphores
• Monitors

15
Semaphores

• Invented by Edsger Dijkstra in 1968
• Interface consists of two primitives
• P() and V()

16
Notes on the Language

• Dutch P Proberen, V Verhogen
• Hebrew P ????, V ????
• English P() wait(), V() signal()

17
Semaphores initial value

• Initial value of a semaphore indicates how many
  identical instances of the critical resource
  exist
• A semaphore initialized to 1 is called a mutex
  (mutual exclusion)

18
Programming with semaphores

• Semaphores is a powerful programming abstraction
• Define a semaphore for each critical resource
• E.g., one for each linked list
• Granularity?
• Concurrent processes access appropriate
  semaphores when synchronization is needed

19
Some examples
P(synch)
V(synch)
20
Some examples
Do P(mutex) critical section V(mutex) Rema
inder section While(1)
21
Implementing semaphores

• Semaphores can be implemented efficiently by the
  system
• P() is explicitly telling the system Hey, I
  cannot proceed, you can preempt me
• V() instructs the system to wake up a waiting
  process

22
Implementing Semaphores
type semaphore record count
integer queue list of
process end var S semaphore
S.count must be initialized to a nonnegative
value (depending on application)
23
Implementing Semaphores
P(S) S.count-- if (S.countlt0) add
this process to S.queue block this process

V(S) S.count if (S.count lt 0)
remove a process P from S.queue place this
process P on ready queue
24
Were still cheating

• P() and V() must be executed atomically
• In uniprocessor system may disable interrupts
• In multi-processor system, use hardware
  synchronization primitives
• TS, FAA, etc
• Involves a some limited amount of busy waiting

25
Monitors

• Only a single process at a time can be active
  within the monitor
• gt other processes calling Pi() are queued
• Conditional variables for finer grained
  synchronization
• x.wait() suspend the execution until another
  process calls x.signal()

monitor monitor-name shared variable
declarations procedure P1()
procedure Pn()