同一线程重新获取 openmp 锁，而其他线程正在等待它

Question

我使用反向锁作为信号量来指示队列更新（注意注释掉的 Sleep(1)，稍后会用到）：

#include <stdio.h>
#include <omp.h>
#include <queue>
#include <stdint.h>
#include <windows.h>

class ThreadLock
{
protected:
  omp_lock_t lock;

public:
  ThreadLock() {
    omp_init_lock(&lock);
  }
  ~ThreadLock() {
    omp_destroy_lock(&lock);
  }

  void acquire() {
    omp_set_lock(&lock);
  }

  void release() {
    omp_unset_lock(&lock);
  }
};

std::queue< uint32_t > g_queue;
ThreadLock g_lock;

void producer()
{
  uint32_t seq = 0;
  g_lock.acquire();
  while (true) {
    Sleep(200);
    #pragma omp critical
      g_queue.push(++seq);
    printf("Produced %u\n", seq);

    g_lock.release();
    //Sleep(1);
    g_lock.acquire();
  }
  g_lock.release();
}

void consumer()
{
  while (true) {
    // Lock if empty
    if (g_queue.empty()) {
      printf("[Consumer] Acquiring lock\n");
      g_lock.acquire();
      g_lock.release();
      printf("[Consumer] Released lock\n");
      if (g_queue.empty()) {
        printf("Still empty\n");
        Sleep(100);
        continue;
      }
    }

    #pragma omp critical
    {
      printf("Consumed %u\n", g_queue.front());
      g_queue.pop();
    }
  }
}

int main(int argc, char* argv[])
{
  #pragma omp parallel sections
  {
    #pragma omp section
      consumer();
    #pragma omp section
      producer();
  }

  return 0;
}

这段代码包含一个竞争条件，它会在一段时间后停止消费者，如下所示：

[Consumer] Acquiring lock
Produced 1
Produced 2
[Consumer] Released lock
Consumed 1
Consumed 2
[Consumer] Acquiring lock
Produced 3
Produced 4
Produced 5
Produced 6
Produced 7
Produced 8
Produced 9
Produced 10
Produced 11
Produced 12
Produced 13
Produced 14
Produced 15
Produced 16
Produced 17
Produced 18
Produced 19

生产者线程似乎在 release/acquire 没有上下文切换的情况下匆匆忙忙。美好的。让我们通过取消注释 Sleep(1):

来强制它

[Consumer] Acquiring lock
Produced 1
[Consumer] Released lock
Consumed 1
[Consumer] Acquiring lock
[Consumer] Released lock
Still empty
[Consumer] Acquiring lock
Produced 2
[Consumer] Released lock
Consumed 2
[Consumer] Acquiring lock
[Consumer] Released lock
Still empty
[Consumer] Acquiring lock
Produced 3
[Consumer] Released lock
Consumed 3

注意到那些 Still empty 行了吗？看起来消费者设法在生产者的 release/acquire 行之间进行额外的处理。

我知道在消费者线程中添加另一个 Sleep(1) 可以解决问题。但我觉得代码中这些固定的人为延迟是错误的（Sleep(200) 不算，它仅用于演示目的）。

使用 OpenMP 和不使用高于 2.0 的 OpenMP 版本如何以正确的方式完成？

Answer 1

您的代码中存在几个问题。您正在混合 #pragma omp critical 和锁 - 这没有多大意义。你真正想要的是一个锁的组合——用于保护队列上的所有操作——和一个条件变量——以获得关于插入元素的通知。不幸的是，OpenMP 不提供条件变量的原语。您还可以对队列中的元素数量使用计数信号量——这在 OpenMP 中也不可用。

然后是饥饿问题，您尝试用 sleep 解决这个问题 - 无论 OS 切换任务的提示是什么，它都不是完美的。您可能会考虑使用 OpenMP 任务 + taskyield（但这不是 OpenMP 2.0）。

归根结底，OpenMP 并不是很适合这种工作。 OpenMP 更专注于拥有 1 个线程 - 1 个核心映射和分布并行循环。您可以将 OpenMP 线程与 C++11 std::lock / std::condition_variable 结合使用。虽然它可能会在实践中起作用，但标准并未正式支持它。

注意：保护队列操作时，必须保护所有个调用，包括g_queue.empty().

同一线程重新获取 openmp 锁，而其他线程正在等待它

openmp lock reacquired by the same thread while other thread is waiting for it

c++

multithreading

synchronization

openmp

race-condition