CHAP5 - Concurrency Mutual Exclusion and Synchronization...

Concurrency: Mutual Exclusion
and Synchronization
Chapter 5

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

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

Difficulties with Concurrency
•
Sharing global resources
•
Management of allocation of resources
•
Programming errors difficult to locate

A Simple Example
void echo()
{
chin = getchar();
chout = chin;
putchar(chout);
}

A Simple Example
Process P1 Process P2
. .
in = getchar(); .
. in = getchar();
chout = chin; chout = chin;
putchar(chout); .
. putchar(chout);
. .

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

Process Interaction
•
Processes unaware of each other
•
Processes indirectly aware of each other
•
Process directly aware of each other

Competition Among
Processes for Resources
•
Mutual Exclusion
–
Critical sections
•
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

Cooperation Among Processes
by Sharing
•
Writing must be mutually exclusive
•
Critical sections are used to provide data
integrity

Cooperation Among Processes
by Communication
•
Messages are passes
–
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

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

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

First Attempt
•
Busy Waiting
Process P0:
while(turn!=0)
{};
CS
turn:=1;
RS
Process P1:
while(turn!=1){};
CS
turn:=0;
RS

First Attempt
•
Drawbacks:
–
Busy waiting
–
Processes must strictly alternate
–
If one process fails the other process is
permanently blocked

Second Attempt
•
Each process can examine the other’s status
but cannot alter it.