c++ - 不能在 C++ 中引发优先级倒置

Question

为了演示目的，我试图在一个小的 C++ 程序上引发 Priority Inversion，但我不能:持有互斥锁的低优先级线程 没有被抢占，并一直在临界区运行。这就是我正在做的:

// let's declare a global mutex
pthread_mutex_t my_mutex;
  ...

int main(int argc, char **argv) {
  ...
  pthread_t normal_thread;
  pthread_t prio_thread;

  pthread_mutexattr_t attr;
  pthread_mutexattr_init (&attr);
  pthread_mutexattr_setprotocol (&attr, PTHREAD_PRIO_NONE);  // ! None !
  pthread_mutex_init(&my_mutex, &attr);

  // create first normal thread (L):
  pthread_create(&normal_thread, NULL, the_locking_start_routine, NULL);

  // just to help the normal thread enter in the critical section
  sleep(2);

  // now will launch:
  // * (M) several CPU intensive SCHED_FIFO threads with priority < 99
  // * (H) one SCHED_FIFO thread that will try to lock the mutex, with priority < 99

  // build Real Time attributes for the Real Time threads:
  pthread_attr_t my_rt_att;
  pthread_attr_init(&my_rt_att);

  // it was missing in the original post and it was also wrong:
  // even setting the SchedPolicy you have to set "InheritSched"
  pthread_attr_setinheritsched(&my_rt_att, PTHREAD_EXPLICIT_SCHED)

  pthread_attr_setschedpolicy(&my_rt_att, SCHED_FIFO);
  struct sched_param params;

  params.sched_priority = 1;
  pthread_attr_setschedparam(&my_rt_att, &params);

  pthread_create(&prio_thread, &my_rt_att, the_CPU_intensive_start_routine, NULL) 

  params.sched_priority = 99;
  pthread_attr_setschedparam(&my_rt_att, &params);

  // create one RealTime thread like this:
  pthread_create(&prio_thread, &my_rt_att, the_locking_start_routine, NULL)  //coma was missing

  ...
}

void *the_locking_start_routine(void *arg) {
  ...
  pthread_mutex_lock(&my_mutex);
  // This thread is on the critical section
  // ... (skipped)
  pthread_mutex_unlock(&my_mutex);
  ...
}

...但它不起作用，我无法获得我想要的优先级反转。

是这样的:

据我了解，对于像 Linux 的 CFS 这样的调度程序，非实时线程 (SCHED_OTHER) 将不会运行，直到没有任何实时线程(SCHED_FIFO 或 SCHED_RR)处于运行状态。但是我已经实现了这个线程同时运行:

• (L) 一个非实时 (SCHED_OTHER) 线程锁定互斥体和消耗 CPU
• (M) 几个实时线程 (SCHED_FIFO , & priority > 0) CPU密集且非等待锁定互斥锁
• (H) 一个实时线程(SCHED_FIFO 和最高优先级)等待为了锁

运行的实时 CPU 密集型线程 (M) 多于我系统的 CPU 数量...但是持有锁的非实时线程 (L) 仍在消耗 CPU 并完成其工作并释放在“M”线程完成消耗 CPU 之前互斥。

为什么低优先级线程没有被抢占，应用程序死锁，我无法获得优先级反转？

我在内核为 2.6.38-13 的 Ubuntu Desktop 11.04 上使用 g++ 4.5.2。

Answer 1

回复:我试图在一个小型 C++ 程序上引发优先级反转以用于演示目的，但我不能:持有互斥锁的低优先级线程未被抢占并继续运行 ...

那是优先级反转场景的开始。低优先级线程获取独占资源(例如互斥锁)，然后高优先级线程会阻塞该资源。

要正确显示优先级倒置的后果，例如，您需要三个线程:低优先级 (L)、中等 (M) 和高 (H) 优先级线程。

L 锁定一个 H 争用的互斥体。所以 L 正在运行，H 没有。这已经很糟糕了:重要的线程 H 正在等待不太重要的线程 L 做某事。

现在 M 变得可运行并且是计算密集型的。 M 不关心互斥量；它与 H 或 L 无关。但是 M 的优先级高于 L，并将 L 踢出 CPU。

所以现在 M 继续执行，阻止 L 运行。这可以防止 L 到达释放互斥锁的代码行，也可以防止 H 获得互斥锁。

因此一个中等优先级的线程 M 正在运行，而不是最高优先级的线程 H。

通过阻止 L，M 也能够阻止 H:反转。

看看你是否可以完全像这样编写代码。