update to current commit

Author: Yui Kwan Calvin Leung

synch.cc

@@ -100,13 +100,165 @@ Semaphore::V()
 // Dummy functions -- so we can compile our later assignments 
 // Note -- without a correct implementation of Condition::Wait(), 
 // the test case in the network assignment won't work!
-Lock::Lock(char* debugName) {}
-Lock::~Lock() {}
-void Lock::Acquire() {}
-void Lock::Release() {}
-
-Condition::Condition(char* debugName) { }
-Condition::~Condition() { }
-void Condition::Wait(Lock* conditionLock) { ASSERT(FALSE); }
-void Condition::Signal(Lock* conditionLock) { }
-void Condition::Broadcast(Lock* conditionLock) { }
+Lock::Lock(char* debugName)
+{
+    name = debugName;
+    lockStatus = FREE;
+    lockOwner = NULL;
+    waitQueue = new List;
+}
+
+Lock::~Lock() 
+{
+	delete waitQueue;
+}
+
+void Lock::Acquire()
+{
+    IntStatus oldLevel = interrupt->SetLevel(IntOff); //disable interrupts
+    if(currentThread == lockOwner) //current thread is lock owner
+    {
+        (void) interrupt->SetLevel(oldLevel); //restore interrupts
+        return;
+    }
+
+    if(lockStatus == FREE) //lock is available
+    {
+        //I can have the lock
+        lockStatus = BUSY; //make state BUSY
+        lockOwner = currentThread; //make myself the owner
+    }
+    else //lock is busy
+    {
+        waitQueue->Append(currentThread); //Put current thread on the lock’s waitQueue
+        currentThread->Sleep();
+    }
+
+    (void) interrupt->SetLevel(oldLevel); //restore interrupts
+}
+
+void Lock::Release()
+{
+    IntStatus oldLevel = interrupt->SetLevel(IntOff); //disable interrupts
+    if(currentThread != lockOwner) //current thread is not lock owner
+    {
+        printf("Lock::Release::(currentThread != lockOwner)::Current thread is not lock owner\n");
+        (void) interrupt->SetLevel(oldLevel); //restore interrupts
+        return;
+    }
+
+    if(!waitQueue->IsEmpty()) //lock waitQueue is not empty
+    { 
+        Thread* thread = (Thread*)waitQueue->Remove(); //remove 1 waiting thread
+        lockOwner = thread; //make them lock owner
+        scheduler->ReadyToRun(thread); //puts a thread at the back of the 
+                             //readyQueue in the ready state
+    }
+    else
+    {
+        lockStatus = FREE; //make lock available
+        lockOwner = NULL; //unset ownership
+    }
+
+    (void) interrupt->SetLevel(oldLevel); //restore interrupts
+}
+
+void Lock::Print()
+{
+    printf("Lock waitQueue contents:\n");
+    waitQueue->Mapcar((VoidFunctionPtr) ThreadPrint);
+}
+
+Condition::Condition(char* debugName)
+{
+    name = debugName;
+    waitingLock = NULL;
+    waitQueue = new List;
+}
+
+Condition::~Condition() 
+{
+	delete waitQueue;
+}
+
+void Condition::Wait(Lock* conditionLock)
+{
+    //ASSERT(FALSE); 
+
+    IntStatus oldLevel = interrupt->SetLevel(IntOff); //disable interrupts
+    if(conditionLock == NULL)
+    {
+        printf("Condition::Wait::(conditionLock == NULL)::There is no lock to be acquired\n");
+        (void) interrupt->SetLevel(oldLevel); //restore interrupts
+        return;
+    }
+    if(waitingLock == NULL)
+    {
+        //no one waiting
+        waitingLock = conditionLock;
+    }
+    if(waitingLock != conditionLock)
+    {
+        printf("Condition::Wait::(waitingLock != conditionLock)::waitingLock and the lock passed in don't match\n");
+        (void) interrupt->SetLevel(oldLevel); //restore interrupts
+        return;
+    }
+    //OK to wait
+    waitQueue->Append(currentThread);//Hung: add myself to Condition Variable waitQueue
+	conditionLock->Release();
+    currentThread->Sleep(); //currentThread is put on the waitQueue
+    conditionLock->Acquire();
+    (void) interrupt->SetLevel(oldLevel); //restore interrupts
+}
+
+void Condition::Signal(Lock* conditionLock)
+{
+    IntStatus oldLevel = interrupt->SetLevel(IntOff); //disable interrupts
+    if(waitQueue->IsEmpty()) //no thread waiting
+    { 
+        (void) interrupt->SetLevel(oldLevel); //restore interrupts
+        return;
+    }
+
+    if(waitingLock != conditionLock)
+    {
+        printf("Condition::Signal::(waitingLock != lock)::Incorrect lock passed in\n");
+        (void) interrupt->SetLevel(oldLevel); //restore interrupts
+        return;
+    }
+
+    //Wake up one waiting thread
+    Thread* thread = (Thread*)waitQueue->Remove();//Remove one thread from waitQueue
+    scheduler->ReadyToRun(thread); //Put on readyQueue
+
+    if(waitQueue->IsEmpty()) //waitQueue is empty
+    {
+        waitingLock = NULL;
+    }
+
+    (void) interrupt->SetLevel(oldLevel); //restore interrupts
+}
+
+void Condition::Broadcast(Lock* conditionLock)
+{
+    IntStatus oldLevel = interrupt->SetLevel(IntOff); //disable interrupts
+    if(conditionLock == NULL)
+    {
+        printf("Condition::Broadcast::(conditionLock == NULL)::No lock passed in.  Reenable interrupts and return.\n");
+        (void) interrupt->SetLevel(oldLevel); //restore interrupts
+        return;
+    }
+
+    if(conditionLock != waitingLock)
+    {
+        printf("Condition::Broadcast::(conditionLock != waitingLock)::Waiting lock is not the same as the condition lock.\n");
+        (void) interrupt->SetLevel(oldLevel); //restore interrupts
+        return;
+    }
+
+    (void) interrupt->SetLevel(oldLevel); //restore interrupts
+    while(!waitQueue->IsEmpty()) //waitQueue is not empty
+    {
+        Signal(conditionLock);
+    }
+}

synch.h

@@ -41,7 +41,6 @@ class Semaphore {
     Semaphore(char* debugName, int initialValue);	// set initial value
     ~Semaphore();   					// de-allocate semaphore
     char* getName() { return name;}			// debugging assist
-    
     void P();	 // these are the only operations on a semaphore
     void V();	 // they are both *atomic*
 
@@ -76,10 +75,15 @@ class Lock {
 					// holds this lock.  Useful for
 					// checking in Release, and in
 					// Condition variable ops below.
-
+    Thread* getLockOwner() {return lockOwner;}
+    void Print();
   private:
     char* name;				// for debugging
     // plus some other stuff you'll need to define
+    enum LockStatus {FREE, BUSY};
+    LockStatus lockStatus;
+    Thread* lockOwner;
+    List* waitQueue;
 };
 
 // The following class defines a "condition variable".  A condition
@@ -132,5 +136,7 @@ class Condition {
   private:
     char* name;
     // plus some other stuff you'll need to define
+    Lock* waitingLock;
+    List *waitQueue;
 };
 #endif // SYNCH_H