Process Synchronization: Silberschatz, Galvin and Gagne ©2009 Operating System Concepts - 8 Edition

Process Synchronization
Operating System Concepts – 8th Edition Silberschatz, Galvin and Gagne ©2009
Process Synchronization
 On the basis of synchronization, processes are categorized as one of the
following two types:
 Independent Process : Execution of one process does not affects the
execution of other processes.
 Cooperative Process : Execution of one process affects the execution of
other processes.
Process synchronization problem arises in the case of Cooperative process
also because resources are shared in Cooperative processes.
Operating System Concepts – 8th Edition 6.2 Silberschatz, Galvin and Gagne ©2009
RACE Condition
When more than one processes are executing the same code or accessing the
same memory or any shared variable in that condition there is a possibility that
the output or the value of the shared variable is wrong so for that all the
processes doing race to say that my output is correct this condition known as
race condition.
B is a shared variable with initial value 2. You can execute
P1 and P2 in any way. How many different values of B can
have?
P1() P2
{ {
C=B-1; D=2*B;
B=2*C; B=D-1;
} }
Critical Section Problem
Critical Section is a code segment that accesses shared

variables and has to be executed as an atomic action. It
means that in a group of cooperating processes, at a given
point of time, only one process must be executing its critical
section. If any other process also wants to execute its critical
section, it must wait until the first one finishes.
Solution to Critical-Section Problem
Requirements:
1. Mutual Exclusion - If process Pi is executing in its critical section,
then no other processes can be executing in their critical sections.
2. 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.
3. 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.
 Assume that each process executes at a nonzero speed
 No assumption concerning relative speed of the N processes
 P0  P1
while(1) while(1)
{ {
while(turn!=0); while(turn!=1);
critical section critical section
turn=1; turn=0;
remainder section remainder section
} }
 Fulfils mutual exclusion
 Do not fulfil progress
Next approach can be fulfilling progress
USING FLAG VARIABLE
P0 P1
while(1) while(1)
{ {
flag[0]=T; flag[1]=T;
while(flag[1]); while(flag[0]);
critical section critical section
flag[0]=F flag[1]=F
} }
 Fulfils ME and progress(in some instance)
 Fails to maintain progress at every step
Peterson’s Solution
 P0  P1
while(1) while(1)
{ {
flag[0]=T flag[1]=T
turn=1 turn=0
while(turn==1&&flag[1]=T); while(turn==0&&flag[0]=T);
Critical section Critical section
Flag[0]=F; Flag[1]=F;
} }
Semaphores
 Peterson solution have the drawback of providing solution to only 2
processes to overcome this Semaphores are used that provide solution to n
processes.
 A semaphore is an integer variable
 The initialization value of semaphore decides that which problem are we
solving with semaphore.
 Eg. For critical section (S=1) where S is a semaphore variable.
Major Applications of Semaphores
 Critical section problem
 To decide order of execution of processes
 Resource management
 In critical section after initialization of semaphore variable we cannot directly
access it. I t can be accessed using two atomic operations:
 Wait(S)
 Signal(S)
 wait (S)
{
while S <= 0
; // no-op
S--;
}
 signal (S)
{
S++;
}
Solving Critical Section
do
{
Wait(S);
Critical section
Signal(S);
//Remainder section
}while(T)
Types of Semaphores
There are two main types of semaphores i.e. counting semaphores and binary
semaphores. Details about these are given as follows:
Counting Semaphores
These are integer value semaphores and have an unrestricted value domain. These
semaphores are used to coordinate the resource access, where the semaphore
count is the number of available resources. If the resources are added, semaphore
count automatically incremented and if the resources are removed, the count is
decremented.
Binary Semaphores
The binary semaphores are like counting semaphores but their value is restricted to
0 and 1. The wait operation only works when the semaphore is 1 and the signal
operation succeeds when semaphore is 0. It is sometimes easier to implement
binary semaphores than counting semaphores.
Semaphore as
General Synchronization Tool
 Counting semaphore – integer value can range over an unrestricted domain
 Binary semaphore – integer value can range only between 0
and 1; can be simpler to implement
 Also known as mutex locks
 Can implement a counting semaphore S as a binary semaphore
 Provides mutual exclusion
Semaphore mutex; // initialized to 1

do {
wait (mutex);
// Critical Section
signal (mutex);
// remainder section
} while (TRUE);
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.
 Could now have busy waiting in critical section
implementation
 But implementation code is short
 Little busy waiting if critical section rarely occupied
 Note that applications may spend lots of time in critical sections
and therefore this is not a good solution.
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 processes in the waiting queue
and place it in the ready queue.
Semaphore Implementation with
no Busy waiting (Cont.)
 Implementation of wait:
wait(semaphore *S) {
S->value--;
if (S->value < 0) {
add this process to S->list;
block();
}
}
 Implementation of signal:
signal(semaphore *S) {
S->value++;
if (S->value <= 0) {
remove a process P from S->list;
wakeup(P);
}
}
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
 Priority Inversion – Scheduling problem when lower-priority process
holds a lock needed by higher-priority process
Classical Problems of Synchronization
 Bounded-Buffer Problem
 Readers and Writers Problem
 Dining-Philosophers Problem
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
 Problem – allow multiple readers to read at the same time. Only
one single writer can access the shared data at the same time.
 Shared Data
 Data set
 Semaphore mutex initialized to 1 (controls access to
readcount)
 Semaphore wrt initialized to 1 (writer access)
 Integer readcount initialized to 0 (how many processes are
reading object)
Readers-Writers Problem (Cont.)
 The structure of a writer process
do {
wait (wrt) ;
// writing is performed
signal (wrt) ;
} while (TRUE);
Readers-Writers Problem (Cont.)
 The structure of a reader process
do {
wait (mutex) ;
readcount ++ ;
if (readcount == 1)
wait (wrt) ;
signal (mutex)
// reading is performed
wait (mutex) ;
readcount - - ;
if (readcount == 0)
signal (wrt) ;
signal (mutex) ;
} while (TRUE);

Process Synchronization: Silberschatz, Galvin and Gagne ©2009 Operating System Concepts - 8 Edition

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Process Synchronization: Silberschatz, Galvin and Gagne ©2009 Operating System Concepts - 8 Edition

Uploaded by

Copyright:

Available Formats

Process Synchronization

Critical Section is a code segment that accesses shared

Next approach can be fulfilling progress

Semaphore mutex; // initialized to 1

 With each semaphore there is an associated waiting queue.

 Readers and Writers Problem

 The structure of a writer process

You might also like