为什么这个C ++函数会产生如此多的分支错误预测？
[英]Why does this C++ function produce so many branch mispredictions?
问题描述
设A是包含奇数个零和1的数组。 如果n是A的大小，则构造A使得第一ceil(n/2)元素为0并且剩余元素为1 。
因此，如果n = 9 ， A将如下所示：
0,0,0,0,0,1,1,1,1
我们的目标是要找到的总和1s数组中，我们使用该功能来做到这一点：
s = 0;
void test1(int curIndex){
//A is 0,0,0,...,0,1,1,1,1,1...,1
if(curIndex == ceil(n/2)) return;
if(A[curIndex] == 1) return;
test1(curIndex+1);
test1(size-curIndex-1);
s += A[curIndex+1] + A[size-curIndex-1];
}
对于给出的问题，这个函数相当愚蠢，但它是一个不同函数的模拟，我希望看起来像这样，并产生相同数量的分支误预测。
以下是整个实验代码：
#include <iostream>
#include <fstream>
using namespace std;
int size;
int *A;
int half;
int s;
void test1(int curIndex){
//A is 0,0,0,...,0,1,1,1,1,1...,1
if(curIndex == half) return;
if(A[curIndex] == 1) return;
test1(curIndex+1);
test1(size - curIndex - 1);
s += A[curIndex+1] + A[size-curIndex-1];
}
int main(int argc, char* argv[]){
size = atoi(argv[1]);
if(argc!=2){
cout<<"type ./executable size{odd integer}"<<endl;
return 1;
}
if(size%2!=1){
cout<<"size must be an odd number"<<endl;
return 1;
}
A = new int[size];
half = size/2;
int i;
for(i=0;i<=half;i++){
A[i] = 0;
}
for(i=half+1;i<size;i++){
A[i] = 1;
}
for(i=0;i<100;i++) {
test1(0);
}
cout<<s<<endl;
return 0;
}
通过键入g++ -O3 -std=c++11 file.cpp ，然后输入./executable size{odd integer} 。
我正在使用Intel（R）Core（TM）i5-3470 CPU @ 3.20GHz，8 GB RAM，L1缓存256 KB，L2缓存1 MB，L3缓存6 MB。
运行perf stat -B -e branches,branch-misses ./cachetests 111111给出了以下内容：
Performance counter stats for './cachetests 111111':
32,639,932 branches
1,404,836 branch-misses # 4.30% of all branches
0.060349641 seconds time elapsed
如果我删除该行
s += A[curIndex+1] + A[size-curIndex-1];
我从perf得到以下输出：
Performance counter stats for './cachetests 111111':
24,079,109 branches
39,078 branch-misses # 0.16% of all branches
0.027679521 seconds time elapsed
当它甚至不是if语句时，该行与分支预测有什么关系？
我看到它的方式，在第一个ceil(n/2) - 1调用test1() ，两个if语句都将为false。 在ceil(n/2)-th调用中， if(curIndex == ceil(n/2))将为真。 在剩余的n-ceil(n/2)调用中，第一个语句将为false，第二个语句将为true。
为什么英特尔无法预测这么简单的行为？
现在让我们看看第二种情况。 假设A现在有交替的零和1。 我们将始终从0开始。因此，如果n = 9 A将如下所示：
0,1,0,1,0,1,0,1,0
我们将要使用的功能如下：
void test2(int curIndex){
//A is 0,1,0,1,0,1,0,1,....
if(curIndex == size-1) return;
if(A[curIndex] == 1) return;
test2(curIndex+1);
test2(curIndex+2);
s += A[curIndex+1] + A[curIndex+2];
}
以下是整个实验代码：
#include <iostream>
#include <fstream>
using namespace std;
int size;
int *A;
int s;
void test2(int curIndex){
//A is 0,1,0,1,0,1,0,1,....
if(curIndex == size-1) return;
if(A[curIndex] == 1) return;
test2(curIndex+1);
test2(curIndex+2);
s += A[curIndex+1] + A[curIndex+2];
}
int main(int argc, char* argv[]){
size = atoi(argv[1]);
if(argc!=2){
cout<<"type ./executable size{odd integer}"<<endl;
return 1;
}
if(size%2!=1){
cout<<"size must be an odd number"<<endl;
return 1;
}
A = new int[size];
int i;
for(i=0;i<size;i++){
if(i%2==0){
A[i] = false;
}
else{
A[i] = true;
}
}
for(i=0;i<100;i++) {
test2(0);
}
cout<<s<<endl;
return 0;
}
我使用与以前相同的命令运行perf：
Performance counter stats for './cachetests2 111111':
28,560,183 branches
54,204 branch-misses # 0.19% of all branches
0.037134196 seconds time elapsed
删除该行再次改善了一些事情：
Performance counter stats for './cachetests2 111111':
28,419,557 branches
16,636 branch-misses # 0.06% of all branches
0.009977772 seconds time elapsed
现在，如果我们分析函数， if(curIndex == size-1)将为n-1次，并且if(A[curIndex] == 1)将从true切换为false。
在我看来，两个函数都应该很容易预测，但第一个函数不是这种情况。 与此同时，我不确定该行发生了什么，以及为什么它在改善分支行为方面发挥作用。
5 个解决方案
解决方案1
25 已采纳 2016-09-23 07:08:51
在盯着它看了一会儿之后，我对此有了一些看法。 首先，使用-O2可以很容易地重现该问题，因此最好将其用作参考，因为它生成易于分析的简单的非展开代码。 -O3的问题本质上是相同的，它只是不太明显。
因此，对于第一种情况（带有半模式的半零），编译器会生成以下代码：
0000000000400a80 <_Z5test1i>:
400a80: 55 push %rbp
400a81: 53 push %rbx
400a82: 89 fb mov %edi,%ebx
400a84: 48 83 ec 08 sub $0x8,%rsp
400a88: 3b 3d 0e 07 20 00 cmp 0x20070e(%rip),%edi #
60119c <half>
400a8e: 74 4f je 400adf <_Z5test1i+0x5f>
400a90: 48 8b 15 09 07 20 00 mov 0x200709(%rip),%rdx #
6011a0 <A>
400a97: 48 63 c7 movslq %edi,%rax
400a9a: 48 8d 2c 85 00 00 00 lea 0x0(,%rax,4),%rbp
400aa1: 00
400aa2: 83 3c 82 01 cmpl $0x1,(%rdx,%rax,4)
400aa6: 74 37 je 400adf <_Z5test1i+0x5f>
400aa8: 8d 7f 01 lea 0x1(%rdi),%edi
400aab: e8 d0 ff ff ff callq 400a80 <_Z5test1i>
400ab0: 89 df mov %ebx,%edi
400ab2: f7 d7 not %edi
400ab4: 03 3d ee 06 20 00 add 0x2006ee(%rip),%edi #
6011a8 <size>
400aba: e8 c1 ff ff ff callq 400a80 <_Z5test1i>
400abf: 8b 05 e3 06 20 00 mov 0x2006e3(%rip),%eax #
6011a8 <size>
400ac5: 48 8b 15 d4 06 20 00 mov 0x2006d4(%rip),%rdx #
6011a0 <A>
400acc: 29 d8 sub %ebx,%eax
400ace: 48 63 c8 movslq %eax,%rcx
400ad1: 8b 44 2a 04 mov 0x4(%rdx,%rbp,1),%eax
400ad5: 03 44 8a fc add -0x4(%rdx,%rcx,4),%eax
400ad9: 01 05 b9 06 20 00 add %eax,0x2006b9(%rip) #
601198 <s>
400adf: 48 83 c4 08 add $0x8,%rsp
400ae3: 5b pop %rbx
400ae4: 5d pop %rbp
400ae5: c3 retq
400ae6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
400aed: 00 00 00
非常简单，有点你期望的 - 两个条件分支，两个调用。 它给了我们关于Core 2 Duo T6570，AMD Phenom II X4 925和Core i7-4770的这个（或类似的）统计数据：
$ perf stat -B -e branches,branch-misses ./a.out 111111
5555500
Performance counter stats for './a.out 111111':
45,216,754 branches
5,588,484 branch-misses # 12.36% of all branches
0.098535791 seconds time elapsed
如果您要进行此更改，请在递归调用之前移动分配：
--- file.cpp.orig 2016-09-22 22:59:20.744678438 +0300
+++ file.cpp 2016-09-22 22:59:36.492583925 +0300
@@ -15,10 +15,10 @@
if(curIndex == half) return;
if(A[curIndex] == 1) return;
+ s += A[curIndex+1] + A[size-curIndex-1];
test1(curIndex+1);
test1(size - curIndex - 1);
- s += A[curIndex+1] + A[size-curIndex-1];
}
图片变化：
$ perf stat -B -e branches,branch-misses ./a.out 111111
5555500
Performance counter stats for './a.out 111111':
39,495,804 branches
54,430 branch-misses # 0.14% of all branches
0.039522259 seconds time elapsed
是的，正如已经指出的那样，它与尾递归优化直接相关，因为如果你要使用-fno-optimize-sibling-calls编译修补代码，你将得到相同的“坏”结果。 那么让我们来看看我们在尾部调用优化的汇编中有什么：
0000000000400a80 <_Z5test1i>:
400a80: 3b 3d 16 07 20 00 cmp 0x200716(%rip),%edi #
60119c <half>
400a86: 53 push %rbx
400a87: 89 fb mov %edi,%ebx
400a89: 74 5f je 400aea <_Z5test1i+0x6a>
400a8b: 48 8b 05 0e 07 20 00 mov 0x20070e(%rip),%rax #
6011a0 <A>
400a92: 48 63 d7 movslq %edi,%rdx
400a95: 83 3c 90 01 cmpl $0x1,(%rax,%rdx,4)
400a99: 74 4f je 400aea <_Z5test1i+0x6a>
400a9b: 8b 0d 07 07 20 00 mov 0x200707(%rip),%ecx #
6011a8 <size>
400aa1: eb 15 jmp 400ab8 <_Z5test1i+0x38>
400aa3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
400aa8: 48 8b 05 f1 06 20 00 mov 0x2006f1(%rip),%rax #
6011a0 <A>
400aaf: 48 63 d3 movslq %ebx,%rdx
400ab2: 83 3c 90 01 cmpl $0x1,(%rax,%rdx,4)
400ab6: 74 32 je 400aea <_Z5test1i+0x6a>
400ab8: 29 d9 sub %ebx,%ecx
400aba: 8d 7b 01 lea 0x1(%rbx),%edi
400abd: 8b 54 90 04 mov 0x4(%rax,%rdx,4),%edx
400ac1: 48 63 c9 movslq %ecx,%rcx
400ac4: 03 54 88 fc add -0x4(%rax,%rcx,4),%edx
400ac8: 01 15 ca 06 20 00 add %edx,0x2006ca(%rip) #
601198 <s>
400ace: e8 ad ff ff ff callq 400a80 <_Z5test1i>
400ad3: 8b 0d cf 06 20 00 mov 0x2006cf(%rip),%ecx #
6011a8 <size>
400ad9: 89 c8 mov %ecx,%eax
400adb: 29 d8 sub %ebx,%eax
400add: 89 c3 mov %eax,%ebx
400adf: 83 eb 01 sub $0x1,%ebx
400ae2: 39 1d b4 06 20 00 cmp %ebx,0x2006b4(%rip) #
60119c <half>
400ae8: 75 be jne 400aa8 <_Z5test1i+0x28>
400aea: 5b pop %rbx
400aeb: c3 retq
400aec: 0f 1f 40 00 nopl 0x0(%rax)
它有四个条件分支，一个调用。 那么让我们分析一下到目前为止我们得到的数据。
首先，从处理器的角度来看，什么是分支指令？ 它是call ， ret ， j* （包括直接jmp ）和loop 。 call和jmp有点不直观，但它们对于正确计算事物至关重要。
总的来说，我们希望这个函数被称为11111100次，每个元素一个，大约是11M。 在非尾部调用优化版本中，我们看到大约45M分支，main（）中的初始化仅为111K，所有其他东西都是次要的，因此对此数字的主要贡献来自我们的函数。 我们的函数是call -ed，它计算第一个je ，除了一个之外在所有情况下都是真的，然后它计算第二个je ，这是真正的一半时间，然后它要么递归调用自己（但我们已经计算过了）该函数被调用了11M次）或返回（就像在递归调用之后那样。因此，每11M调用就有4个分支指令，正好是我们看到的数字。这些错过了大约5.5M的分支，这表明这些错过都来了从一个错误预测的指令，要么被评估了11M次并且错过了大约50％的时间，要么被评估了一半的时间并且总是错过了。
我们在尾部调用优化版本中有什么作用？ 我们有大约5.5M次调用的函数，但现在每次调用都会产生一次call ，最初有两个分支（第一个在所有情况下都是真的，除了一个，第二个因为我们的数据总是假的），然后是一个jmp ，然后是调用（但我们已经知道我们有5.5M调用），然后是400ae8的分支和400ab6处的分支（由于我们的数据总是为真），然后返回。 因此，平均而言，四个条件分支，一个无条件跳转，一个调用和一个间接分支（从函数返回），5.5M乘以7给出了大约39M分支的总计数，正如我们在perf输出中看到的那样。
我们所知道的是，处理器在使用一个函数调用来预测流中的事物没有任何问题（即使这个版本有更多的条件分支），并且它有两个函数调用的问题。 所以它表明问题在于函数的回报。
不幸的是，我们对现代处理器的分支预测器的工作原理的细节知之甚少。 我能找到的最好的分析就是这个 ，它表明处理器有一个大约16个条目的返回堆栈缓冲区。 如果我们再次使用这一发现再次回到我们的数据，事情就会开始澄清一点。
当你有半个半模式的半零时，你会非常深入地test1(curIndex+1)到test1(curIndex+1) ，但是你开始返回并调用test1(size-curIndex-1) 。 该递归永远不会比一次调用更深，因此可以完美地预测回报。 但请记住，我们现在已经进行了55555次深度调用，处理器只记得16级，因此它无法从55539级深度猜测我们的回报也就不足为奇了，更令人惊讶的是它可以通过尾部调用来实现 - 优化版。
实际上，尾部调用优化版本的行为表明缺少关于返回的任何其他信息，处理器只是假设正确的一个是最后看到的。 非尾调用优化版本的行为也证明了这一点，因为它在test1(curIndex+1)深入55555次调用，然后在返回时它总是在test1(size-curIndex-1)深入一级，所以当我们从55555深度到55539深度（或任何你的处理器返回缓冲区）时，它调用test1(size-curIndex-1) ，从那里返回并且它完全没有关于下一个返回的信息，所以它假设我们要返回到最后看到的地址（这是从test1(size-curIndex-1)返回的地址test1(size-curIndex-1) ），这显然是错误的。 55539次错了。 使用100个循环的函数，这正是我们看到的5.5M分支预测错过。
现在让我们来看看你的交替模式和代码。 这个代码实际上是非常不同的，如果你要分析它是如何进入深度的。 在这里，你的test2(curIndex+1) 总是立即返回，你的test2(curIndex+2) 总是更深。 因此， test2(curIndex+1)的返回总是完美地预测（它们只是不够深入），当我们完成递归到test2(curIndex+2) ，它总是返回到同一点，所有55555次，所以处理器没有问题。
这可以通过对半原始代码的原始半零的这一小改动来进一步证明：
--- file.cpp.orig 2016-09-23 11:00:26.917977032 +0300
+++ file.cpp 2016-09-23 11:00:31.946027451 +0300
@@ -15,8 +15,8 @@
if(curIndex == half) return;
if(A[curIndex] == 1) return;
- test1(curIndex+1);
test1(size - curIndex - 1);
+ test1(curIndex+1);
s += A[curIndex+1] + A[size-curIndex-1];
所以现在生成的代码仍然不是尾部调用优化的（在程序方面它与原始代码非常相似），但是你在perf输出中得到这样的东西：
$ perf stat -B -e branches,branch-misses ./a.out 111111
5555500
Performance counter stats for './a.out 111111':
45 308 579 branches
75 927 branch-misses # 0,17% of all branches
0,026271402 seconds time elapsed
正如预期的那样，现在我们的第一个呼叫总是立即返回，第二个呼叫变为55555深，然后只返回到同一个点。
现在解决了这个让我展示一些东西。 在一个系统上，即Core i5-5200U，具有半个版本的非尾部调用优化的原始半零显示了以下结果：
$ perf stat -B -e branches,branch-misses ./a.out 111111
5555500
Performance counter stats for './a.out 111111':
45 331 670 branches
16 349 branch-misses # 0,04% of all branches
0,043351547 seconds time elapsed
因此，显然，Broadwell可以轻松处理这种模式，这使我们回到了我们对现代处理器的分支预测逻辑了解多少的问题。
解决方案2
4 2016-09-21 14:45:39
删除行s += A[curIndex+1] + A[size-curIndex-1]; 启用尾递归优化 。 只有在递归调用位于函数的最后一行时才会发生此优化。
解决方案3
3 2016-09-21 22:13:58
有趣的是，在第一次执行中，你的分支比第二次执行多30％（32M分支对24个Mbranches）。
我已经使用gcc 4.8.5和相同的标志（加上-S ）为您的应用程序生成了汇编代码，并且程序集之间存在显着差异。 具有冲突语句的代码大约是572行，而没有相同语句的代码只有409行。 专注于符号_Z5test1i - test1的装饰C ++名称，例程长367行，而第二种情况仅占202行。 从所有这些行开始，第一个案例包含36个分支（加上15个呼叫指令），第二个案例包含34个分支（加上1个呼叫指令）。
同样有趣的是，使用-O1编译应用程序并不会暴露两个版本之间的这种差异（尽管分支误预测更高，大约12％）。 使用-O2显示两个版本之间的差异（12％对3％的分支误预测）。
我不是编译器专家来理解编译器使用的控制流和逻辑，但看起来编译器能够实现更智能的优化（可能包括用户1850903在他的答案中指出的尾递归优化）代码不存在。
解决方案4
3 2016-09-21 22:49:05
问题是这样的：
if(A[curIndex] == 1) return;
由于一些优化，测试函数的每次调用都交替进行这种比较的结果，因为数组是例如0,0,0,0,0,1,1,1,1
换一种说法：
- curIndex = 0 - > A [0] = 0
- test1（curIndex + 1） - > curIndex = 1 - > A [1] = 0
但是，处理器架构MIGHT （一个很大的因素，因为它取决于我;优化被禁用 - 一个i5-6400）有一个叫做runahead的功能（沿着分支预测执行），它在进入之前执行管道中的剩余指令分店; 所以它会在违规的if语句之前执行test1(size - curIndex -1) 。
当删除属性时，它会进入另一个优化，如用户1850903所说。
解决方案5
3 2016-09-21 23:39:44
下面的代码是尾递归的：函数的最后一行不需要调用，只是一个分支到函数以第一个参数开始的点：
void f(int i) {
if (i == size) break;
s += a[i];
f(i + 1);
}
但是，如果我们打破这个并使其非尾递归：
void f(int i) {
if (i == size) break;
f(i + 1);
s += a[i];
}
编译器无法推断后者是尾递归的原因有很多，但在您给出的示例中，
test(A[N]);
test(A[M]);
s += a[N] + a[M];
同样的规则适用。 编译器无法确定这是尾递归，但更多因为两次调用而无法执行此操作（请参阅之前和之后 ）。
你似乎期望编译器对此做的是一个执行几个简单条件分支，两个调用和一些加载/添加/存储的函数。
相反，编译器正在展开此循环并生成具有大量分支点的代码。 这部分是因为编译器认为这种方式更有效（涉及更少的分支），但部分原因是它减少了运行时递归深度。
int size;
int* A;
int half;
int s;
void test1(int curIndex){
if(curIndex == half || A[curIndex] == 1) return;
test1(curIndex+1);
test1(size-curIndex-1);
s += A[curIndex+1] + A[size-curIndex-1];
}
生产：
test1(int):
movl half(%rip), %edx
cmpl %edi, %edx
je .L36
pushq %r15
pushq %r14
movslq %edi, %rcx
pushq %r13
pushq %r12
leaq 0(,%rcx,4), %r12
pushq %rbp
pushq %rbx
subq $24, %rsp
movq A(%rip), %rax
cmpl $1, (%rax,%rcx,4)
je .L1
leal 1(%rdi), %r13d
movl %edi, %ebp
cmpl %r13d, %edx
je .L42
cmpl $1, 4(%rax,%r12)
je .L42
leal 2(%rdi), %ebx
cmpl %ebx, %edx
je .L39
cmpl $1, 8(%rax,%r12)
je .L39
leal 3(%rdi), %r14d
cmpl %r14d, %edx
je .L37
cmpl $1, 12(%rax,%r12)
je .L37
leal 4(%rdi), %edi
call test1(int)
movl %r14d, %edi
notl %edi
addl size(%rip), %edi
call test1(int)
movl size(%rip), %ecx
movq A(%rip), %rax
movl %ecx, %esi
movl 16(%rax,%r12), %edx
subl %r14d, %esi
movslq %esi, %rsi
addl -4(%rax,%rsi,4), %edx
addl %edx, s(%rip)
movl half(%rip), %edx
.L10:
movl %ecx, %edi
subl %ebx, %edi
leal -1(%rdi), %r14d
cmpl %edx, %r14d
je .L38
movslq %r14d, %rsi
cmpl $1, (%rax,%rsi,4)
leaq 0(,%rsi,4), %r15
je .L38
call test1(int)
movl %r14d, %edi
notl %edi
addl size(%rip), %edi
call test1(int)
movl size(%rip), %ecx
movq A(%rip), %rax
movl %ecx, %edx
movl 4(%rax,%r15), %esi
movl %ecx, %edi
subl %r14d, %edx
subl %ebx, %edi
movslq %edx, %rdx
addl -4(%rax,%rdx,4), %esi
movl half(%rip), %edx
addl s(%rip), %esi
movl %esi, s(%rip)
.L13:
movslq %edi, %rdi
movl 12(%rax,%r12), %r8d
addl -4(%rax,%rdi,4), %r8d
addl %r8d, %esi
movl %esi, s(%rip)
.L7:
movl %ecx, %ebx
subl %r13d, %ebx
leal -1(%rbx), %r14d
cmpl %edx, %r14d
je .L41
movslq %r14d, %rsi
cmpl $1, (%rax,%rsi,4)
leaq 0(,%rsi,4), %r15
je .L41
cmpl %edx, %ebx
je .L18
movslq %ebx, %rsi
cmpl $1, (%rax,%rsi,4)
leaq 0(,%rsi,4), %r8
movq %r8, (%rsp)
je .L18
leal 1(%rbx), %edi
call test1(int)
movl %ebx, %edi
notl %edi
addl size(%rip), %edi
call test1(int)
movl size(%rip), %ecx
movq A(%rip), %rax
movq (%rsp), %r8
movl %ecx, %esi
subl %ebx, %esi
movl 4(%rax,%r8), %edx
movslq %esi, %rsi
addl -4(%rax,%rsi,4), %edx
addl %edx, s(%rip)
movl half(%rip), %edx
.L18:
movl %ecx, %edi
subl %r14d, %edi
leal -1(%rdi), %ebx
cmpl %edx, %ebx
je .L40
movslq %ebx, %rsi
cmpl $1, (%rax,%rsi,4)
leaq 0(,%rsi,4), %r8
je .L40
movq %r8, (%rsp)
call test1(int)
movl %ebx, %edi
notl %edi
addl size(%rip), %edi
call test1(int)
movl size(%rip), %ecx
movq A(%rip), %rax
movq (%rsp), %r8
movl %ecx, %edx
movl %ecx, %edi
subl %ebx, %edx
movl 4(%rax,%r8), %esi
subl %r14d, %edi
movslq %edx, %rdx
addl -4(%rax,%rdx,4), %esi
movl half(%rip), %edx
addl s(%rip), %esi
movl %esi, %r8d
movl %esi, s(%rip)
.L20:
movslq %edi, %rdi
movl 4(%rax,%r15), %esi
movl %ecx, %ebx
addl -4(%rax,%rdi,4), %esi
subl %r13d, %ebx
addl %r8d, %esi
movl %esi, s(%rip)
.L16:
movslq %ebx, %rbx
movl 8(%rax,%r12), %edi
addl -4(%rax,%rbx,4), %edi
addl %edi, %esi
movl %esi, s(%rip)
jmp .L4
.L45:
movl s(%rip), %edx
.L23:
movslq %ebx, %rbx
movl 4(%rax,%r12), %ecx
addl -4(%rax,%rbx,4), %ecx
addl %ecx, %edx
movl %edx, s(%rip)
.L1:
addq $24, %rsp
popq %rbx
popq %rbp
popq %r12
popq %r13
popq %r14
popq %r15
.L36:
rep ret
.L42:
movl size(%rip), %ecx
.L4:
movl %ecx, %ebx
subl %ebp, %ebx
leal -1(%rbx), %r14d
cmpl %edx, %r14d
je .L45
movslq %r14d, %rsi
cmpl $1, (%rax,%rsi,4)
leaq 0(,%rsi,4), %r15
je .L45
cmpl %edx, %ebx
je .L25
movslq %ebx, %rsi
cmpl $1, (%rax,%rsi,4)
leaq 0(,%rsi,4), %r13
je .L25
leal 1(%rbx), %esi
cmpl %edx, %esi
movl %esi, (%rsp)
je .L26
cmpl $1, 8(%rax,%r15)
je .L26
leal 2(%rbx), %edi
call test1(int)
movl (%rsp), %esi
movl %esi, %edi
notl %edi
addl size(%rip), %edi
call test1(int)
movl size(%rip), %ecx
movl (%rsp), %esi
movq A(%rip), %rax
movl %ecx, %edx
subl %esi, %edx
movslq %edx, %rsi
movl 12(%rax,%r15), %edx
addl -4(%rax,%rsi,4), %edx
addl %edx, s(%rip)
movl half(%rip), %edx
.L26:
movl %ecx, %edi
subl %ebx, %edi
leal -1(%rdi), %esi
cmpl %edx, %esi
je .L43
movslq %esi, %r8
cmpl $1, (%rax,%r8,4)
leaq 0(,%r8,4), %r9
je .L43
movq %r9, 8(%rsp)
movl %esi, (%rsp)
call test1(int)
movl (%rsp), %esi
movl %esi, %edi
notl %edi
addl size(%rip), %edi
call test1(int)
movl size(%rip), %ecx
movl (%rsp), %esi
movq A(%rip), %rax
movq 8(%rsp), %r9
movl %ecx, %edx
movl %ecx, %edi
subl %esi, %edx
movl 4(%rax,%r9), %esi
subl %ebx, %edi
movslq %edx, %rdx
addl -4(%rax,%rdx,4), %esi
movl half(%rip), %edx
addl s(%rip), %esi
movl %esi, s(%rip)
.L28:
movslq %edi, %rdi
movl 4(%rax,%r13), %r8d
addl -4(%rax,%rdi,4), %r8d
addl %r8d, %esi
movl %esi, s(%rip)
.L25:
movl %ecx, %r13d
subl %r14d, %r13d
leal -1(%r13), %ebx
cmpl %edx, %ebx
je .L44
movslq %ebx, %rdi
cmpl $1, (%rax,%rdi,4)
leaq 0(,%rdi,4), %rsi
movq %rsi, (%rsp)
je .L44
cmpl %edx, %r13d
je .L33
movslq %r13d, %rdx
cmpl $1, (%rax,%rdx,4)
leaq 0(,%rdx,4), %r8
movq %r8, 8(%rsp)
je .L33
leal 1(%r13), %edi
call test1(int)
movl %r13d, %edi
notl %edi
addl size(%rip), %edi
call test1(int)
movl size(%rip), %ecx
movq A(%rip), %rdi
movq 8(%rsp), %r8
movl %ecx, %edx
subl %r13d, %edx
movl 4(%rdi,%r8), %eax
movslq %edx, %rdx
addl -4(%rdi,%rdx,4), %eax
addl %eax, s(%rip)
.L33:
subl %ebx, %ecx
leal -1(%rcx), %edi
call test1(int)
movl size(%rip), %ecx
movq A(%rip), %rax
movl %ecx, %esi
movl %ecx, %r13d
subl %ebx, %esi
movq (%rsp), %rbx
subl %r14d, %r13d
movslq %esi, %rsi
movl 4(%rax,%rbx), %edx
addl -4(%rax,%rsi,4), %edx
movl s(%rip), %esi
addl %edx, %esi
movl %esi, s(%rip)
.L31:
movslq %r13d, %r13
movl 4(%rax,%r15), %edx
subl %ebp, %ecx
addl -4(%rax,%r13,4), %edx
movl %ecx, %ebx
addl %esi, %edx
movl %edx, s(%rip)
jmp .L23
.L44:
movl s(%rip), %esi
jmp .L31
.L39:
movl size(%rip), %ecx
jmp .L7
.L41:
movl s(%rip), %esi
jmp .L16
.L43:
movl s(%rip), %esi
jmp .L28
.L38:
movl s(%rip), %esi
jmp .L13
.L37:
movl size(%rip), %ecx
jmp .L10
.L40:
movl s(%rip), %r8d
jmp .L20
s:
half:
.zero 4
A:
.zero 8
size:
.zero 4
对于交替值的情况，假设size == 7：
test1(curIndex = 0)
{
if (curIndex == size - 1) return; // false x1
if (A[curIndex] == 1) return; // false x1
test1(curIndex + 1 => 1) {
if (curIndex == size - 1) return; // false x2
if (A[curIndex] == 1) return; // false x1 -mispred-> returns
}
test1(curIndex + 2 => 2) {
if (curIndex == size - 1) return; // false x 3
if (A[curIndex] == 1) return; // false x2
test1(curIndex + 1 => 3) {
if (curIndex == size - 1) return; // false x3
if (A[curIndex] == 1) return; // false x2 -mispred-> returns
}
test1(curIndex + 2 => 4) {
if (curIndex == size - 1) return; // false x4
if (A[curIndex] == 1) return; // false x3
test1(curIndex + 1 => 5) {
if (curIndex == size - 1) return; // false x5
if (A[curIndex] == 1) return; // false x3 -mispred-> returns
}
test1(curIndex + 2 => 6) {
if (curIndex == size - 1) return; // false x5 -mispred-> returns
}
s += A[5] + A[6];
}
s += A[3] + A[4];
}
s += A[1] + A[2];
}
让我们想象一下案例
size = 11;
A[11] = { 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0 };
test1(0)
-> test1(1)
-> test1(2)
-> test1(3) -> returns because 1
-> test1(4)
-> test1(5)
-> test1(6)
-> test1(7) -- returns because 1
-> test1(8)
-> test1(9) -- returns because 1
-> test1(10) -- returns because size-1
-> test1(7) -- returns because 1
-> test1(6)
-> test1(7)
-> test1(8)
-> test1(9) -- 1
-> test1(10) -- size-1
-> test1(3) -> returns
-> test1(2)
... as above
要么
size = 5;
A[5] = { 0, 0, 0, 0, 1 };
test1(0)
-> test1(1)
-> test1(2)
-> test1(3)
-> test1(4) -- size
-> test1(5) -- UB
-> test1(4)
-> test1(3)
-> test1(4) -- size
-> test1(5) -- UB
-> test1(2)
..
您挑选出的两种情况（交替和半模式）是最佳极值，编译器选择了一些中间情况，它将尝试处理最佳。
为什么我的C ++模板化函数不会产生“未声明的已识别”编译错误？
[英]Why my C++ templated function does not produce `undeclared identified` compile error?
为什么vs c ++ 2010编译器为类似函数生成不同的汇编代码
[英]why does vs c++ 2010 compiler produce a different assembly code for similar function
为什么此C ++模板会产生错误，要求缺少分号？
[英]Why does this C++ template produce an error asking for the missing semicolon?
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.