Concurrency

1
Concurrency

• Operating Systems
• Spring 2004

2
Concurrency pros and cons

• Concurrency is good for users
• One of the reasons for multiprogramming
• Working on the same problem, simultaneous
  execution of programs, background execution
• Concurrency is a pain in the neck for the
  system
• Access to shared data structures
• Deadlock due to resource contention

3
Mutual Exclusion

• OS is an instance of concurrent programming
• Multiple activities may take place in the same
  time
• Concurrent execution of operations involving
  multiple steps is problematic
• Example updating linked list
• Concurrent access to a shared data structure must
  be mutually exclusive

4
new-gtnextcurrent.next
insert_after(current,new)
current.nextnew
new
current
new
current
5
remove_next(current)
tmpcurrent.next current.nextcurrent.next.next
free(tmp)
current
current
6
new
current
new
current
new
current
7
Atomic operations

• A generic solution is to ensure atomic execution
  of operations
• All the steps are perceived as executed in a
  single point of time
• insert_after(current,new) remove_next(current),
  or
• remove_next(current) insert_after(current,new)

8
The Critical Section Model

• A code within a critical section must be executed
  exclusively by a single process

do
critical section
remainder section
while(1)
9
Linked list example
do
do
tmpcurrent.next current.nextcurrent.next.next
free(tmp)
new-gtnextcurrent.next
current.nextnew
remainder section
remainder section
while(1)
while(1)
10
The Critical Section Problem

• n processes P0,,Pn-1
• No assumptions on relative process speeds, no
  synchronized clocks, etc
• Models inherent non-determinism of process
  scheduling
• No assumptions on process activity when executing
  within
• Critical and reminder sections

11
Shared variables

• Processes are communicating through shared
  atomic read/write variables
• x is a shared variable, l is a local variable
• Read takes the current value
• Write assigns a provided value

12
Requirements

• Mutual Exclusion If process Pi is executing its
  C.S., then no other process is in its C.S.
• Progress If Pi is in its entry section and no
  process is in C.S., then some process eventually
  enters C.S.
• Fairness If no process remains in C.S. forever,
  then each process requesting entry to C.S. will
  be eventually let into C.S.

13
Solving the CS problem (n2)
14
Solving the CS problem (n2)
15
Solving the CS problem (n2)
16
Petersons algorithm for n2
17
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

18
Choosing a ticket
19
Bakery algorithm for n processes
20
Correctness
Lemma
Mutual exclusion is immediate from this lemma It
is easy to show that Progress and Fairness
hold as well (recitation)
21
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

22
Test-and-Set (TS)

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

23
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?

24
Discussion

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

25
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
26
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?

27
Discussion

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

28
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

29
Higher Level Abstractions

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

30
Semaphores

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

31
Notes on the Language

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

32
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)

33
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

34
Some examples
P(synch)
V(synch)
35
Some examples
Do P(mutex) critical section V(mutex) Rema
inder section While(1)
36
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

37
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)
38
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
39
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

40
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 grain
  synchronization
• x.wait() suspend the execution until another
  process calls x.signal()

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