Operating Systems{week 10}

Rensselaer Polytechnic InstituteCSCI-4210 – Operating SystemsDavid Goldschmidt, Ph.D.

A need for synchronization (i) Without synchronization amongst

processes (and threads), results are unpredictable

how do

variables x and y

become corrupted?

A need for synchronization (ii) Processes compete for resources

Once obtained, the resource isfully dedicated to a process

Often, mutual exclusion is required▪ No other process is allowed access to the

resource

Processes cooperate with other processes Shared resources Specific ordering or sequencing of

events

all of this applies

to threads, too!

Semaphores (i)

A semaphore is a synchronization mechanism Semaphore S is a special integer variable

OS provides two atomic operations on S: wait(S) or P(S):▪ wait for a resource to become available

signal(S) or V(S):▪ signal that we’re done using a resource

Semaphores (ii)

The wait(S) operation decrementssemaphore S only when S is available

wait(S) { while ( S <= 0 ) { /** no-op **/ ; } S--; }

this will blockindefinitelyin a busy wait

Semaphores (iii)

The signal(S) operation incrementssemaphore S to release a resource

signal(S) { S++; } to protectcritical section

wait(S); // CRITICAL // SECTION signal(S);

Binary semaphores

A binary semaphore providesmutually exclusive access toa shared resource Initialize semaphore S to 1 Use wait(S) and signal(S) Possible values of S are 0 and 1

Counting semaphores

A counting semaphore controls accessto a finite number of resources: e.g. open files, network connections,

shared buffers, etc.// n instances of a finite resourcesemaphore S = n Write pseudocode for the

producer-consumer problem usingsemaphores to synchronize access

to the shared buffer of size N

Starvation

A process faces starvation when it is forced to wait indefinitely for shared resource X as other processes use that shared resource X Also known as indefinite blocking

Deadlock

A system enters a deadlock state when multiple processes are unable to obtain a lock on all necessary resources After acquiring

a resource, aprocess holds thatresource indefinitely

// P0 ...wait(S)wait(Q)...signal(Q)signal(S)...

// P1 ...wait(Q)wait(S)...signal(S)signal(Q)...

semaphore S, Q

Deadlock!

Conditions for deadlock

Deadlock requires four conditions: Mutual exclusion Hold and wait No preemption Circular wait▪ i.e. a cycle!

Resource allocation graph A resource allocation graph is a

directed graph showing processes and resources

Deadlock!

Deadlock?

Rice

Dining philosophers problem (i) Five philosophers at a table

Each philosopher thinks or eats To eat, a philosopher must pick

up the closest two chopsticks A philosopher may only pick

up one chopstick at a time

Represents allocating shared resources to competing and cooperating processes

Rice

Dining philosophers problem (ii) Potential solution:

Can deadlock occur?

// philosopheri

while ( true ){ think(); wait( fork[i] ); wait( fork[(i+1)%5] ); eat(); signal( fork[(i+1)%5] ); signal( fork[i] );}

semaphore fork[] = { 1, 1, 1, 1, 1 };

Handling deadlocks (i)

Allow the system to enter a deadlock state, then recover by: Terminating one or all deadlocked

processes Rollback deadlocked processes to a safe

checkpointed state

Or....

Handling deadlocks (ii)

Guarantee that the system will neverenter a deadlocked state Deadlock prevention ensures that at

least one of the four necessary conditions is never met

Deadlock avoidance allows a system to change state by allocating resource(s) only when it is certain deadlock will not occur as a result