C++中避免预取指令重排序（SPSC队列场景）

场景说明 #

在多线程环境下的SPSC（单生产者单消费者）队列中，希望在pop操作成功时预取write_index对应的内存池数据。

原始实现 #

void process()
{
  if(spsc_queue->pop())
  {
     // 一些预处理操作

     auto r_index = spsc_queue->read_index.load(memory_order_relaxed);
     auto val = mempool_[r_index+1];

     // 后续使用val的逻辑
  }
}

加入预取后的优化实现（已观测到延迟降低） #

void process()
{
  if(spsc_queue->pop())
  {
    auto r_index = spsc_queue->read_index.load(memory_order_relaxed);
    __builtin_prefetch(mempool_ + r_index + 1, 0, 0);
    
    // 一些预处理操作

    auto val = mempool_[r_index + 1];

    // 后续使用val的逻辑
  }
}

问题描述 #

由于pop会被编译器内联，无法确定编译器或处理器是否会将预取指令重排序到pop失败的执行路径中。例如pop的实现如下：

bool pop()
{
  auto w_index = write_index.load(memory_order_acquire);
  auto r_index = read_index.load(memory_order_relaxed);

  // 会不会__builtin_prefetch被重排到这个return之前？

  if (w_index == r_index) return false; // 队列为空时提前返回失败

  // 更新其他结构体
  return true;
}

需要确保预取仅在pop返回true时执行，而非失败时。已尝试以下方法但未得到确定性结果：

• 使用mfence：在提前返回后放置mfence可确保不重排序，但会引入额外延迟，代价过高。
• 统计pop失败路径的缓存访问量：若缓存访问量上升，可能存在处理器层面的重排序，但该方法不具备确定性。
• 利用编译器原生支持阻止编译器重排序，但无法解决处理器层面的重排序问题。
• 在提前返回后访问volatile变量再执行预取：根据资料，volatile仅与其他volatile操作同步，因此对当前场景无效。

请问是否存在确定性方法，能确保预取指令不会在pop失败路径中执行？

编译器信息 #

$ gcc -v
gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0
Target: x86_64-linux-gnu

确定性解决方案 #

结合x86_64架构特性与GCC 9.4的编译规则，可通过以下两种方式确保预取指令仅在pop成功路径执行：

1. 利用pop的acquire语义+轻量编译屏障

pop中write_index.load(memory_order_acquire)已经隐含处理器层面的单向屏障：在x86架构下，acquire负载会阻止后续所有内存操作（包括预取）被重排到该负载之前。同时，为了杜绝编译器内联后的激进路径合并优化，可在pop的提前返回分支前插入编译屏障：

bool pop()
{
  auto w_index = write_index.load(memory_order_acquire);
  auto r_index = read_index.load(memory_order_relaxed);

  if (w_index == r_index) {
    // 编译屏障：告知编译器不能将内存操作跨屏障重排
    asm volatile("" ::: "memory");
    return false;
  }

  // 更新其他结构体
  return true;
}

asm volatile("" ::: "memory")不会生成任何处理器指令，仅约束编译器的内存操作重排行为，结合acquire负载的处理器屏障，可同时阻止编译器和处理器层面的非法重排序。

2. 用atomic_thread_fence强化成功路径的屏障

在pop成功后的代码块开头插入acquire类型的内存屏障，强制预取操作被约束在成功路径内：

#include <atomic>

void process()
{
  if(spsc_queue->pop())
  {
    std::atomic_thread_fence(std::memory_order_acquire);
    auto r_index = spsc_queue->read_index.load(memory_order_relaxed);
    __builtin_prefetch(mempool_ + r_index + 1, 0, 0);
    
    // 预处理操作
    auto val = mempool_[r_index + 1];
    // 后续逻辑
  }
}

这个屏障会在处理器层面阻止后续所有内存操作（包括预取）被重排到屏障之前，同时编译器会严格遵守屏障约束，不会将预取代码移动到if条件之外。

关键原理说明 #

• x86架构本身不会将负载操作重排到之前的存储操作之后，而acquire语义的负载会进一步阻止后续内存操作向前重排。
• 轻量编译屏障asm volatile("" ::: "memory")是GCC特有的无开销约束方式，比mfence的性能代价低得多。
• __builtin_prefetch在GCC中被视为内存操作，会受到编译屏障和内存屏障的双重约束。

内容的提问来源于stack exchange，提问作者Akash