3

1
3

• Chapter 5

2
Theme of OS Design?
Management of processes and threads
Multiprogramming Multiprocessing Distributed pro
cessing
3
Currency

• Communication among processes
• Sharing resources
• Synchronization of multiple processes
• Allocation of processor time

4
Concurrency in different contexts

• Multiple applications
• Multiprogramming time sharing
• Structured application
• Application can be a set of concurrent processes
• Operating-system structure
• Operating system is a set of processes or threads

Unit of concurrency process / thread
5
Chapter 5

• What is mutual exclusion?
• How to implement mutual exclusion
• Busy waiting? Software/Hardware
• Semaphore, monitor, massage passing

6
Difficulties with Concurrency

• Sharing global resources, global variables
• Management of allocation of resources
• Optimally?, deadlock?
• Programming errors difficult to locate

Relative speed of execution can not be predicted
Other process, interrupt handling, scheduling
7
A Simple Example

• void echo()
• chin getchar()
• chout chin
• putchar(chout)
• //uniprocessor

Block from entering
8
A Simple Example

• Process P1 Process P2
• . .
• in getchar() .
• . in getchar()
• chout chin chout chin
• putchar(chout) .
• . putchar(chout)
• . .
• //in processor A processor B

Control access to the shared resource.
9
Operating System Concernsissues

• Keep track of active processes
• Allocate and deallocate resources
• Processor time
• Memory
• Files
• I/O devices
• Protect data and resources chapter 15
• Result of process must be independent of the
  speed of execution of other concurrent processes
  this chapter

PCB
10
Process Interaction

• Processes unaware of each other multiprograming
  of multiplr independent process competition for
  disk, file or printer
  
• Processes indirectly aware of each other not by
  the PID, but by sharing some object such as I/O
  buffer
  
• Process directly aware of each other by PID and
  can communicate each other - cooperation

11
(No Transcript)
12
Competition Among Processes for Resources

• Mutual Exclusion (non shareable resource)
• Critical sections portion of program
• Only one program at a time is allowed in its
  critical section
  
• Example only one process at a time is allowed to
  send command to the printer
  
• Deadlock
• Starvation

13
Mutual exclusion mechanism in abstract terms
Const int n // number of processes
void P(int i) while (true) entercrit
ical(i) //critical section exitcr
itical(i)
Void main() parbegin(P(R1), P(R2), ,P(Rn))


14
Cooperation Among Processes by Sharing

• Aware each other with shared data
• Writing must be mutually exclusive-
• data coherence is required
• Critical sections are used to provide data
  integrity

15
In a bookkeeping application a b
P1 a a 1 b b 1
P2 b 2 b a a 2
Start w/ a b 1
A 4 , b 3 - cs is important!
16
Cooperation Among Processes by Communication

• Communication
• A way of synchronization or coordination
• Messages are passes no sharing
• Mutual exclusion is not a control requirement
• Possible to have deadlock
• Each process waiting for a message from the other
  process
  
• Possible to have starvation
• Two processes sending message to each other while
  another process waits for a message

17
Requirements for Mutual Exclusion

• Only one process at a time is allowed in the
  critical section for a resource
  
• A process that halts in its non-critical section
  must do so without interfering with other
  processes
  
• No deadlock or starvation

18
Requirements for Mutual Exclusion

• A process must not be delayed access to a
  critical section when there is no other process
  using it
  
• No assumptions are made about relative process
  speeds or number of processes
  
• A process remains inside its critical section for
  a finite time only

19
Ways

• Each process takes responsibility
• Software approach
• High processing overhead, error prone
• Special purpose machine instn
• Hardware approach
• Special purpose
• O/S or PL supports

20
First Attempt

• Global memory - turn
• Busy Waiting
• Process is always checking to see if it can enter
  the critical section
  
• Process can do nothing productive until it gets
  permission to enter its critical section

21
//process 0 While (turn ! 0) //do nothing

//critical section turn 1
//process 1 While (turn ! 1) //do nothing

//critical section turn 0
Drawback
Speed is dictated by slower process
One fails inside or outside cs
22
Coroutine

• Designed to be able to pass execution control
  back and forth between themselves
  
• Inadequate to support concurrent processing

23
Second Attempt

• Each process can examine the others status but
  cannot alter it
  
• When a process wants to enter the critical
  section is checks the other processes first
  
• If no other process is in the critical section,
  it sets its status for the critical section
  
• Each process can check the flags and then proceed
  to enter the critical section at the same time
  

24
Boolean flag2 false, false
//process 0 While (flag1) //do nothing
flag0 true //critical section Flag0
false
//process 1 While (flag0) //do nothing
flag1 true //critical section Flag1
false
25
drawbacks

• If processes fails inside its cs
• It does not guarantee mutual exclusion
• P0 finds flag1 set to false.
• P1 finds flag0 set to false.
• P0 set flag0 and enter cs
• P1 set flag1 and enter cs

26
Third attempt
//process 0 Flag0 true While (flag1)
//do nothing //critical section Flag0 fal
se
//process 1 Flag1 true While (flag0)
//do nothing //critical section Flag1 fal
se
27
Third Attempt

• Set flag to enter critical section before check
  other processes
  
• If another process is in the critical section
  when the flag is set, the process is blocked
  until the other process releases the critical
  section
• Deadlock is possible when two process set their
  flags to enter the critical section. Now each
  process must wait for the other process to
  release the critical section

28
Fourth Attempt

• A process sets its flag to indicate its desire to
  enter its critical section but is prepared to
  reset the flag
  
• Other processes are checked. If they are in the
  critical region, the flag is reset and later set
  to indicate desire to enter the critical region.
  This is repeated until the process can enter the
  critical region.

29
4th attempt
//process 1 Flag1 true While (flag0)
flag0 false Delay Flag0 true

//critical section Flag1 false
//process 0 Flag0 true While (flag1)
flag0 false Delay Flag0 true

//critical section Flag0 false
30
Fourth Attempt

• It is possible for each process to set their
  flag, check other processes, and reset their
  flags. This scenario will not last very long so
  it is not deadlock. It is undesirable

31
livelock

• P0 sets flag0 to true
• P1 sets flag1 to true
• P0 checks flag1
• P1 checks flag0
• P0 sets flag0 to false
• P1 sets flag1 to false
• P0 sets flag0 to true
• P1 sets flag1 to true

32
Correct Solution

• Each process gets a turn at the critical section
• If a process wants the critical section, it sets
  its flag and may have to wait for its turn
  
• Set flag and check others flag, if set consults
  turn - eventually get its turn
  

33
Fig 5.3 Dekkers algorithm
Void P1() while (true) flag1
true while(flag0) if (tu
rn 1) flag1 false
while (turn 0)
//do nothing
flag1 true
//cs turn 0 flag1
false
Boolean flag 2 Int turn Void P0() while (
true) flag0 true while(flag
1) if (turn 1)
flag0 false while (turn
1) //do nothing
flag0 true
//cs turn 1 flag0
false
Void main() Flag0 false Flag1 false
Turn 1
Parbegin(P0,P1)
34
Fig 5.3 Petersons algorithm
Void P1() while (true) flag1
true turn 0 while(flag1 tu
rn 1) //do nothing //cs
flag1 false
Boolean flag 2 Int turn Void P0() while (
true) flag0 true turn 1
while(flag1 turn 1)
//do nothing //cs fla
g0 false
Void main() Flag0 false Flag1 false
Parbegin(P0,P1)

35
Mutual ExclusionHardware Support

• Interrupt Disabling
• A process runs until it invokes an
  operating-system service or until it is
  interrupted
  
• Disabling interrupts guarantees mutual exclusion
• Processor is limited in its ability to interleave
  programs
  
• Multiprocessing
• disabling interrupts on one processor will not
  guarantee mutual exclusion
  

36
Mutual ExclusionHardware Support

• Special Machine Instructions
• Performed in a single instruction cycle
• Not subject to interference from other
  instructions
  
• Reading and writing
• Reading and testing

37
Mutual ExclusionHardware Support

• Test and Set Instruction
• boolean testset (int i)
• if (i 0)
• i 1
• return true
• else
• return false

38
Mutual ExclusionHardware Support

• Exchange Instruction
• void exchange(int register, int memory)
• int temp
• temp memory
• memory register
• register temp

39
Const int n //number of processes
int bolt void P(int i) while (true)
while(!testset(bolt))
//do nothing
//critical section
bolt 0
void main() bolt 0 parbegin(P(1),P(2), ,P
(n))

40
Const int n //number of processes
int bolt void P(int i) int keyi wh
ile (true) keyi 1
while(keyi ! 0)
exchange(keyi,bolt) /
/critical section exc
hange(keyi,bolt) bolt 0

void main() bolt 0 parbegin(P(1),P(2), ,P
(n))

41
Mutual Exclusion Machine Instructions

• Advantages
• Applicable to any number of processes on either a
  single processor or multiple processors sharing
  main memory
  
• It is simple and therefore easy to verify
• It can be used to support multiple critical
  sections

42
Mutual Exclusion Machine Instructions

• Disadvantages
• Busy-waiting consumes processor time
• Starvation is possible when a process leaves a
  critical section and more than one process is
  waiting.
  
• Deadlock
• If a low priority process has the critical region
  and a higher priority process needs, the higher
  priority process will obtain the processor to
  wait for the critical region

43
O.S / PL

• Semaphore
• Monitors
• Message passing

44
Semaphores

• Special variable called a semaphore is used for
  signaling
  
• If a process is waiting for a signal, it is
  suspended until that signal is sent
  
• Wait and signal operations cannot be interrupted
• Queue is used to hold processes waiting on the
  semaphore
  

45
Semaphores

• Semaphore is a variable that has an integer
  value
  
• May be initialized to a nonnegative number
• Wait operation decrements the semaphore value
• Signal operation increments semaphore value
• signal(s) P, wait(s) V

46
Const int n //number of processes
Semaphore s 1 Void P(int I) while(true)
wait(s) //cs signal
(s)
Void main() Parbegin(P(1),P(2), P(n))
47
A
B
C
1
Wait(s)
0
Wait(s)
B
Wait(s)
B
C
signal(s)
48
Producer/Consumer Problem

• One or more producers are generating data and
  placing these in a buffer
  
• A single consumer is taking items out of the
  buffer one at time
  
• Only one producer or consumer may access the
  buffer at any one time
  
• Power pitfalls of semaphore!

49
Producer

• producer
• while (true)
• / produce item v /
• bin v
• in

50
Consumer

• consumer
• while (true)
• while (in
• /do nothing /
• w bout
• out
• / consume item w /

51
Void consumer() waitB(delay) while(
true) waitB(s) take()
N-- signalB(s) consume() if
(n 0) waitB(delay)
Void producer() while(true) Pr
oduce() waitB(s) Append()
N If(n1) signalB(delay) signalB
(s)
52
(No Transcript)
53
Void consumer() waitB(delay) while(tru
e) waitB(s) take() N-
- signalB(s) consume() if(n
0) waitB(delay)
Int m
Void producer() while(true) Pr
oduce() waitB(s) Append()
N If(n1) signalB(delay) signalB
(s)
M n
54
Infinite Buffer
55
(No Transcript)
56
Producer with Circular Buffer

• producer
• while (true)
• / produce item v /
• while ((in 1) n out) / do nothing /
• bin v
• in (in 1) n

57
Consumer with Circular Buffer

• consumer
• while (true)
• while (in out)
• / do nothing /
• w bout
• out (out 1) n
• / consume item w /

58
Barbershop Problem
59
Barbershop

• Shop and sofa capacity
• Barber chair capacity
• Customers are in barber chair
• Holding customers in barber chair
• Limiting one customer/barber chair
• Paying and receiving
• Coordinating barber and cashier function

60
(No Transcript)
61
Void cashier() while (true)
wait(payment) wait(coord)
accept_pay() signal (coord)
signal(receipt)
Semaphore max_capacity 20 Semaphore sofa 4
Semaphore barber_chair 3 Semaphore coord
3 Semaphore cust_ready 0 Semaphore finished
0 Semaphore leave_b_chair 0 Semaphore paym
ent 0 Semaphore receipt 0
62
Void customer () wait(max_capacity) en
ter_shop() wait(sofa) sit_on_sofa()
wait(barber_chair) get_up_from_sofa() s
ignal_sofa() sit_in_barber_chair() signa
l(cust_ready) wait(finished) leave_barbe
r_chaor() signal(leave_b_chair) pay()
signal(payment) wait(recipt) exit_shop(
) signal(max_capacity)
Void barber() While(true)
wait(cust_ready) wait(coord)
cut_hair() signal(coor
d) signal(finished) wa
it(leave_b_chair) signal(barber_chair
)
63
Void main() parbegin(customer, 50times, ba
rber, barber, barber, cashier)

64
Monitors

• Monitor is a software module
• Chief characteristics
• Local data variables are accessible only by the
  monitor
  
• Process enters monitor by invoking one of its
  procedures
  
• Only one process may be executing in the monitor
  at a time

65
(No Transcript)
66
Monitor boundedbuffer Char bufferN Int nexti
n, nextout Int count Int notfull, notempty
void append(char x) if
(count) N) cwait(notfull) buffernex
tin x nextin (nextin)N count
csignal(notempty)
Nextin nextout count 0
void take(char x) if (count 0) cwai
t(notempty) x buffer(nextout nextout
nextout)N
count csignal(notfull)
67
Parbegin(producer, consumer)
Void producer() Char x while (true)
produce(x) append(x)


Void consumer() Char x while(true)
take(x) consume(x)


68
Message Passing

• Enforce mutual exclusion
• Exchange information
• send (destination, message)
• receive (source, message)

69
Synchronization

• Sender and receiver may or may not be blocking
  (waiting for message)
  
• Blocking send, blocking receive
• Both sender and receiver are blocked until
  message is delivered
  
• Called a rendezvous

70
Synchronization

• Nonblocking send, blocking receive
• Sender continues processing such as sending
  messages as quickly as possible
  
• Receiver is blocked until the requested message
  arrives
  
• Nonblocking send, nonblocking receive
• Neither party is required to wait

71
Addressing

• Direct addressing
• send primitive includes a specific identifier of
  the destination process
  
• receive primitive could know ahead of time which
  process a message is expected
  
• receive primitive could use source parameter to
  return a value when the receive operation has
  been performed
  

72
Addressing

• Indirect addressing
• messages are sent to a shared data structure
  consisting of queues
  
• queues are called mailboxes
• one process sends a message to the mailbox and
  the other process picks up the message from the
  mailbox
  

73
(No Transcript)
74
Message Format
75
Readers/Writers Problem

• Any number of readers may simultaneously read the
  file
  
• Only one writer at a time may write to the file
• If a writer is writing to the file, no reader may
  read it