请求审查 mpsc 队列的内存顺序

Question

我将http://www.1024cores.net/home/lock-free-algorithms/queues/intrusive-mpsc-node-based-queue的C代码转换成C++。

在撰写本文时，如下所示：

struct MpscNode
{
  std::atomic<MpscNode*> m_next;
};

class MpscQueue
{
 private:
  std::atomic<MpscNode*> m_head;
  MpscNode*              m_tail;
  MpscNode               m_stub;

 public:
  MpscQueue() : m_head(&m_stub), m_tail(&m_stub), m_stub{{nullptr}} { }

  void push(MpscNode* node)
  {
    node->m_next.store(nullptr, std::memory_order_relaxed);
    MpscNode* prev = m_head.exchange(node, std::memory_order_relaxed);
    prev->m_next.store(node, std::memory_order_release);
  }

  MpscNode* pop()
  {
    MpscNode* tail = m_tail;
    MpscNode* next = tail->m_next.load(std::memory_order_acquire);
    if (tail == &m_stub)
    {
      if (nullptr == next)
        return nullptr;
      m_tail = next;
      tail = next;
      next = next->m_next.load(std::memory_order_acquire);
    }
    if (next)
    {
      m_tail = next;
      return tail;
    }
    MpscNode* head = m_head.load(std::memory_order_relaxed);
    if (tail != head)
      return nullptr;
    push(&m_stub);
    next = tail->m_next.load(std::memory_order_acquire);
    if (next)
    {
      // Remove node and return it.
      m_tail = next;
      return tail;
    }
    return nullptr;
  }
};

您可以在这里查看最新版本，包括我的 cmets：https://github.com/CarloWood/ai-utils/blob/master/threading/MpscQueue.h

我的问题是关于push的第二行：

MpscNode* prev = m_head.exchange(node, std::memory_order_relaxed);

我不太确定这里使用的内存顺序。 看起来不错，但我想回顾一下我使用的内存顺序。

我无法测试它，因为我只有一个 Intel CPU - 而不是一个弱的 原子的（比如 -say- ARM）。

Answer 1

是的，您的代码是正确的！ m_head 上的操作可以放宽，因为它们不用于任何同步。 pop 仅加载 m_head 以检查它是否等于 tail，但没有操作依赖于 m_head 上的同步关系。

重要的操作在m_next 上，用于建立必要的同步，并正确使用获取/释放命令。

所以从我的角度来看，这段代码看起来不错！

FWIW：您不一定需要具有弱内存模型的 CPU 来检测数据竞争； thread-sanitizer 在 x86 CPU 上也做得很好。

---

编辑：

让我尝试详细说明...首先，让我们注意一些一般性观察。

1. 队列始终至少包含一个节点，即m_tail 和m_head 始终指向某个节点并且永远不会为空。
2. 当且仅当m_tail 和m_head 指向m_stub 时，队列为空。如果m_tail 和m_head 都指向某个不是m_stub 的节点，则队列包含一个元素（即该节点），因此我们必须推送m_stub 才能使该节点出列并满足我们要求队列始终至少拥有一个节点。
3. 队列不可线性化！

在推理内存顺序时，我们首先需要确定我们的需求，即什么是必要的先发生关系。让我们使用以下符号：

happens-before    -hb->
synchronize-with  -sw->
sequenced-before  -sb->
read-from         -rf->

在这种情况下，它很简单——我们需要在 push 和 pop 操作之间建立一个发生前的关系。特别是我们需要展示以下内容（node1 和 node2 是独立的变量，但都指向同一个节点；init 和 consume 是在节点上运行的一些任意函数）：

init(node1) -sb-> push(node1) -hb-> node2 = pop() -sb-> consume(node2)

由于happens-before关系的传递性，它遵循init(node1) -hb-> consume(node2)。那么我们如何确保这一点呢？再来看看push的操作：

node->m_next.store() -sb-> m_head.exchange() -sb-> prev-m_next.store()

prev->m_next 的存储是我们的同步点。仅当该商店对消费者可见时，该节点才能被消费。

现在让我们看看pop 操作。首先，我们可以注意到有两个路径不返回nullptr，并且这两个路径都返回变量tail。 tail 有两个分配，一个来自m_tail，另一个来自next 如果tail == &m_stub。我们将在这里忽略后一种情况，因为很容易制定类似的论点。 m_tail 不能用来和pop 建立inter-thread-happens-before 关系，所以我们要考虑m_tail 是如何接收它的值的。

m_tail 有两个赋值（我们一直忽略tail == &m_stub 的情况），它们都赋值next，它本身被赋值为tail->m_next.load() 的结果。所以我们最终得到以下（简化）：

                         pop_1                                        pop_2
v-------------------------^---------------------v    v-----------------^----------------v
next=tail->m_next.load() -sb-> m_tail=next -sb-> ... -sb-> tail=m_tail -sb-> return tail

Note: pop_1 is the pop call preceeding pop_2.

这个代码路径只包含一个原子操作——tail->m_next的加载——所以这个操作必须建立必要的happens-before关系。这是通过使用获取/释放订单来实现的。如果pop操作中的load观察到push中store写入的值，那么这两个操作就建立了同步关系。值得注意的是pop_2需要的inter-thread-happens-before关系其实是pop_1建立的：

                thread1                                      thread2
  v----------------^-------------v     v------------------------^---------------------v
   prev->m_next.store(mo_release) -rf-> next=tail->m_next.load(mo_acquire) -sb-> pop_2
=> prev->m_next.store(mo_release) -sw-> next=tail->m_next.load(mo_acquire) -sb-> pop_2
=> prev->m_next.store(mo_release) -hb-> next=tail->m_next.load(mo_acquire) -sb-> pop_2
=>                           push -hb-> pop_2

现在让我们看看执行m_head 加载的代码路径。首先，此路径仅在 next 为空时才相关。其次，如果m_head 与tail 不同，我们会立即返回一个nullptr（如果push 已执行交换，但尚未存储到m_next，则可能发生这种情况 -回想一下，这个队列不是线性化的）。 所以我们只有在m_head 等于tail 时才继续（即，如果我们在队列中剩下一个不是m_stub 的节点），但我们只是讨论了如何建立必要的tail 的发生之前的关系，所以我们不需要 m_head ！ 如果在m_head 上没有获取操作，则使用memory_order_release 进行交换操作是没有意义的，因为没有任何东西可以与该交换同步。