[ RCOS.java Home | RCOS Home | David's Home ]

Condition CRC

Name:

 Condition

Comment:

 The following class defines a "condition variable". A condition variable does not have a value, but threads may be queued, waiting on the variable. These are only operations on a condition variable:

Wait() -- release the lock, relinquish the CPU until signaled, then re-acquire the lock

Signal() -- wake up a thread, if there are any waiting on the condition

Broadcast() -- wake up all threads waiting on the condition

All operations on a condition variable must be made while the current thread has acquired a lock. Indeed, all accesses to a given condition variable must be protected by the same lock. In other words, mutual exclusion must be enforced among threads calling the condition variable operations.

In Nachos, condition variables are assumed to obey *Mesa*-style semantics. When a Signal or Broadcast wakes up another thread, it simply puts the thread on the ready list, and it is the responsibility of the woken thread to re-acquire the lock (this re-acquire is taken care of within Wait()). By contrast, some define condition variables according to *Hoare*-style semantics -- where the signalling thread gives up control over the lock and the CPU to the woken thread, which runs immediately and gives back control over the lock to the signaller when the woken thread leaves the critical section.

The consequence of using Mesa-style semantics is that some other thread can acquire the lock, and change data structures, before the woken thread gets a chance to run.

Collaborators:

Responsibilities: 

class Condition {
  public:
    Condition(char* debugName);         // initialize condition to
                                        // "no one waiting"
    ~Condition();                       // deallocate the condition
    char* getName() { return (name); }

    void Wait(Lock *conditionLock);     // these are the 3 operations on
                                        // condition variables; releasing the
                                        // lock and going to sleep are
                                        // *atomic* in Wait()
    void Signal(Lock *conditionLock);   // conditionLock must be held by
    void Broadcast(Lock *conditionLock);// the currentThread for all of
                                        // these operations

  private:
    char* name;
    // plus some other stuff you'll need to define
};