让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，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现在有交替的0和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)将为false n-1次，if(A[curIndex] == 1)将从true变为false。
正如我所看到的，两个函数都应该易于预测，但第一个函数不是这种情况。与此同时，我不确定该行发生了什么，以及为什么它在改善分支行为方面发挥作用。
答案 0 :(得分：25)
在盯着它看了一会儿之后，我对此有了一些看法。首先，
使用-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你会得到相同的＆＃34;坏＆＃34;结果。那么，让我们来吧
看看我们在尾部调用优化的汇编中有什么：
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个分支指令，正是我们看到的数字）在这些错过的大约550万个分支中，这表明这些失误都来自一个错误预测的指令，要么是评估了11M次并且错过了大约50％的时间，要么是评估了一半时间总是错过了。
我们在尾部调用优化版本中有什么作用？我们有一个叫做的函数
大约5.5M次，但是现在每个调用都会产生一个call，最初有两个分支（第一个在所有情况下都是真的，除了一个，第二个因为我们的数据总是假的），然后是jmp ，然后是一个电话（但我们已经计算过我们有5.5M的电话），然后是400ae8的分支和400ab6的分支（由于我们的数据，总是为真），然后返回。因此，平均而言，四个条件分支，一个无条件跳转，一个调用和一个间接分支（从函数返回），5.5M乘以7给我们一个大约39M分支的总计数，正如我们在perf中看到的那样输出
我们所知道的是，处理器在使用一个函数调用来预测流中的事情是没有问题的（即使这个版本有更多的条件分支），并且它有两个函数调用的问题。所以它表明问题在于函数的返回。
不幸的是，我们对如何精确分支的细节知之甚少 我们现代处理器的预测器工作。我能找到的最佳分析 is this它表明处理器有一个大约16个条目的返回堆栈缓冲区。如果我们再次使用这一发现重新回到我们的数据，事情就会开始澄清一点。
当你有半个半模式的半零时，你就会重复非常
深入到test1(curIndex+1)，然后你开始回来了
致电test1(size-curIndex-1)。那个递归从不比一个更深
打电话，所以回报是完美的预测。但请记住，我们是
现在55555深度调用，处理器只记得16，所以它
毫不奇怪它无法从55539级开始猜测我们的回报，
更令人惊讶的是它可以通过尾部调用优化版本来实现。
实际上，尾部调用优化版本的行为表明缺少
关于退货的任何其他信息，处理器只是假设正确
一个是最后一个看到的。它的行为也证明了这一点
非尾部调用优化版本，因为它深入55555调用
test1(curIndex+1)然后在返回时它总是深入到一级
test1(size-curIndex-1)，所以当我们从55555深到55539深（或者
无论你的处理器返回缓冲区是什么）它都会调用
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可以轻松处理这种模式，这将使我们回归 我们对分支预测逻辑了解多少的问题 现代处理器。
答案 1 :(得分：4)
删除行s += A[curIndex+1] + A[size-curIndex-1];可启用尾递归优化。
只有在递归调用位于函数的最后一行时才能进行此优化。
答案 2 :(得分：3)
有趣的是，在第一次执行中，你的分支比第二次执行多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在其答案中指出的尾递归优化）当代码的那部分不存在时。
答案 3 :(得分：3)
问题是：
if(A[curIndex] == 1) return;
由于一些优化，测试函数的每次调用都会交替进行此比较的结果，因为数组是，例如0,0,0,0,0,1,1,1,1
换句话说：
然而，处理器架构可能（一个很大的因素，因为它取决于我;优化被禁用 - 一个i5-6400）有一个名为 runahead 的功能（沿分支预测执行），在进入分支之前执行管道中的剩余指令;所以它会在违规的if语句之前执行test1(size - curIndex -1)。
删除归因后，它会进入另一个优化，如用户1850903所说。
答案 4 :(得分：3)
以下代码是尾递归的：函数的最后一行不需要调用，只是一个分支到函数以第一个参数开始的点：
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];
适用相同的规则。编译器无法确定这是尾递归，但更多因为两次调用而无法执行此操作（请参阅before和after）。
你似乎期望编译器对此做的是一个执行几个简单条件分支，两个调用和一些加载/添加/存储的函数。
相反，编译器正在展开此循环并生成具有大量分支点的代码。这部分是因为编译器认为它会以这种方式更有效（涉及 less 分支），但部分原因是它减少了运行时递归深度。
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)
..
你挑出的两个案例（交替和半模式）是最佳极值，编译器选择了一些中间案例，它会尽力处理。