有人决定做一个快速测试，看看 native 客户端在速度方面与 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 中出现的内容的编辑版本
最佳答案
注意:此答案是 native client mailing list 中出现的内容的编辑版本
微基准测试很棘手:除非您非常了解自己在做什么，否则很容易产生与您想要观察/测量的行为完全无关的苹果与橘子的比较。
我将使用您自己的示例进行详细说明(我将排除 NaCl 并坚持使用现有的“久经考验的”技术)。
这是您作为 native 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 如何影响前一个循环？
让我们看看:
$ 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!为什么？编译器(或者更确切地说，编译器作者)在这里试图做什么？
好吧，这很简单:因为我们没有在这个特定版本中使用“result”，所以它可以安全地省略“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
执行时间是……零？怎么会这样？十亿计算不到那么眨眼？让我们看看:
$ 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，您将得到一个如此复杂的系统，其结果实际上是不可预测的。
这里的问题是，对于微基准测试，您试图隔离一段代码，然后评估它的属性，但是编译器(无论是 JIT 还是 AOT)将试图阻止您的努力，因为它试图从中删除所有无用的计算你的程序!
Microbenchmarks 当然有用，但它们是取证分析工具，而不是您想用来比较两个不同系统的速度的东西!为此，您需要一些“真实的”(在某种意义上:无法通过过度急切的编译器优化成碎片的东西)工作负载:排序算法尤其流行。
使用 sqrt 的基准测试特别令人讨厌，因为正如我们所见，通常它们 90% 以上的时间都用于执行一条 CPU 指令:sqrtsd(如果是 32 位版本，则为 fsqrt)，当然，对于JavaScript 和氯化钠。这些基准测试(如果实现得当)可以作为试金石(如果某些实现的速度与简单的 native 版本表现出的差异太大，那么你做错了什么)，但它们作为 NaCl、JavaScript、C# 速度的比较是无用的或 Visual Basic。
关于c++ - 为什么我的程序这么慢？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/16156130/