Getting Started With Locks

Some tips for implementing the locks. Remember, a lock is a mutually exclusive resource, which means that only one process/thread can hold the lock at a time. A lock is always initialized in the unlocked state. This means that you can't create a lock and have a thread holding it when it is created. Think about how this relates to more basic P and V (wait and signal) semaphore functionality that can be found in kern/thread/synch.c. Is there a way that you can use existing kernel functionality to implement the locks more easily? Also, when creating a lock, what should the initial values be for its data members?

Additionally, there must be a way to find the owner of a lock. Think about a way that you can identify a process/thread that is holding the lock. How can you store this with the lock? How should you handle the owner when initializing, acquiring, releasing and destroying the lock?

Then finally keep in mind what areas of the code are critical sections. Here is a big hint: this is actually documented in the header file kern/include/synch.h.

Getting Started With Condition-Variables

A condition-variable (cv) is essentially just a condition that threads or processes are waiting on. Once the condition becomes true, then the thread(s) will get awoken.  So, in order to implement this, you have to think about how threads are put to sleep and then later woken up. How can you signal the sleeping threads that the condition-variable they are waiting on has become true? You will definitely want to look at: kern/include/thread.h and kern/thread/thread.c. As a hint, you may find it easier to implement a new function in the thread code to implement the waking of one thread. This will be very useful for simplifying cv_signal. You will also want to make sure to read over the commentary in kern/include/synch.h about condition-variables.