Chapter 6: Process Synchronization

1
Chapter 6 Process Synchronization
2
Objectives

• Understand
• The Critical-Section Problem
• And its hardware and software solutions

3
Consumer-Producer Problem

• Classic example of process coordination
• Two processes sharing a buffer
• One places items into the buffer (producer)
• Must wait if the buffer if full
• The other takes items from the buffer (consumer)
• Must wait if buffer is empty
• Solution Keep a counter on number of items in
  the buffer

4
Producer

• while (true)
• / produce an item in nextProduced /
• while (count BUFFER_SIZE)
• // do nothing
• buffer in nextProduced
• in (in 1) BUFFER_SIZE
• count

5
Consumer

• while (true)
• while (count 0)
• // do nothing
• nextConsumed bufferout
• out (out 1) BUFFER_SIZE
• count--
• / consume the item in nextConsumed /

What can go wrong with this solution?
6
Race Condition

• count could be implemented a
• register1 count
• register1 register1 1
• count register1
• count-- could be implemented as
• register2 count
• register2 register2 - 1
• count register2
• Consider this execution interleaving with count
  5 initially
• S0 producer execute register1 count
  register1 5S1 producer execute register1
  register1 1 register1 6 S2 consumer
  execute register2 count register2 5 S3
  consumer execute register2 register2 - 1
  register2 4 S4 producer execute count
  register1 count 6 S5 consumer execute
  count register2 count 4

7
Race Condition

• Occurs when multiple processes manipulate shared
  data concurrently and the result depends on the
  particular order of manipulation
• Data inconsistency may arise
• Solution idea
• Mark code segment that manipulates shared data as
  critical section
• If a process is executing its critical section,
  no other processes can execute their critical
  sections
• More formally, any method that solves the
  Critical-Section Problem must satisfy three
  requirements

8
Critical-Section Problem

• Mutual Exclusion - If process Pi is executing in
  its critical section, then no other processes can
  be executing in their critical sections
• Progress - If no process is executing in its
  critical section and there exist some processes
  that wish to enter their critical section, then
  the selection of the processes that will enter
  the critical section next cannot be postponed
  indefinitely
• Bounded Waiting - A bound must exist on the
  number of times that other processes are allowed
  to enter their critical sections after a process
  has made a request to enter its critical section
  and before that request is granted
• Assumptions
• Each process executes at a nonzero speed
• No restriction on the relative speed of the N
  processes

9
Petersons Solution

• Software solution no hardware support
• Two process solution
• Assume that the LOAD and STORE instructions are
  atomic that is, cannot be interrupted (may not
  always be true in modern computers)
• The two processes share two variables
• int turn
• Boolean flag2
• turn indicates whose turn it is to enter the
  critical section
• The flag array indicates whether a process is
  ready to enter the critical section
• flagi true gt process Pi is ready

10
Algorithm for Process Pi

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

Does this algorithm satisfy the three
requirements?
11
Synchronization Hardware

• Uniprocessors could disable interrupts
• Currently running code would execute without
  preemption
• Generally too inefficient on multiprocessor
  systems
• Operating systems using this not broadly scalable
• Many systems provide hardware support for
  critical section code ? more efficient and easier
  for programmers
• Modern machines provide special atomic hardware
  instructions
• Atomic non-interruptable
• Either test memory word and set value
• Or swap contents of two memory words

12
TestAndndSet Instruction

• Definition
• boolean TestAndSet (boolean target)
• boolean rv target
• target TRUE
• return rv

13
Solution using TestAndSet

• Shared boolean variable lock, initialized to
  false
• while (true)
• while ( TestAndSet (lock )
  )
• / do
  nothing
• // critical section
• lock FALSE
• // remainder
  section

Does this algorithm satisfy the three
requirements?
NO. A process can wait indefinitely for another
faster process that is accessing its CS. Check
Fig 6.8 for a modified version.
14
Swap Instruction

• Definition
• void Swap (boolean a, boolean b)
• boolean temp a
• a b
• b temp

15
Solution using Swap

• Shared boolean variable lock initialized to
  FALSE
• Each process has a local boolean variable key
• while (true)
• key TRUE
• while ( key TRUE)
• Swap (lock, key )
• // critical
  section
• lock FALSE
• // remainder
  section

16
Semaphore

• Much easier to use than hardware-based solutions
• Semaphore S integer variable
• Two standard operations modify S
• wait()
• signal()
• These two operations are indivisible (atomic)

17
Semaphore Operations

• wait (S)
• while (S lt 0)
• // no-op, called busy waiting,
  spinlock
• S--
• signal (S)
• S
• Later, we will see how to implement these
  operations with no busy waiting

18
Semaphore Usage

• Counting semaphore can be any integer value
• Binary semaphore can be 0 or 1, (also known as
  mutex locks)
• Mutual exclusion
• Semaphore mutex // initialized to 1
• wait (mutex)
• Critical Section
• signal (mutex)
• Process synchronization S2 in P2 should be
  executed after S1 in P1
• P1
• S1
• signal (sem)
• P2
• wait (sem)
• S2
• Control access to a resource with finite number
  of instances
• Example producer-consumer problem with finite
  buffer

19
Semaphore Implementation with no Busy waiting

• With each semaphore there is an associated
  waiting queue. Each entry in a waiting queue has
  two data items
• value (of type integer)
• pointer to next record in the list
• Two operations
• block place the process invoking the operation
  on the appropriate waiting queue.
• wakeup remove one of the processes in the
  waiting queue and place it in the ready queue.

20
Semaphore Implementation with no Busy Waiting

• wait (S)
• value--
• if (value lt 0)
• add this process to waiting queue
• block()
• signal (S)
• value
• if (value lt 0) /if some
  processes are waiting/
• remove a process P from waiting
  queue
• wakeup(P)

21
Semaphore Implementation

• Must guarantee that no two processes can execute
  wait and signal on the same semaphore at the same
  time
• Thus, implementation becomes the critical section
  problem where the wait and signal code are placed
  in the critical section, and protected by
• Disabling interrupts (uniprocessor systems only)
• Busy waiting or spinlocks (multiprocessor
  systems)
• Can not disable interrupts on all processors (too
  costly and degrades performance)
• Well, why we do not do the above in applications
  anyway?
• Applications may spend long (and unknown) amount
  of time in critical sections, unlike the kernel
  which spends a short and known beforehand time in
  the critical section ( ten instructions)

22
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
• Let S and Q be two semaphores initialized to 1
• P0 P1
• wait (S)
  wait (Q)
• wait (Q)
  wait (S)
• . .
• . .
• . .
• signal (S)
  signal (Q)
• signal (Q)
  signal (S)
• Starvation indefinite blocking. A process may
  never be removed from the semaphore queue in
  which it is suspended.

23
Classical Problems of Synchronization

• Bounded-Buffer Problem
• Readers and Writers Problem
• Dining-Philosophers Problem
• These problems are usually used to test newly
  proposed synchronization schemes

24
Bounded-Buffer Problem

• 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

25
Bounded Buffer Problem (Cont.)

• The structure of the producer process
• while (true)
• // produce an item
• wait (empty)
• wait (mutex)
• // add the item to the
  buffer
• signal (mutex)
• signal (full)

26
Bounded Buffer Problem (Cont.)

• The structure of the consumer process
• while (true)
• wait (full)
• wait (mutex)
• // remove an item
  from buffer
• signal (mutex)
• signal (empty)
• // consume the
  removed item

27
Dining-Philosophers Problem

• Shared data
• Bowl of rice (data set)
• Semaphore chopstick 5 initialized to 1

28
Dining-Philosophers Problem (Cont.)

• The structure of Philosopher i
• While (true)
• wait ( chopsticki )
• wait ( chopStick (i 1) 5 )
• // eat
• signal ( chopsticki )
• signal (chopstick (i 1) 5 )
• // think

29
Be Careful When You Use Semaphores

• Some common problems
• signal (mutex) . wait (mutex)
• Multiple processes can access CS at the same
  time
• wait (mutex) wait (mutex)
• Processes may block for ever
• Omitting of wait (mutex) or signal (mutex) (or
  both)

30
Synchronization Examples

• Windows XP
• Linux
• Pthreads

31
Windows XP Synchronization

• Uses interrupt masks to protect access to global
  resources on uniprocessor systems (inside kernel)
• Uses spinlocks on multiprocessor systems
• Also provides dispatcher objects for thread
  synchronization outside kernel, which can act as
  mutexes, semaphores, or events (condition
  variables)

32
Linux Synchronization

• Linux
• disables interrupts to implement short critical
  sections (on single processor systems)
• Linux provides
• semaphores
• Spinlocks (on SMP)

33
Pthreads Synchronization

• Pthreads API is OS-independent
• It provides
• mutex locks
• condition variables
• extensions include
• semaphores
• read-write locks
• spin locks
• May not be portable

• include ltpthread.hgt
• pthread_mutex_t mutex
• pthread_mutex_init(mutex, null)
• pthread_mutex_lock(mutex)
• pthread_mutex_unlock(mutex)
• include ltsemaphore.hgt
• sem_t sem
• sem_init(sem, 0, 5)
• sem_wait(sem)
• sem_post(sem)

34
Summary

• Processor Synchronization
• Techniques to coordinate access to shared data
• Race condition
• Multiple processes manipulating shared data and
  result depends on execution order
• Critical section problem
• Three requirements mutual exclusion, progress,
  bounded waiting
• Software solution Petersons Algorithm
• Hardware support TestAndSet(), Swap()
• Busy waiting (or spinlocks)
• Semaphores
• Not busy waiting
• wait(), signal() must be atomic ? moves the CS
  problem to kernel
• Some classical synchronization problems
• Consumer-producer
• Dining philosopher
• Readers-writers
• Examples
• Win XP, Linux, Pthreads