我有一个嵌套的 for 循环，它生成以下程序集:

# branch target labels manually added for readability
002E20F8  mov         ebx,esi  
002E20FA  mov         dword ptr [ebp-10h],3B9ACA00h  
002E2101  sub         ebx,edi  
002E2103  add         ebx,7  
002E2106  shr         ebx,3  
002E2109  nop         dword ptr [eax]  
  outer_loop:
002E2110  xor         eax,eax  
002E2112  xor         ecx,ecx  
002E2114  cmp         edi,esi  
002E2116  mov         edx,ebx  
002E2118  cmova       edx,eax  
002E211B  mov         eax,edi  
002E211D  test        edx,edx 
002E211F  je          main+107h (02E2137h)  ;end_innerloop

  inner_loop:           
002E2121  movsd       xmm0,mmword ptr [eax] 
002E2125  inc         ecx                     ; inc/addsd swapped
002E2126  addsd       xmm0,mmword ptr [k]   
002E212B  add         eax,8  
002E212E  movsd       mmword ptr [k],xmm0  
002E2133  cmp         ecx,edx  
002E2135  jne         main+0F1h (02E2121h)  ;inner_loop
  end_innerloop:        
002E2137  sub         dword ptr [ebp-10h],1  
002E213B  jne         main+0E0h (02E2110h)   ;outer_loop

如果我将嵌套 for 循环之前的一行代码更改为简单地声明一个 int，然后在 for 循环之后将其打印出来。这使得编译器将 k 的存储/重新加载从循环中拉出来。

问题的第一个版本将此描述为“以稍微不同的顺序生成指令”。 (编者按:也许我应该把这个分析/更正留给答案？)

003520F8  mov         ebx,esi  
003520FA  mov         dword ptr [ebp-10h],3B9ACA00h  
00352101  sub         ebx,edi  
00352103  add         ebx,7  
00352106  shr         ebx,3  
00352109  nop         dword ptr [eax]  
  outer_loop:
00352110  xor         eax,eax  
00352112  xor         ecx,ecx  
00352114  cmp         edi,esi  
00352116  mov         edx,ebx  
00352118  cmova       edx,eax  
0035211B  mov         eax,edi  
0035211D  test        edx,edx  
0035211F  je          main+107h (0352137h) ;end_innerloop

00352121  movsd       xmm0,mmword ptr [k]    ; load of k hoisted out of the loop.  Strangely not optimized to xorpd xmm0,xmm0

  inner_loop:
00352126  addsd       xmm0,mmword ptr [eax]
0035212A  inc         ecx  
0035212B  add         eax,8  
0035212E  cmp         ecx,edx  
00352130  jne         main+0F6h (0352126h)  ;inner_loop

00352132  movsd       mmword ptr [k],xmm0     ; movsd in different place.

  end_innerloop:
00352137  sub         dword ptr [ebp-10h],1  
0035213B  jne         main+0E0h (0352110h)  ;outer_loop

编译器的第二次安排快了 3 倍。我对此感到有些震惊。有谁知道这是怎么回事吗？

这是用 Visual Studio 2015 编译的。

编译器标志(如果需要我可以添加更多):

优化:最大化速度 /O2

代码:

#include <iostream>
#include <vector>
#include "Stopwatch.h"

static constexpr int N = 1000000000;

int main()
{
    std::vector<double> buffer;

    buffer.resize(10);

    for (auto& i : buffer)
    {
        i = 1e-100;
    }

    double k = 0;
    int h = 0; // removing this line and swapping the lines std::cout << "time = "... results in 3x slower code??!!

    Stopwatch watch;

    for (int i = 0; i < N; i++)
    {
        for (auto& j : buffer)
        {
            k += j;
        }
    }

    //std::cout << "time = " << watch.ElapsedMilliseconds() << " / " << k << std::endl;
    std::cout << "time = " << watch.ElapsedMilliseconds() << " / " << k << " / " << h << std::endl;

    std::cout << "Done...";
    std::getchar();

    return EXIT_SUCCESS;
}

秒表类:

#pragma once

#include <chrono>

class Stopwatch
{
private:
    typedef std::chrono::high_resolution_clock clock;
    typedef std::chrono::microseconds microseconds;
    typedef std::chrono::milliseconds milliseconds;

    clock::time_point _start;

public:
    Stopwatch()
    {
        Restart();
    }

    void Restart()
    {
        _start = clock::now();
    }

    double ElapsedMilliseconds()
    {
        return ElapsedMicroseconds() * 1E-3;
    }

    double ElapsedSeconds()
    {
        return ElapsedMicroseconds() * 1E-6;
    }

    Stopwatch(const Stopwatch&) = delete;
    Stopwatch& operator=(const Stopwatch&) = delete;

private:
    double ElapsedMicroseconds()
    {
        return static_cast<double>(std::chrono::duration_cast<microseconds>(clock::now() - _start).count());
    }
};

最佳答案

在编辑问题以修复令人困惑的换行符，并在 jcc 指令中的地址前面添加分支目标标签以弄清楚代码实际在做什么之后，它很明显，循环明显不同。 movsd 在循环中没有重新排序；它在循环之外。

我决定编辑问题并在此处讨论，而不是将这些内容留在问题中并在答案中进行更正。我认为代码块足够长，以至于 future 的读者会因为试图跟踪代码的 4 个版本而陷入困境，而且它无法帮助有相同问题的人通过搜索引擎找到它。

快速版本将 k 保存在寄存器 (xmm0) 中，而慢速版本在每次迭代时重新加载/存储它。这通常表明编译器的别名分析未能证明事物不能重叠。

造成伤害的不是额外的存储和加载本身，而是它通过存储转发延迟延长了循环承载的依赖链从一次迭代中的存储到加载中的加载下一次迭代。存储转发延迟在现代 Intel CPU 上约为 6 个周期，而 addsd(例如在 Haswell 上)为 3 个周期。所以这完美地解释了 3 倍加速的因素:

• 当循环携带的依赖链为addsd + store-forwarding
时，每次迭代 9 个周期
• 当循环携带的依赖链只是 addsd
时每次迭代 3 个周期

参见 http://agner.org/optimize/有关指令表和微架构的详细信息。 x86 中的其他链接标记维基。

IDK MSVC 怎么没能证明 k 不与任何东西重叠，因为它是一个本地地址，其地址没有逃脱函数。 (它的地址甚至没有被占用)。 MSVC 在那里做得很糟糕。它也应该只是 xorps xmm0,xm​​m0 在循环之前将其归零，而不是加载一些归零的内存。我什至没有看到它在哪里清零任何内存；我想这不是整个函数的汇编。

如果您使用 MSVC 的 -ffast-math 等价物进行编译，它可以对归约进行矢量化(使用 addpd)，并希望有多个累加器。尽管使用这样一个微小 vector ，您要循环很多次，但非 4 的倍数元素计数还是有点不方便。不过，循环开销在这里不是问题；即使 k 保存在寄存器中，循环携带的依赖链也会占主导地位，因为您的代码只使用一个累加器。每 3 个时钟一个 addsd 为其他 insn 运行留下大量时间。

理想情况下，允许关联的 FP 数学重新排序将使编译器将其优化为 k = N * std::accumulate(...); 就像@Ped7g 建议的那样，处理数组的总和作为一个普通的子表达式。

顺便说一句，有很多更好的方法来初始化 vector :

与其调整 vector 大小(使用默认构造函数构造新元素)然后然后写入新值，您应该做类似的事情

std::vector<double> buffer(10, 1e-100);   // 10 elements set to 1e-100

这确保了 asm 不会在存储您想要的值之前浪费时间存储零。我认为 resize 也可以取一个值复制到新元素中，所以你仍然可以声明一个空 vector 然后调整它的大小。

关于c++ - 更改完全不相关的代码时，Visual Studio C++ 编译器生成的代码速度降低了 3 倍，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/38768000/