为什么我的程序很慢？

Question

有人决定做一个快速测试，看看本地客户端与JavaScript相比在速度方面如何。他们通过运行10 000 000 sqrt计算并测量所花费的时间来做到这一点。结果与JavaScript：0.096秒，并与NaCl：4.241秒...怎么可能？速度不是首先使用NaCl的原因之一？或者我错过了一些编译器标志或什么？

继承人所运行的代码：

clock_t t = clock(); 
float result = 0; 
for(int i = 0; i < 10000000; ++i) { 
    result += sqrt(i); 
} 
t = clock() - t;  
float tt = ((float)t)/CLOCKS_PER_SEC; 
pp::Var var_reply = pp::Var(tt); 
PostMessage(var_reply); 

PS：这个问题的一些编辑过的版本中出现的native client mailing list

Answer 1

注：此答案是，出现了一些编辑版native client mailing list

微基因标记很棘手：除非你明白你在做什么很好，很容易产生与你想要的行为无关的苹果与桔子的比较rve /措施。

我会用你自己的例子来详细说明一下（我会排除NaCl并坚持现有的“可靠和真实的”技术）。

这里是原生的C程序测试：

$ cat test1.c 
#include <math.h> 
#include <time.h> 
#include <stdio.h> 

int main() { 
    clock_t t = clock(); 
    float result = 0; 
    for(int i = 0; i < 1000000000; ++i) { 
     result += sqrt(i); 
    } 
    t = clock() - t; 
    float tt = ((float)t)/CLOCKS_PER_SEC; 
    printf("%g %g\n", result, tt); 

} 
$ gcc -std=c99 -O2 test1.c -lm -o test1 
$ ./test1 
5.49756e+11 25.43 

确定。我们可以在25.43秒内完成数十亿次循环。但让我们看看需要花费多少时间：让我们来替换“result + = sqrt（i）;”与“结果+ =我;”

$ cat test2.c 
#include <math.h> 
#include <time.h> 
#include <stdio.h> 

int main() { 
    clock_t t = clock(); 
    float result = 0; 
    for(int i = 0; i < 1000000000; ++i) { 
     result += i; 
    } 
    t = clock() - t; 
    float tt = ((float)t)/CLOCKS_PER_SEC; 
    printf("%g %g\n", result, tt); 
} 
$ gcc -std=c99 -O2 test2.c -lm -o test2 
$ ./test2 
1.80144e+16 1.21 

哇！ 95％的时间实际上是花在CPU提供的sqrt函数上的，其他所有的花费少于5％。但是如果我们稍微改变一下代码呢：将“printf（”％g％g \ n“，result，tt）替换为”与“printf（”％g \ n“，tt）;” ？

$ cat test3.c 
#include <math.h> 
#include <time.h> 
#include <stdio.h> 

int main() { 
    clock_t t = clock(); 
    float result = 0; 
    for(int i = 0; i < 1000000000; ++i) { 
     result += sqrt(i); 
    } 
    t = clock() - t; 
    float tt = ((float)t)/CLOCKS_PER_SEC; 
    printf("%g\n", tt); 
} 
$ gcc -std=c99 -O2 test3.c -lm -o test3 
$ ./test 
1.44 

嗯......看起来像现在“sqrt”几乎和“+”一样快。怎么会这样？ printf如何影响上一个周期AT ALL？

让我们来看看：

$ gcc -std=c99 -O2 test1.c -S -o - 
... 
.L3: 
     cvtsi2sd  %ebp, %xmm1 
     sqrtsd %xmm1, %xmm0 
     ucomisd %xmm0, %xmm0 
     jp  .L7 
     je  .L2 
.L7: 
     movapd %xmm1, %xmm0 
     movss %xmm2, (%rsp) 
     call sqrt 
     movss (%rsp), %xmm2 
.L2: 
     unpcklps  %xmm2, %xmm2 
     addl $1, %ebp 
     cmpl $1000000000, %ebp 
     cvtps2pd  %xmm2, %xmm2 
     addsd %xmm0, %xmm2 
     unpcklpd  %xmm2, %xmm2 
     cvtpd2ps  %xmm2, %xmm2 
     jne  .L3 
... 
$ gcc -std=c99 -O2 test3.c -S -o - 
... 
     xorpd %xmm1, %xmm1 
... 
.L5: 
     cvtsi2sd  %ebp, %xmm0 
     ucomisd %xmm0, %xmm1 
     ja  .L14 
.L10: 
     addl $1, %ebp 
     cmpl $1000000000, %ebp 
     jne  .L5 
... 
.L14: 
     sqrtsd %xmm0, %xmm2 
     ucomisd %xmm2, %xmm2 
     jp  .L12 
     .p2align 4,,2 
     je  .L10 
.L12: 
     movsd %xmm1, (%rsp) 
     .p2align 4,,5 
     call sqrt 
     movsd (%rsp), %xmm1 
     .p2align 4,,4 
     jmp  .L10 
... 

第一个版本实际上是调用开方十亿次，但第二个没有做这种事情！相反，它会检查数字是否定的，并且只在这种情况下才调用sqrt！为什么？编译器（或者编译器作者）在这里试图做什么？

嗯，很简单：因为我们没有在这个特定的版本中使用“结果”，所以它可以安全地省略“sqrt”调用......如果值不是负数，那就是！如果它是负数，那么（取决于FPU标志）sqrt可以做不同的事情（返回无意义的结果，崩溃程序等）。这就是为什么这个版本要快十几倍 - 但它根本不计算平方根！

下面是最后一个例子，显示微基准是多么的错误可以去：

$ cat test4.c 
#include <math.h> 
#include <time.h> 
#include <stdio.h> 

int main() { 
    clock_t t = clock(); 
    int result = 0; 
    for(int i = 0; i < 1000000000; ++i) { 
     result += 2; 
    } 
    t = clock() - t; 
    float tt = ((float)t)/CLOCKS_PER_SEC; 
    printf("%d %g\n", result, tt); 
} 
$ gcc -std=c99 -O2 test4.c -lm -o test4 
$ ./test4 
2000000000 0 

执行时间是...... ZERO？怎么会这样？十亿计算在眨眼间？让我们看看：

$ gcc -std=c99 -O2 test1.c -S -o - 
... 
     call clock 
     movq %rax, %rbx 
     call clock 
     subq %rbx, %rax 
     movl $2000000000, %edx 
     movl $.LC1, %esi 
     cvtsi2ssq  %rax, %xmm0 
     movl $1, %edi 
     movl $1, %eax 
     divss .LC0(%rip), %xmm0 
     unpcklps  %xmm0, %xmm0 
     cvtps2pd  %xmm0, %xmm0 
... 

呃，哦，周期是完全消除的！所有的计算都是在编译时发生的，并且增加了对受伤的伤害两个“时钟”调用都是在启动周期之前执行的！

如果我们将它放在单独的函数中，该怎么办？

$ cat test5.c 
#include <math.h> 
#include <time.h> 
#include <stdio.h> 

int testfunc(int num, int max) { 
    int result = 0; 
    for(int i = 0; i < max; ++i) { 
     result += num; 
    } 
    return result; 
} 

int main() { 
    clock_t t = clock(); 
    int result = testfunc(2, 1000000000); 
    t = clock() - t; 
    float tt = ((float)t)/CLOCKS_PER_SEC; 
    printf("%d %g\n", result, tt); 
} 
$ gcc -std=c99 -O2 test5.c -lm -o test5 
$ ./test5 
2000000000 0 

还是一样的？怎么会这样？

$ gcc -std=c99 -O2 test5.c -S -o - 
... 
.globl testfunc 
     .type testfunc, @function 
testfunc: 
.LFB16: 
     .cfi_startproc 
     xorl %eax, %eax 
     testl %esi, %esi 
     jle  .L3 
     movl %esi, %eax 
     imull %edi, %eax 
.L3: 
     rep 
     ret 
     .cfi_endproc 
... 

嗯，编译器足够聪明，可以用乘法代替循环！

现在，如果你在一边添加NaCl而在另一边添加JavaScript，你会得到如此复杂的系统，结果是不可预测的。

这里的问题是，对于microbenchmark你试图隔离一段代码然后评估它的属性，但是然后编译器（不管JIT或AOT）会试图阻止你的努力，因为它试图去除所有无用的计算从你的程序！

Microbenchmarks有用，当然，但他们是法医分析工具，而不是你想用来比较两个不同系统的速度！为此，您需要一些“真实的”（在某些意义上的世界：无法通过编译器过度优化的东西）工作负载：排序算法尤其受欢迎。

使用sqrt的基准测试特别讨厌，因为正如我们所看到的，通常他们花费超过90％的时间来执行单个CPU指令：sqrtsd（fsqrt，如果它是32位版本）当然是相同的对于JavaScript和NaCl。这些基准测试（如果执行得当的话）可以作为试金石（如果某些实现的速度与简单的本地版本展现的差异太大，那么你做错了什么），但是它们对于NaCl，JavaScript，C＃或Visual Basic。