CS372H Spring 2011 Homework 4 Solutions

flag[i] = 1;
while (flag[j])
{
    if (turn == j)
    {
        flag[i] = 0;
        while(turn == j)
            ;
        flag[i] = 1;
    }
}

/* enter C.S. */
/* exit C.S. */
turn = j;
flag[i] = 0;

This algorithm is called Dekker's solution.

1. Mutual exclusion:
There are two cases to consider:
a. A process is inside the C.S.: Without loss of generality, assume process j is inside the C.S. Before entering
the C.S. the process sets its own flag to 1. If process i tries to enter the C.S. it will see that flag[j] is up and gets caught up in the while loop. It will continue in the while loop until the other process sets its own flag to 0, which happens only at the end of the C.S.
b. Two processes are trying to enter simultaneously: In this situation, if both processes reach their respective while loop at the top, then the variable turn will ensure that only one of them passes through. The variable turn is alternating between the allowing either process, and is only modified at the exit of a C.S.

2. Progress:
There are two cases to consider:
a. One process is trying to enter with no competition: In such a case, the flag of the other process is down, and the process goes past the while look into the critical section directly.
b. Two processes are trying to enter simultaneously. In this case if the first process is trapped into the while loop, then the variable turn will make one of the two variables lower its flag and goes into a loop waiting for the variable turn to change (the inner while loop). The other process whose turn is set by the variable turn will be able to get through.

3. Bounded Waiting:
Assume there is a process blocked inside the inner while loop, while another process is in C.S. In such a case, if the process inside the critical section tries to re-enter, it will be blocked because on exit of the C.S. it has already set the variable turn to point to the other process. Therefore, the process that just got out of the C.S. will be forced to wait for its own turn. So, bounded waiting is taken care of.

        j = a++;         // execute in one atomic operation
        a = 0;

Either come up with a solution to the C.S. problem using this facility or show that it cannot help.

This hardware solution can help implement a solution to the C.S. as follows:

// Shared state

atomic inside = 0;            // inside is an atomic counter

// Per-thread state
int a;

retry:
a = inside++;
if(a != 1)
  goto retry;
/* enter C.S. */
...
/* exit C.S. */
inside = 0;
 
Note that this counter could wrap around, causing a bug in the above solution to mainfest. If we permit an additional operation to read the value, then we can do:

// Shared state

atomic inside = 0;            // inside is an atomic counter

// Per-thread state
int a;

retry:
a = inside++;
if(a != 1){
 while(inside != 0){
  ; // spin
 }
  goto retry;
}
/* enter C.S. */
...
/* exit C.S. */
inside = 0;
 

If we don't want to add such an operation, does the following work?

// Shared state
int delay = 0;
atomic inside = 0;            // inside is an atomic counter
// Per-thread state
int a;

retry:
while(delay){
  // wait
}
delay = 1;
a = inside++;
if(a != 1){
  goto retry;
}
/* enter C.S. */
...
/* exit C.S. */
inside = 0;
delay = 0;
 

Problem 4

Problem 5

#include "Exception.h"
#include "Semaphore.h"
#include <iostream.h>

const MaxStackSize = 100;

class Stack            // throws an exception object when popping an empty stack, and when pushing into a full stack
{
private:
    int s[MaxStackSize];
    int stackp;                        // stack pointer
    Exception * e;                  // For error handling
    Semaphore * sem;           // For mutual exclusion
public:
    Stack();
    ~Stack()        {};
    int Pop(void);
    void Push(int item);
};

Stack::Stack()
{
    stackp = MaxStackSize;
    e = new Exception();
    sem = new Semaphore(1);
}

int Stack::Pop(void)
{
    P(sem)
    if(stackp == MaxStackSize)
        {
            e->SetErrorMsg("Popping empty stack");
            e->SetErrorLocation("Stack::Pop()");
            throw(e);
Error: Before throwing the exception, we must release the lock (i.e. V(sem)), or
the stack object will not be accessible to any process any time in the future.
        }
    V(sem);
    return s[stackp++];
Error: We are incrementing stackp after releasing the lock!!
}

void Stack::Push(int item)
{
    P(sem)
    if(stackp == 0)
        {
            e->SetErrorMsg("Pushing to a full stack");
            e->SetErrorLocation("Stack::Push()");
            throw(e);
Error: Before throwing the exception, we must release the lock (i.e. V(sem)), or
the stack object will not be accessible to any process any time in the future.
       }
    s[--stackp] = item;
    V(sem);
}
 

Problem 6

/*
 * Each philosopher is a thread that does the following:
 */
philosopherMain(int myId, Table *table){
  while(1){
    table->startEating(myId);
    eat();
    table->doneEating(myId);
  }
}





typedef enum stick_status{STICK_FREE, STICK_USED} stick_status;



/*
 * First solution. It is safe but not completely
 * live in that it does not guarantee freedom
 * from starvation.
 */


public class Table{
  public:
  Table(int nSeats);
  void startEating(int philosopherId);
  void doneEating(int philosopherId);

  private:
  mutex lock;
  cond  cv;
  int nseats;
  stick_status stickStatus[];
}


Table::Table(int ns)
{
  int ii;
  nseats = ns;
  stickStatus = (stick_status *)malloc(nseats * sizeof(stick_status));
  for(ii = 0; ii < nseats; ii++){
    stickStatus[ii] = STICK_FREE;
  }
}

void
Table::startEating(int id)
{
  lock.acquire();
  while(stickStatus[stickLeft(id)] == STICK_USED ||   
        stickStatus[stickRight(id)] == STICK_USED){
     cv.wait(&lock);
  }
  stickStatus[stickLeft(id)] = STICK_USED;
  stickStatus[stickRight(id)] = STICK_USED;
  lock.release();
}

void
Table::doneEating(int id)
{
  lock.acquire();
  stickStatus[stickLeft(id)] = STICK_FREE;
  stickStatus[stickRight(id)] = STICK_FREE;
  cv.broadcast(&lock);
  lock.release();
}


/*
 * Second solution. A philosopher should eat if there
 * is no conflict for the chopsticks. But, if two philosophers
 * are waiting for the same chopstick, the one that
 * has been waiting longer should go.
 *
 */

const static int NOT_WAITING = -999;

public class Table{
  public:
  Table(int nSeats);
  void startEating(int philosopherId);
  void doneEating(int philosopherId);

  private:
  mutex lock;
  cond  cv;
  int nseats;
  stick_status stickStatus[];
  int entryTime[];
  int currentTime;

  int okToGo(int id);
}


Table::Table(int ns)
{
  int ii;
  nseats = ns;
  stickStatus = (stick_status *)malloc(nseats * sizeof(stick_status));
  entryTime = (int *)malloc(nseats * sizeof(int));
  for(ii = 0; ii < nseats; ii++){
    stickStatus[ii] = STICK_FREE;
    entryTime[ii] =  NOT_WAITING;
  }
  currentTime = 0;
}

void
Table::startEating(int id)
{
  lock.acquire();
  entryTime[id] = currentTime;
  currentTime++;
  while(!okToGo(id)){
     cv.wait(&lock);
  }
  stickStatus[stickLeft(id)] = STICK_USED;
  stickStatus[stickRight(id)] = STICK_USED;
  entryTime[id] = NOT_WAITING;
  lock.release();
}

void
Table::doneEating(int id)
{
  lock.acquire();
  stickStatus[stickLeft(id)] = STICK_FREE;
  stickStatus[stickRight(id)] = STICK_FREE;
  cv.broadcast(&lock);
  lock.release();
}

int
Table::okToGo(int id)
{
  assert(lock is held on entry);
  /*
   * OK to go if both left and right sticks
   * are free AND for each stick my neighbor
   * is not waiting, or my neighbor's waiting 
   * number is larger than mine
   */
  if(stickStatus[stickLeft(id)] != STICK_FREE){
    return 0;
  }
  if(stickStatus[stickRight(id)] != STICK_FREE){
    return 0;
  }
  if(entryTime[seatRight(id)] != NOT_WAITING
     &&
     entryTime[seatRight(id)] < entryTime[id]){
    return 0;
  }
  if(entryTime[seatLeft(id)] != NOT_WAITING
     &&
     entryTime[seatLeft(id)] < entryTime[id]){
    return 0;
  }
  return 1;
}