ucore-lab7

void Lock::Acquire() {
	while(test-and-set(value));//锁定
		; //spin
}

void Lock::Release() {
	value = 0;//解锁
}

class Lock{
	int value = 0;
	WaitQueue q;//等待该锁的线程所排成的队列
}

void Lock::Acquire() {
	while(test-and-set(value)) {//如果返回1，则代表锁正在被其他线程使用
    ...(将该线程的TCB加入队列q)
    schedule();//该进程进入等待状态，调度其他线程
  }
}

void Lock::Release() {
	value = 0;
  ...(将该线程的TCB从等待队列q删除)
  wakeup(t);//唤醒在等待状态的线程
}

int sem; //可用的资源数
P(); //sem减一，如果sem小于0则进入等待，否则继续
V(); //sem加一，如果sem小于等于0则唤醒一个等待进程

static void
trap_dispatch(struct trapframe *tf) {
				...      
        /* LAB7 YOUR CODE */
        /* you should upate you lab6 code
         * IMPORTANT FUNCTIONS:
	       * run_timer_list
         */
        ticks ++;
        run_timer_list();//更新，使用run_timer_list函数
        break;
        ...
}

typedef struct condvar{
    semaphore_t sem;        //条件变量对应队列 用semaphore结构体 即一个信号量表示
    int count;              //对应等待队列中的线程数
    monitor_t * owner;      //这个条件变量的宿主管程
} condvar_t;

typedef struct monitor{
    semaphore_t mutex;      //互斥锁，下图中对线程A中mutex成员的wait和signal操作类似于PV操作
    semaphore_t next;       //用于线程B的wait操作使线程B睡眠或线程A的signal操作唤醒线程B
    int next_count;         //执行signal操作将当前线程（线程A）唤醒的线程（线程B） 的个数
    condvar_t *cv;          //条件变量,线程A执行wait操作让线程A进入条件对应等待队列或线程B执行signal操作唤醒线程A
} monitor_t;

// Unlock one of threads waiting on the condition variable. 
void 
cond_signal (condvar_t *cvp) {
   //LAB7 EXERCISE1: YOUR CODE
   cprintf("cond_signal begin: cvp %x, cvp->count %d, cvp->owner->next_count %d\n", cvp, cvp->count, cvp->owner->next_count);  
  /*
   *      cond_signal(cv) {
   *          if(cv.count>0) {
   *             mt.next_count ++;
   *             signal(cv.sem);
   *             wait(mt.next);
   *             mt.next_count--;
   *          }
   *       }
   */
  if(cvp->count>0) {//判断该条件变量对应等待队列中是否有等待的线程
    cvp->owner->next_count++;
    up(&(cvp->sem));
    down(&(cvp->owner->next));
    cvp->owner->next_count--;
  }//没有则相当于空操作
   cprintf("cond_signal end: cvp %x, cvp->count %d, cvp->owner->next_count %d\n", cvp, cvp->count, cvp->owner->next_count);
}

// Suspend calling thread on a condition variable waiting for condition Atomically unlocks 
// mutex and suspends calling thread on conditional variable after waking up locks mutex. Notice: mp is mutex semaphore for monitor's procedures
void
cond_wait (condvar_t *cvp) {
    //LAB7 EXERCISE1: YOUR CODE
    cprintf("cond_wait begin:  cvp %x, cvp->count %d, cvp->owner->next_count %d\n", cvp, cvp->count, cvp->owner->next_count);
   /*
    *         cv.count ++;
    *         if(mt.next_count>0)
    *            signal(mt.next)
    *         else
    *            signal(mt.mutex);//release
    *         wait(cv.sem);
    *         cv.count --;
    */
    cvp->count++;
    if(cvp->owner->next_count>0)
      up(&(cvp->owner->next));
    else
      up(&(cvp->owner->mutex));
    down(&(cvp->sem));
    cvp->count --;
    cprintf("cond_wait end:  cvp %x, cvp->count %d, cvp->owner->next_count %d\n", cvp, cvp->count, cvp->owner->next_count);
}

void phi_test_condvar (i) { 
    if(state_condvar[i]==HUNGRY&&state_condvar[LEFT]!=EATING
            &&state_condvar[RIGHT]!=EATING) {
      //当哲学家i饥饿时，如果其左右的哲学家都不在eating状态，则哲学家i进入eating状态
        cprintf("phi_test_condvar: state_condvar[%d] will eating\n",i);
        state_condvar[i] = EATING ;
        cprintf("phi_test_condvar: signal self_cv[%d] \n",i);
        cond_signal(&mtp->cv[i]) ;//唤醒哲学家i对应进程
    }
}

/*
 *  void pickup(int i) {
 *      state[i] = hungry;
 *      if ((state[(i+4)%5] != eating) && (state[(i+1)%5] != eating)) {
 *        state[i] = eating;
 *      else
 *         self[i].wait();
 *   }
 */
void phi_take_forks_condvar(int i) {
     down(&(mtp->mutex));//占用临界区资源
//--------into routine in monitor--------------
     // LAB7 EXERCISE1: YOUR CODE
     // I am hungry
     // try to get fork
//--------leave routine in monitor--------------
      state_condvar[i] = HUNGRY;//将哲学家i设置为hungry状态
      phi_test_condvar(i);//调用test函数判断是否可以eating
      if(state_condvar[i] != EATING)//如果不满足条件，未能进入eating状态
        cond_wait(&mtp->cv[i]);     //则进入等待状态，等待邻座哲学家都放下餐叉后才被唤醒
      if(mtp->next_count>0)
         up(&(mtp->next));
      else
         up(&(mtp->mutex));//唤醒释放临界区资源
}

/*
 *   void putdown(int i) {
 *      state[i] = thinking;
 *      if ((state[(i+4)%5] == hungry) && (state[(i+3)%5] != eating)) {
 *          state[(i+4)%5] = eating;
 *          self[(i+4)%5].signal();
 *      }
 *      if ((state[(i+1)%5] == hungry) && (state[(i+2)%5] != eating)) {
 *          state[(i+1)%5] = eating;
 *          self[(i+1)%5].signal();
 *      }
 *   }
 */
void phi_put_forks_condvar(int i) {
     down(&(mtp->mutex));//占用临界区资源
//--------into routine in monitor--------------
     // LAB7 EXERCISE1: YOUR CODE
     // I ate over
     // test left and right neighbors
//--------leave routine in monitor--------------
     state_condvar[i] = THINKING;//哲学家线程状态变为thinking
     phi_test_condvar(LEFT);//检测左右邻座是否处于hungry状态，将处于hungry状态的邻座置位eating状态并唤醒
     phi_test_condvar(RIGHT);
     if(mtp->next_count>0)
        up(&(mtp->next));
     else
        up(&(mtp->mutex));//唤醒释放临界区资源
}