pintos (4) --Mesa vs. Hoare style

最新推荐文章于 2023-04-19 23:43:57 发布

原创最新推荐文章于 2023-04-19 23:43:57 发布 · 1.3k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#pintos #mesa #hoare

pintos 专栏收录该内容

7 篇文章

订阅专栏

在阅读pintos/src/threads/synch.c的时候，发现了一个令人疑惑的地方：

/* Down or "P" operation on a semaphore. Waits for SEMA's value
to become positive and then atomically decrements it.
This function may sleep, so it must not be called within an
interrupt handler. This function may be called with
interrupts disabled, but if it sleeps then the next scheduled
thread will probably turn interrupts back on. */
void
sema_down (struct semaphore *sema)
{
    enum intr_level old_level;

    ASSERT (sema != NULL);
    ASSERT (!intr_context ());

    old_level = intr_disable ();
    while (sema->value == 0)
    {
        list_push_back (&sema->waiters, &thread_current ()->elem);
        thread_block ();
    }
    sema->value--;
    intr_set_level (old_level);
}

这个函数是信号量的P操作，完成的功能就是

关中断
判断信号量是否为0
- 如果为0，当前进程加入该sema等待队列
- 不为0，sema–，继续执行
还原中断

第16行使用了while而不是if，为什么要在这里循环呢？
sema为0陷入阻塞之后，一定是被V操作唤醒的，既然是V操作，那么sema一定不为0，while的意义在哪里呢？

先来看一下V操作：

/* Up or "V" operation on a semaphore.  Increments SEMA's value
   and wakes up one thread of those waiting for SEMA, if any.
   This function may be called from an interrupt handler. */
void
sema_up (struct semaphore *sema) 
{
  enum intr_level old_level;

  ASSERT (sema != NULL);

  old_level = intr_disable ();
  if (!list_empty (&sema->waiters)) 
    thread_unblock (list_entry (list_pop_front (&sema->waiters),
                                struct thread, elem));
  sema->value++;
  intr_set_level (old_level);
}

V操作做了如下的事情

关中断
如果waiters队列有进程，执行thread_unblock()
sema++
还原中断

好像没什么不对的

再来看一下thread_unblock()的实现：

/* Transitions a blocked thread T to the ready-to-run state.
   This is an error if T is not blocked.  (Use thread_yield() to
   make the running thread ready.)
   This function does not preempt the running thread.  This can
   be important: if the caller had disabled interrupts itself,
   it may expect that it can atomically unblock a thread and
   update other data. */
void
thread_unblock (struct thread *t) 
{
  enum intr_level old_level;

  ASSERT (is_thread (t));

  old_level = intr_disable ();
  ASSERT (t->status == THREAD_BLOCKED);
  list_push_back (&ready_list, &t->elem);
  t->status = THREAD_READY;
  intr_set_level (old_level);
}