我有一个嵌套的 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,xmm0
在循环之前将其归零,而不是加载一些归零的内存。我什至没有看到它在哪里清零任何内存;我想这不是整个函数的汇编。
如果您使用 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/