了解较长代码执行速度提高4倍的微架构原因（AMDZen2架构）

我在 x64 模式下使用 VS 2019（版本 16.8.6）编译了以下 C++17 代码：

struct __declspec(align(16)) Vec2f { float v[2]; };
struct __declspec(align(16)) Vec4f { float v[4]; };

static constexpr std::uint64_t N = 100'000'000ull;

const Vec2f p{};
Vec4f acc{};

// Using virtual method:
for (std::uint64_t i = 0; i < N; ++i)
    acc += foo->eval(p);

// Using function pointer:
for (std::uint64_t i = 0; i < N; ++i)
    acc += eval_fn(p);

在第一个循环中，foo是一个std::shared_ptr和eval()是一个虚方法：

__declspec(noinline) virtual Vec4f eval(const Vec2f& p) const noexcept
{
    return { p.v[0], p.v[1], p.v[0], p.v[1] };
}

在第二个循环中，eval_fn是一个指向以下函数的指针：

__declspec(noinline) Vec4f eval_fn_impl(const Vec2f& p) noexcept
{
    return { p.v[0], p.v[1], p.v[0], p.v[1] };
}

最后，我有两种operator+=for实现Vec4f：

• 一个使用显式循环实现的：

  Vec4f& operator+=(Vec4f& lhs, const Vec4f& rhs) noexcept
  {
      for (std::uint32_t i = 0; i < 4; ++i)
          lhs.v[i] += rhs.v[i];
      return lhs;
  }
  

• 还有一个用 SSE 内在实现：

  Vec4f& operator+=(Vec4f& lhs, const Vec4f& rhs) noexcept
  {
      _mm_store_ps(lhs.v, _mm_add_ps(_mm_load_ps(lhs.v), _mm_load_ps(rhs.v)));
      return lhs;
  }
  

您可以在下面找到测试的完整（独立，仅限 Windows）代码。

这是两个循环的生成代码，以及在AMD Threadripper 3970X CPU（Zen 2 架构）上执行时以毫秒为单位的运行时间（对于 100M 迭代）：

• 使用SSE 内在实现operator+=(Vec4f&, const Vec4f&)：

  // Using virtual method: 649 ms
  $LL4@main:
    mov rax, QWORD PTR [rdi]            // fetch vtable base pointer (rdi = foo)
    lea r8, QWORD PTR p$[rsp]           // r8 = &p
    lea rdx, QWORD PTR $T3[rsp]         // not sure what $T3 is (some kind of temporary, but why?)
    mov rcx, rdi                        // rcx = this
    call    QWORD PTR [rax]             // foo->eval(p)
    addps   xmm6, XMMWORD PTR [rax]
    sub rbp, 1
    jne SHORT $LL4@main
  
  // Using function pointer: 602 ms
  $LL7@main:
    lea rdx, QWORD PTR p$[rsp]          // rdx = &p
    lea rcx, QWORD PTR $T2[rsp]         // same question as above
    call    rbx                         // eval_fn(p)
    addps   xmm6, XMMWORD PTR [rax]
    sub rsi, 1
    jne SHORT $LL7@main
  

  // Using virtual method: 649 ms
  $LL4@main:
    mov rax, QWORD PTR [rdi]            // fetch vtable base pointer (rdi = foo)
    lea r8, QWORD PTR p$[rsp]           // r8 = &p
    lea rdx, QWORD PTR $T3[rsp]         // not sure what $T3 is (some kind of temporary, but why?)
    mov rcx, rdi                        // rcx = this
    call    QWORD PTR [rax]             // foo->eval(p)
    addps   xmm6, XMMWORD PTR [rax]
    sub rbp, 1
    jne SHORT $LL4@main
  
  // Using function pointer: 602 ms
  $LL7@main:
    lea rdx, QWORD PTR p$[rsp]          // rdx = &p
    lea rcx, QWORD PTR $T2[rsp]         // same question as above
    call    rbx                         // eval_fn(p)
    addps   xmm6, XMMWORD PTR [rax]
    sub rsi, 1
    jne SHORT $LL7@main
  

• 使用显式循环实现operator+=(Vec4f&, const Vec4f&)：

  // Using virtual method: 167 ms [3.5x to 4x FASTER!]
  $LL4@main:
    mov rax, QWORD PTR [rdi]
    lea r8, QWORD PTR p$[rsp]
    lea rdx, QWORD PTR $T5[rsp]
    mov rcx, rdi
    call    QWORD PTR [rax]
    addss   xmm9, DWORD PTR [rax]
    addss   xmm8, DWORD PTR [rax+4]
    addss   xmm7, DWORD PTR [rax+8]
    addss   xmm6, DWORD PTR [rax+12]
    sub rbp, 1
    jne SHORT $LL4@main
  
  // Using function pointer: 600 ms
  $LL7@main:
    lea rdx, QWORD PTR p$[rsp]
    lea rcx, QWORD PTR $T4[rsp]
    call    rbx
    addps   xmm6, XMMWORD PTR [rax]
    sub rsi, 1
    jne SHORT $LL7@main
  

（在AMD禅2拱，据我所知，addss并且addps指令具有3个周期的等待时间，和最多两个这样的指令可以同时执行）。

令我困惑的情况是在使用虚拟方法和显式循环实现时operator+=：

为什么它比其他三个变体快 3.5 到 4 倍？

这里有哪些相关的建筑效果在起作用？在循环的后续迭代中寄存器之间的依赖性更少？或者关于缓存的某种厄运？

完整源代码：

回答

__declspec(noinline) virtual Vec4f eval(const Vec2f& p) const noexcept
{
    Vec4f r;
    auto pv = _mm_load_ps(p.v);
    _mm_store_ps(r.v, _mm_shuffle_ps(pv, pv, _MM_SHUFFLE(1, 0, 1, 0)));
    return r;
}