现代编译器能否展开使用开始和结束迭代器表示的“for”循环
[英]Can modern compilers unroll `for` loops expressed using begin and end iterators
问题描述
考虑以下代码
vector<double> v;
// fill v
const vector<double>::iterator end =v.end();
for(vector<double>::iterator i = v.bgin(); i != end; ++i) {
// do stuff
}
g++、clang++、icc 等编译器是否能够像这样展开循环。 不幸的是，我不知道程序集是否能够从输出中验证循环是否展开。 （而且我只能访问 g++。）
在我看来，这似乎需要编译器比平时更聪明，首先要推断迭代器是随机访问迭代器，然后计算出循环执行的次数。 启用优化后，编译器可以执行此操作吗？
感谢您的回复，在你们中的一些人开始讲授过早优化之前，这是一个出于好奇的练习。
4 个解决方案
解决方案1
8 2012-07-17 19:19:49
我建议编译器是否可以使用现代流水线架构和缓存展开循环，除非你的“做事”是微不足道的，否则这样做没有什么好处，而且在很多情况下这样做会影响性能的恩惠。 如果您的“做事”很重要，展开循环将创建此重要代码的多个副本，这将花费额外的时间加载到缓存中，从而显着减慢通过展开循环的第一次迭代。 同时，它将从缓存中逐出更多代码，如果它进行任何函数调用，这些代码可能是执行“做事”所必需的，然后需要再次将其重新加载到缓存中。 在无缓存流水线非分支预测架构之前，展开循环的目的很有意义，其目标是减少与循环逻辑相关的开销。 如今使用基于缓存的流水线分支预测硬件，您的 CPU 将很好地流水线进入下一个循环迭代，推测性地再次执行循环代码，当您检测到 i==end 退出条件时，此时处理器将抛出得出最终推测执行的结果集。 在这样的架构中，循环展开几乎没有意义。 它会进一步膨胀代码而几乎没有任何好处。
解决方案2
8 已采纳 2012-07-17 19:30:52
在我看来，这似乎需要编译器比平时更聪明，首先要推断迭代器是随机访问迭代器，然后计算出循环执行的次数。
STL 完全由模板组成，所有代码都是inline的。 因此，当编译器开始应用优化时，随机访问迭代器已经减少为指针。 创建 STL 的原因之一是程序员不需要以智取编译器。 您应该依靠 STL 来做正确的事情，直到证明不是这样。
当然，你还是要从STL中选择合适的工具来使用……
编辑：讨论过g++是否展开任何循环。 在我使用的版本上，循环展开不是-O 、 -O2或-O3的一部分，我使用以下代码为后两个级别获得相同的程序集：
void foo (std::vector<int> &v) {
volatile int c = 0;
const std::vector<int>::const_iterator end = v.end();
for (std::vector<int>::iterator i = v.begin(); i != end; ++i) {
*i = c++;
}
}
用对应的程序集-O2程序集：
_Z3fooRSt6vectorIiSaIiEE:
.LFB435:
movq 8(%rdi), %rcx
movq (%rdi), %rax
movl $0, -4(%rsp)
cmpq %rax, %rcx
je .L4
.p2align 4,,10
.p2align 3
.L3:
movl -4(%rsp), %edx
movl %edx, (%rax)
addq $4, %rax
addl $1, %edx
cmpq %rax, %rcx
movl %edx, -4(%rsp)
jne .L3
.L4:
rep
ret
通过添加-funroll-loops选项，该函数扩展为更大的东西。 但是，文档警告此选项：
展开循环，其迭代次数可以在编译时或进入循环时确定。 -funroll-loops 表示 -frerun-cse-after-loop。 它还会打开完整的循环剥离（即完全删除具有小常数迭代次数的循环）。 此选项使代码更大，并且可能会或可能不会使其运行得更快。
作为阻止您自己展开循环的进一步论据，我将通过将Duff 的 Device应用于上面的foo函数的示例来结束这个答案：
void foo_duff (std::vector<int> &v) {
volatile int c = 0;
const std::vector<int>::const_iterator end = v.end();
std::vector<int>::iterator i = v.begin();
switch ((end - i) % 4) do {
case 0: *i++ = c++;
case 3: *i++ = c++;
case 2: *i++ = c++;
case 1: *i++ = c++;
} while (i != end);
}
GCC 有另一个循环优化标志：
-ftree-loop-optimize
对树执行循环优化。 默认情况下，此标志在-O和更高级别启用。
因此， -O选项可以对最内层循环进行简单的循环优化，包括对具有固定迭代次数的循环进行完整的循环展开（剥离）。 （感谢医生向我指出这一点。）
解决方案3
1 2012-07-17 18:58:44
简短的回答是肯定的。 它会尽可能多地展开。 在您的情况下，这显然取决于您如何定义end （我假设您的示例是通用的）。 大多数现代编译器不仅会展开，而且还会矢量化和进行其他优化，这些优化通常会使您自己的解决方案一败涂地。
所以我要说的是不要过早地优化：开个玩笑 :)
解决方案4
1 2014-11-30 09:31:57
简单的回答：一般不会！ 至少在涉及到完整的循环展开时。
让我们在这个简单的脏代码（用于测试目的）结构上测试循环展开。
struct Test
{
Test(): begin(arr), end(arr + 4) {}
double * begin;
double * end;
double arr[4];
};
首先让我们采用计数循环并在不进行任何优化的情况下编译它。
double counted(double param, Test & d)
{
for (int i = 0; i < 4; i++)
param += d.arr[i];
return param;
}
这是 gcc 4.9 生成的内容。
counted(double, Test&):
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -24(%rbp)
movq %rdi, -32(%rbp)
movl $0, -4(%rbp)
jmp .L2
.L3:
movq -32(%rbp), %rax
movl -4(%rbp), %edx
movslq %edx, %rdx
addq $2, %rdx
movsd (%rax,%rdx,8), %xmm0
movsd -24(%rbp), %xmm1
addsd %xmm0, %xmm1
movq %xmm1, %rax
movq %rax, -24(%rbp)
addl $1, -4(%rbp)
.L2:
cmpl $3, -4(%rbp)
jle .L3
movq -24(%rbp), %rax
movq %rax, -40(%rbp)
movsd -40(%rbp), %xmm0
popq %rbp
ret
正如预期的那样，循环还没有展开，而且由于没有执行任何优化，代码通常非常冗长。 现在让我们打开-O3标志。 产生的反汇编：
counted(double, Test&):
addsd 16(%rdi), %xmm0
addsd 24(%rdi), %xmm0
addsd 32(%rdi), %xmm0
addsd 40(%rdi), %xmm0
ret
瞧，这次循环已经展开。
现在让我们看一下迭代循环。 包含循环的函数将如下所示。
double iterated(double param, Test & d)
{
for (double * it = d.begin; it != d.end; ++it)
param += *it;
return param;
}
仍然使用-O3标志，让我们看一下反汇编。
iterated(double, Test&):
movq (%rdi), %rax
movq 8(%rdi), %rdx
cmpq %rdx, %rax
je .L3
.L4:
addsd (%rax), %xmm0
addq $8, %rax
cmpq %rdx, %rax
jne .L4
.L3:
rep ret
代码看起来比第一种情况更好，因为执行了优化，但这次循环还没有展开！
funroll-loops和funroll-all-loops标志怎么样？ 他们将产生类似于此的结果
iterated(double, Test&):
movq (%rdi), %rsi
movq 8(%rdi), %rcx
cmpq %rcx, %rsi
je .L3
movq %rcx, %rdx
leaq 8(%rsi), %rax
addsd (%rsi), %xmm0
subq %rsi, %rdx
subq $8, %rdx
shrq $3, %rdx
andl $7, %edx
cmpq %rcx, %rax
je .L43
testq %rdx, %rdx
je .L4
cmpq $1, %rdx
je .L29
cmpq $2, %rdx
je .L30
cmpq $3, %rdx
je .L31
cmpq $4, %rdx
je .L32
cmpq $5, %rdx
je .L33
cmpq $6, %rdx
je .L34
addsd (%rax), %xmm0
leaq 16(%rsi), %rax
.L34:
addsd (%rax), %xmm0
addq $8, %rax
.L33:
addsd (%rax), %xmm0
addq $8, %rax
.L32:
addsd (%rax), %xmm0
addq $8, %rax
.L31:
addsd (%rax), %xmm0
addq $8, %rax
.L30:
addsd (%rax), %xmm0
addq $8, %rax
.L29:
addsd (%rax), %xmm0
addq $8, %rax
cmpq %rcx, %rax
je .L44
.L4:
addsd (%rax), %xmm0
addq $64, %rax
addsd -56(%rax), %xmm0
addsd -48(%rax), %xmm0
addsd -40(%rax), %xmm0
addsd -32(%rax), %xmm0
addsd -24(%rax), %xmm0
addsd -16(%rax), %xmm0
addsd -8(%rax), %xmm0
cmpq %rcx, %rax
jne .L4
.L3:
rep ret
.L44:
rep ret
.L43:
rep ret
将结果与展开循环的计数循环进行比较。 这显然不一样。 我们在这里看到的是 gcc 将循环分成 8 个元素块。 这在某些情况下可以提高性能，因为每 8 次正常循环迭代检查一次循环退出条件。 还可以执行附加标志矢量化。 但这不是完整的循环展开。
但是，如果Test对象不是函数参数，迭代循环将展开。
double iteratedLocal(double param)
{
Test d;
for (double * it = d.begin; it != d.end; ++it)
param += *it;
return param;
}
仅使用-O3标志生成的反汇编：
iteratedLocal(double):
addsd -40(%rsp), %xmm0
addsd -32(%rsp), %xmm0
addsd -24(%rsp), %xmm0
addsd -16(%rsp), %xmm0
ret
如您所见，循环已展开。 这是因为编译器现在可以安全地假设end具有固定值，而它无法预测函数参数。
然而， Test结构是静态分配的。 对于std::vector之类的动态分配结构，事情变得更加复杂。 根据我对修改后的Test结构的观察，使其重新组合为动态分配的容器，看起来 gcc 会尽力展开循环，但在大多数情况下生成的代码并不像上面的代码那么简单。
当您要求其他编译器时，这里是 clang 3.4.1 的输出（ -O3标志）
counted(double, Test&): # @counted(double, Test&)
addsd 16(%rdi), %xmm0
addsd 24(%rdi), %xmm0
addsd 32(%rdi), %xmm0
addsd 40(%rdi), %xmm0
ret
iterated(double, Test&): # @iterated(double, Test&)
movq (%rdi), %rax
movq 8(%rdi), %rcx
cmpq %rcx, %rax
je .LBB1_2
.LBB1_1: # %.lr.ph
addsd (%rax), %xmm0
addq $8, %rax
cmpq %rax, %rcx
jne .LBB1_1
.LBB1_2: # %._crit_edge
ret
iteratedLocal(double): # @iteratedLocal(double)
leaq -32(%rsp), %rax
movq %rax, -48(%rsp)
leaq (%rsp), %rax
movq %rax, -40(%rsp)
xorl %eax, %eax
jmp .LBB2_1
.LBB2_2: # %._crit_edge4
movsd -24(%rsp,%rax), %xmm1
addq $8, %rax
.LBB2_1: # =>This Inner Loop Header: Depth=1
movaps %xmm0, %xmm2
cmpq $24, %rax
movaps %xmm1, %xmm0
addsd %xmm2, %xmm0
jne .LBB2_2
ret
英特尔的 icc 13.01（ -O3标志）
counted(double, Test&):
addsd 16(%rdi), %xmm0 #24.5
addsd 24(%rdi), %xmm0 #24.5
addsd 32(%rdi), %xmm0 #24.5
addsd 40(%rdi), %xmm0 #24.5
ret #25.10
iterated(double, Test&):
movq (%rdi), %rdx #30.26
movq 8(%rdi), %rcx #30.41
cmpq %rcx, %rdx #30.41
je ..B3.25 # Prob 50% #30.41
subq %rdx, %rcx #30.7
movb $0, %r8b #30.7
lea 7(%rcx), %rax #30.7
sarq $2, %rax #30.7
shrq $61, %rax #30.7
lea 7(%rax,%rcx), %rcx #30.7
sarq $3, %rcx #30.7
cmpq $16, %rcx #30.7
jl ..B3.26 # Prob 10% #30.7
movq %rdx, %rdi #30.7
andq $15, %rdi #30.7
je ..B3.6 # Prob 50% #30.7
testq $7, %rdi #30.7
jne ..B3.26 # Prob 10% #30.7
movl $1, %edi #30.7
..B3.6: # Preds ..B3.5 ..B3.3
lea 16(%rdi), %rax #30.7
cmpq %rax, %rcx #30.7
jl ..B3.26 # Prob 10% #30.7
movq %rcx, %rax #30.7
xorl %esi, %esi #30.7
subq %rdi, %rax #30.7
andq $15, %rax #30.7
negq %rax #30.7
addq %rcx, %rax #30.7
testq %rdi, %rdi #30.7
jbe ..B3.11 # Prob 2% #30.7
..B3.9: # Preds ..B3.7 ..B3.9
addsd (%rdx,%rsi,8), %xmm0 #31.9
incq %rsi #30.7
cmpq %rdi, %rsi #30.7
jb ..B3.9 # Prob 82% #30.7
..B3.11: # Preds ..B3.9 ..B3.7
pxor %xmm6, %xmm6 #28.12
movaps %xmm6, %xmm7 #28.12
movaps %xmm6, %xmm5 #28.12
movsd %xmm0, %xmm7 #28.12
movaps %xmm6, %xmm4 #28.12
movaps %xmm6, %xmm3 #28.12
movaps %xmm6, %xmm2 #28.12
movaps %xmm6, %xmm1 #28.12
movaps %xmm6, %xmm0 #28.12
..B3.12: # Preds ..B3.12 ..B3.11
addpd (%rdx,%rdi,8), %xmm7 #31.9
addpd 16(%rdx,%rdi,8), %xmm6 #31.9
addpd 32(%rdx,%rdi,8), %xmm5 #31.9
addpd 48(%rdx,%rdi,8), %xmm4 #31.9
addpd 64(%rdx,%rdi,8), %xmm3 #31.9
addpd 80(%rdx,%rdi,8), %xmm2 #31.9
addpd 96(%rdx,%rdi,8), %xmm1 #31.9
addpd 112(%rdx,%rdi,8), %xmm0 #31.9
addq $16, %rdi #30.7
cmpq %rax, %rdi #30.7
jb ..B3.12 # Prob 82% #30.7
addpd %xmm6, %xmm7 #28.12
addpd %xmm4, %xmm5 #28.12
addpd %xmm2, %xmm3 #28.12
addpd %xmm0, %xmm1 #28.12
addpd %xmm5, %xmm7 #28.12
addpd %xmm1, %xmm3 #28.12
addpd %xmm3, %xmm7 #28.12
movaps %xmm7, %xmm0 #28.12
unpckhpd %xmm7, %xmm0 #28.12
addsd %xmm0, %xmm7 #28.12
movaps %xmm7, %xmm0 #28.12
..B3.14: # Preds ..B3.13 ..B3.26
lea 1(%rax), %rsi #30.7
cmpq %rsi, %rcx #30.7
jb ..B3.25 # Prob 50% #30.7
subq %rax, %rcx #30.7
cmpb $1, %r8b #30.7
jne ..B3.17 # Prob 50% #30.7
..B3.16: # Preds ..B3.17 ..B3.15
xorl %r8d, %r8d #30.7
jmp ..B3.21 # Prob 100% #30.7
..B3.17: # Preds ..B3.15
cmpq $2, %rcx #30.7
jl ..B3.16 # Prob 10% #30.7
movq %rcx, %r8 #30.7
xorl %edi, %edi #30.7
pxor %xmm1, %xmm1 #28.12
lea (%rdx,%rax,8), %rsi #31.19
andq $-2, %r8 #30.7
movsd %xmm0, %xmm1 #28.12
..B3.19: # Preds ..B3.19 ..B3.18
addpd (%rsi,%rdi,8), %xmm1 #31.9
addq $2, %rdi #30.7
cmpq %r8, %rdi #30.7
jb ..B3.19 # Prob 82% #30.7
movaps %xmm1, %xmm0 #28.12
unpckhpd %xmm1, %xmm0 #28.12
addsd %xmm0, %xmm1 #28.12
movaps %xmm1, %xmm0 #28.12
..B3.21: # Preds ..B3.20 ..B3.16
cmpq %rcx, %r8 #30.7
jae ..B3.25 # Prob 2% #30.7
lea (%rdx,%rax,8), %rax #31.19
..B3.23: # Preds ..B3.23 ..B3.22
addsd (%rax,%r8,8), %xmm0 #31.9
incq %r8 #30.7
cmpq %rcx, %r8 #30.7
jb ..B3.23 # Prob 82% #30.7
..B3.25: # Preds ..B3.23 ..B3.21 ..B3.14 ..B3.1
ret #32.14
..B3.26: # Preds ..B3.2 ..B3.6 ..B3.4 # Infreq
movb $1, %r8b #30.7
xorl %eax, %eax #30.7
jmp ..B3.14 # Prob 100% #30.7
iteratedLocal(double):
lea -8(%rsp), %rax #8.13
lea -40(%rsp), %rdx #7.11
cmpq %rax, %rdx #33.41
je ..B4.15 # Prob 50% #33.41
movq %rax, -48(%rsp) #32.12
movq %rdx, -56(%rsp) #32.12
xorl %eax, %eax #33.7
..B4.13: # Preds ..B4.11 ..B4.13
addsd -40(%rsp,%rax,8), %xmm0 #34.9
incq %rax #33.7
cmpq $4, %rax #33.7
jb ..B4.13 # Prob 82% #33.7
..B4.15: # Preds ..B4.13 ..B4.1
ret #35.14
以免误会。 如果计数循环条件将依赖于外部参数，就像这样。
double countedDep(double param, Test & d)
{
for (int i = 0; i < d.size; i++)
param += d.arr[i];
return param;
}
这样的循环也不会展开。
现代编译器可以在使用依赖注入时将函数调用去虚拟化吗
[英]Can modern compilers devirtualize function calls when using dependency injection
我可以告诉nvcc将#pragma展开应用于函数中的所有循环吗？
[英]Can I tell nvcc to apply #pragma unroll to all loops in a function?
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.