[SOLVED] CS /*

/*
* Low priority thread L acquires a lock, then blocks waiting for
* the condition.Medium priority thread M then blocks waiting for
* the same condition.Next, high priority thread H attempts to
* acquire the lock, donating its priority to L.
*
* Next, the main thread signals the condition, waking up L.L
* releases the lock, which wakes up H.H signals the condition,
* waking up M. H terminates, then M, then L, and finally the
* main thread.
*
* Derived from priority_donate_sema by Godmar Back
*
* Modifications Copyright (C) 2017 David C. Harrison. All rights reserved.
*/
#include
#include tests/threads/tests.h
#include threads/init.h
#include threads/condvar.h
#include threads/lock.h
#include threads/thread.h

struct lock_and_cond {
struct lock thread_lock;
struct lock condvar_lock;
struct condvar condvar;
};

static thread_func l_thread_func;
static thread_func m_thread_func;
static thread_func h_thread_func;

void test_priority_donate_condvar(void)
{
ASSERT(thread_get_priority() == PRI_DEFAULT);

struct lock_and_cond ls;

lock_init(&ls.thread_lock);
lock_init(&ls.condvar_lock);
condvar_init(&ls.condvar);

thread_create(low, PRI_DEFAULT + 1, l_thread_func, &ls);
thread_create(med, PRI_DEFAULT + 3, m_thread_func, &ls);
thread_create(high, PRI_DEFAULT + 5, h_thread_func, &ls);
lock_acquire(&ls.condvar_lock);

msg(Thread %s signaling, thread_current()->name);
condvar_signal(&ls.condvar, &ls.condvar_lock);
lock_release(&ls.condvar_lock);
msg(Thread %s finished, thread_current()->name);
}

static void l_thread_func(void *ls_)
{
struct lock_and_cond *ls = ls_;

lock_acquire(&ls->thread_lock);
msg(Thread %s acquired lock, thread_current()->name);
lock_acquire(&ls->condvar_lock);
condvar_wait(&ls->condvar, &ls->condvar_lock);
lock_release(&ls->condvar_lock);
msg(Thread %s woke up, thread_current()->name);
lock_release(&ls->thread_lock);
msg(Thread %s finished, thread_current()->name);
}

static void m_thread_func(void *ls_)
{
struct lock_and_cond *ls = ls_;

lock_acquire(&ls->condvar_lock);
condvar_wait(&ls->condvar, &ls->condvar_lock);
lock_release(&ls->condvar_lock);
msg(Thread %s finished, thread_current()->name);
}

static void h_thread_func(void *ls_)
{
struct lock_and_cond *ls = ls_;

lock_acquire(&ls->thread_lock);
msg(Thread %s acquired lock, thread_current()->name);

lock_acquire(&ls->condvar_lock);
msg(Thread %s signaling, thread_current()->name);
condvar_signal(&ls->condvar, &ls->condvar_lock);
lock_release(&ls->condvar_lock);
lock_release(&ls->thread_lock);
msg(Thread %s finished, thread_current()->name);
}