Chapter 2.3 : Interprocess Communication

1
Chapter 2.3 Interprocess Communication

• Process concept ?
• Process scheduling ?
• Interprocess communication
• Deadlocks
• Threads

2
Producer - Consumer Problem
Producer Process
Consumer Process
BUFFER

• Buffer is shared (ie., it is a shared variable)

3
Progress in time..
Producer
3 instead of 2!
c1

• Both processes are started at the same time and
  consumer uses some old value initially

4
A Race Condition

• Because of the timing and which process starts
  first
• There is a chance that different executions may
  end up with different results

5
Critical Sections

• Critical Section
• A section of code in which the process accesses
  and modifies shared variables
• Mutual Exclusion
• A method of preventing for ensuring that one (or
  a specified number) of processes are in a
  critical section

6
Why Processes Need to Communicate?

• To synchronize their executions
• To exchange data and information

7
Rules to Form Critical Sections

• 1. No two processes may be simultaneously
  inside their CS (mutual exclusion)
• 2. No assumptions are made about relative process
  speeds or number of CPUs
• 3. A process outside a CS should not block other
  processes
• 4. No process should wait forever before
  entering its CS

8
Mutual Exclusion Problem Starvation

• Also known as Indefinite Postponement
• Definition
• Indefinitely delaying the scheduling of a process
  in favour of other processes
• Cause
• Usually a bias in a systems scheduling policies
  (a bad scheduling algorithm)
• Solution
• Implement some form of aging

9
Another Problem Deadlocks

• Two (or more) processes are blocked waiting for
  an event that will never occur
• Generally, A waits for B to do something and B is
  waiting for A
• Both are not doing anything so both events never
  occur

10
How to Implement Mutual Exclusion

• Three possibilities
• Application programmer builds some method
  into the program
• Hardware special h/w instructions provided to
  implement ME
• OS provides some services that can be used
  by the programmer
• All schemes rely on some code for
• enter_critical_section, and
• exit_critical_section
• These "functions" enclose the critical section

11
Application Mutual Exclusion

• Application Mutual Exclusion is
• implemented by the programmer
• hard to get correct, and
• very inefficient
• All rely on some form of busy waiting (process
  tests a condition, say a flag, and loops while
  the condition remains the same)

12
Example

• Producer
• produce
• If lock 1 loop until lock 0
• lock1
• put in buffer
• lock0
• Consumer
• If lock 1 loop until lock 0
• lock1
• get from buffer
• lock0
• consume

13
Hardware ME Test and Set Instruction

• Perform an indivisible xr and r1
  
• x is a local variable
• r is a global register set to 0 initially
• repeat (testset(x)) until x 0
• lt critical section gt
• r 0

14
Hardware ME Exchange Instruction

• Exchange swap the values of x and r
• x is a local variable
• r is a global register set to 1 initially
• x 0
• repeat exchange(r, x) until x 1
• lt critical section gt
• exchange(r, x)
• Note r 0 and x 1 when the process is in CS

15
Hardware ME Characteristics

• Advantages
• can be used by a single or multiple processes
  (with shared memory)
• simple and therefore easy to verify
• can support multiple critical sections
• Disadvantages
• busy waiting is used
• starvation is possible
• deadlock is possible (especially with priorities)

16
Another Hardware ME Disabling Interrupts

• On a single CPU only one process is executed
• Concurrency is achieved by interleaving execution
  (usually done using interrupts)
• If you disable interrupts then you can be sure
  only one process will ever execute
• One process can lock a system or degrade
  performance greatly

17
Mutual Exclusion Through OS

• Semaphores
• Message passing

18
Semaphores

• Major advance incorporated into many modern
  operating systems (Unix, OS/2)
• A semaphore is
• a non-negative integer
• that has two indivisible, valid operations

19
Semaphore Operations

• Wait(s)
• If s gt 0 then s s - 1
• else block this process
• Signal(s)
• If there is a blocked process on this semaphore
  then wake it up
• else s s 1

20
More on Semaphores

• The other valid operation is initialisation
• Two types of semaphores
• binary semaphores can only be 0 or 1
• counting semaphores can be any non-negative
  integer
• Semaphores are an OS service implemented using
  one of the methods shown already
• usually by disabling interrupts for a very short
  time

21
Producer - Consumer Problem Solution by
Semaphores
Produce Wait(mutex) Put in buffer Signal(mutex)
Wait(mutex) Get from buffer Signal(mutex) Consume
CS

• Initially semaphore mutex is 1

22
Another Example

• Three processes all share a resource on which
• one draws an A
• one draws a B
• one draws a C
• Implement a form of synchronization so that the
  output appears ABC

23

• Semaphore b 0, c 0

24
Message Passing

• Provides synchronization and information exchange
• Message Operations
• send(destination, message)
• receive (source, message)

25
Producer - Consumer Problem Using Messages

• define N 100 /number of message slots/
• producer( )
• int item message m
• while (TRUE)
• produce_item(item)
• receive(consumer,m)
• build_message(m, item)
• send(consumer,m)

26

• Consumer( )
• int item message m
• for (i0 iltN i) send(producer,m)
• while (TRUE)
• receive(producer,m)
• extract_item(m,item)
• send(producer,m)
• consume_item(item)