6.3 Peterson

1
6.3 Petersons Solution

• The two processes share two variables
• Int turn
• Boolean flag2
• The variable turn indicates whose turn it is to
  enter the critical section.
• The flag array is used to indicate if a process
  is ready to enter the critical section. flagi
  true implies that process Pi is ready!

2
Algorithm for Process Pi

• while (true)
• flagi TRUE
• turn j
• while ( flagj turn j)
• CRITICAL SECTION
• flagi FALSE
• REMAINDER SECTION

3
Algorithm for Process Pi

• do
• acquire lock
• critical section
• release lock
• remainder section

4
6.5 Semaphore

• Its a hardware based solution
• Semaphore S integer variable
• Two standard operations modify S wait() and
  signal()

5
6.5 Semaphore

• Can only be accessed via two indivisible (atomic)
  operations
• wait (S)
• while S lt 0
• // no-op
• S--
• signal (S)
• S

6
6.5 Semaphore

• Binary semaphore integer value can range only
  between 0 and 1 can be simpler to implement
• Counting semaphore integer value can range over
  an unrestricted domain

7
6.5 Semaphore

• Provides mutual exclusion
• Semaphore S // initialized to 1
• do
• wait (S)
• //Critical Section
• signal (S)
• //Remainder Section
• while (true)

8
6.5 Semaphore

• Must guarantee that no two processes can execute
  wait ()and signal ()on the same semaphore at the
  same time
• Atomic non-interruptable

9
6.5 Semaphore

• The main disadvantage of the semaphore is that it
  requires busy waiting, which wastes CPU cycle
  that some other process might be able to use
  productively
• This type of semaphore is also called a spinlock
  because the process spins while waiting for the
  lock

10
6.5 Semaphore

• To overcome the busy waiting problem, we create
  two more operations
• blockplace the process invoking the operation on
  the appropriate waiting queue.
• wakeup remove one of processes in the waiting
  queue and place it in the ready queue.

11
Diagram of Process State
12
Semaphore Implementation with no Busy waiting
13
Deadlock and Starvation

• Deadlock two or more processes are waiting
  indefinitely for an event that can be caused by
  only one of the waiting processes
• Starvationindefinite blocking. A process may
  never be removed from the semaphore queue in
  which it is suspended.

14
Deadlock example
15
6.6 Classical Problems of Synchronization

• Bounded-Buffer Problem
• Readers and Writers Problem
• Dining-Philosophers Problem

16
6.6 Classical Problems of Synchronization

• N buffers, each can hold one item
• Semaphore mutex initialized to the value 1
• Semaphore full initialized to the value 0
• Semaphore empty initialized to the value N.

17
Bounded Buffer Problem
18
Bounded Buffer Problem
19
Readers-Writers Problem

• A data set is shared among a number of concurrent
  processes
• Readers only read the data set they do not
  perform any updates
• Writers can both read and write.
• First readers-writers problem requires that no
  reader will be kept waiting unless a writer has
  already obtained permission to use the shared
  object

20
Readers-Writers Problem

• Shared Data
• Data set
• Semaphore mutexinitialized to 1.
• Semaphore wrtinitialized to 1.
• Integer readcountinitialized to 0.

21
Readers Readers-Writers Problem
22
Readers Readers-Writers Problem
23
Dining-Philosophers Problem
24
Dining-Philosophers Problem