multithreading - 多处理器架构和 Ring 3

Question

void
sema_down (struct semaphore *sema) 
{
  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);
}

上面这段代码是 PintOS 中的一个机械锁互斥锁。 PintOS 针对单处理器系统。因此，仅禁用中断就足够了。对方不可能使用互斥锁。

所以，让我们考虑一个多处理器设计:

void
sema_down (struct semaphore *sema) 
{
  old_level = intr_disable ();
  while (!lock cmpxchg(1,0)) // it is just pseudocode-idea
    {
      list_push_back (&sema->waiters, &thread_current ()->elem);
      thread_block ();
    }
  intr_set_level (old_level);
}

old_level = intr_disable (); .它关闭了中断，但仅在该 CPU 的上下文中至关重要。

可以是 原型(prototype) 在 MP 架构中获取互斥锁的功能。但是， list_push_back 有问题.它也必须是安全的多线程。但是，我们不能使用互斥锁使其安全，因为我们现在才实现它!

主要问题是:
两个(或更多)CPU 是否有可能在 Ring 0 级别(内核)上执行代码？

并且，依赖于第一个答案的子问题:

如果没有，则没有我上面描述的问题。但是-它如何实现？

如果是(这似乎不可能或很难实现)，那么我的上述考虑呢(这只是潜在问题的示例)。
我们必须使用 spinlocks或 lock-free structures ?

Answer 1

是的，在 SMP 中，多个 CPU 可以执行相同的代码，即使是在 Ring 0。

每个 CPU 都是对称的，因此它可以执行与其他 CPU 相同的代码路径(包括内核代码)，除非软件实现某种同步。

Linux内核也面临这个问题，最初实现了一个不太好的解决方案:A Big Kernel Lock在进入和退出内核时获取和释放。

这不是一个好的解决方案，因为一次只有一个 CPU 可以执行内核代码，但它实现起来很快，并且相当于您列出的第一项。

更好的解决方案是在整个内核中使用更精细的锁。
由于是内核实现了示例中所示的互斥锁或信号量等休眠锁，因此它不能依赖这些原语本身1，并且必须使用自旋锁或其他更简单的锁定形式。

幸运的是，这不是问题，当争用较少或关键路径非常短(如更新列表)时，自旋锁(和 its variants)实际上比互斥锁更好。

你可以看看mutex_init从Linux上看到，一个spinlock是用来同步等待任务队列的。

 49 void
 50 __mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)
 51 {
 52         atomic_set(&lock->count, 1);


 53         spin_lock_init(&lock->wait_lock);


 54         INIT_LIST_HEAD(&lock->wait_list);
 55         mutex_clear_owner(lock);
 56 #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
 57         osq_lock_init(&lock->osq);
 58 #endif
 59 
 60         debug_mutex_init(lock, name, key);
 61 }

所以你的第二个问题的答案是肯定的。

1 等待锁的时候不能 sleep 。