Outline for 1/16/98

• Last Time: Blocking synchronization, semaphores, Producer/Consumer problem, Five Dining Philosopher problem introduced, deadlock and starvation.
• Administrative: Homework 1 due today.
• Objective: several 5DP semaphore-based solutions, other abstractions: monitors / condition variables

Eliminating Circular Wait Conditionn

while (food available)
{	 if (me == 0) {P(fork[left(me)]); P(fork[right(me)]);}
	 else {(P(fork[right(me)]); P(fork[left(me)]); }
	eat;
	 V(fork[left(me)]); V(fork[right(me)]); 			
	think awhile;
}

Eliminating Hold and Wait Condition

while (food available)
{	P(mutex);
 	while (forks [me] != 2) 
		{blocking[me] = true; V(mutex); P(sleepy[me]); P(mutex);}
	forks [leftneighbor(me)] --;  forks [rightneighbor(me)]--;
	V(mutex):
	eat;
	P(mutex); forks [leftneighbor(me)] ++;  forks [rightneighbor(me)]++;
	if (blocking[leftneighbor(me)]) V(sleepy[leftneighbor(me)]); 
	if (blocking[rightneighbor(me)]) V(sleepy[rightneighbor(me)]); V(mutex);
	think awhile;
}

Starvation

• Once a set of processes are deadlocked, there is no future execution sequence that can get them out of it.
• In starvation, there does exist some execution sequence that is favorable to the starving process although there is no guarantee it will ever occur.
• Rollback and Retry solutions are prone to starvation.
• Continuous arrival of higher priority processes is another common starvation situation.

Monitor Abstraction

• Encapsulates shared data and operations with mutual exclusive use of the object (an associated lock).
• Associated Condition Variables with operations of Wait and Signal.

Condition Variables

• We build the monitor abstraction out of a lock (for the mutual exclusion) and a set of associated condition variables.
• Wait on condition: releases lock held by caller, caller goes to sleep on condition’s queue. When awakened, it must reacquire lock.
• Signal condition: wakes up one waiting thread.
• Broadcast: wakes up all threads waiting on this condition.

5DP - Monitor Style

Boolean eating [5];
Lock forkMutex;
Condition forksAvail;

void PickupForks (int i) {
	forkMutex.Acquire( );
	while ( eating[(i-1)%5] || eating[(i+1)%5] ) 
	     forksAvail.Wait(&forkMutex);
	eating[i] = true;
	forkMutex.Release( );
}

void PutdownForks (int i) {
	forkMutex.Acquire( );
	eating[i] = false;
	forksAvail.Broadcast(&forkMutex);
	forkMutex.Release( );
}

What about this?

while (food available)
{	forkMutex.Acquire( );
 	while (forks [me] != 2) {blocking[me]=true;
		forkMutex.Release( ); sleep( ); forkMutex.Acquire( );}
	forks [leftneighbor(me)]--;  forks [rightneighbor(me)]--;
	 forkMutex.Release( ):
	eat;
	 forkMutex.Acquire( );
	forks[leftneighbor(me)] ++;  forks [rightneighbor(me)]++;
	if (blocking[leftneighbor(me)] || blocking[rightneighbor(me)]) wakeup ( );  forkMutex.Release( );
	think awhile;
}