有人决定做一个简单的测试，看看客户端如何本地人在速度方面相比的JavaScript。 他们这样做，通过运行10次000 000开方的计算和测量所花费的时间。 使用JavaScript结果0.096秒，并用NaCl：4.241秒......怎么可能？ 是不是速度放在第一位使用氯化钠的原因之一？ 还是我错过了一些编译器标志还是什么？
继承人，这是运行的代码：
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：这个问题的东西的编辑版本中出现的本地客户端的邮件列表
注意：这个答案是东西编辑版本中出现的本地客户端的邮件列表
微基准是棘手：除非你知道你在做什么，很好很容易产生苹果与桔子的对比这是不相关的，你要观察/测量所有的行为。
我会用自己的例子详细一点（我会排除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秒做十亿周期。 但是，让我们看看有什么需要时间：让我们将“结果+ =开方（I）;” 与 “结果+ = 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
哇！ 时间实际上是在CPU提供的sqrt函数花费95％，其他的一切了不到5％。 但是，如果我们将改变什么代码只是一个位：更换的 “printf（” ％G％G \ n “因此，TT）;” 用的 “printf（” ％克\ 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
嗯......貌似现在“开方”几乎一样快“+”。 怎么会这样？ 如何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
...
第一个版本实际上是调用开方十亿次，但第二个没有做这种事情！ 相反，它会检查，如果数字为负，只有在这种情况下，开方来电！ 为什么？ 什么编译器（或者，更确切地说，编译器的作者）正试图在这里做什么？
嗯，这很简单：因为我们已经不是在这个特殊的版本中使用的“结果”，它可以安全地忽略“开方”呼......如果该值不为负，这是！ 如果是负值，那么（根据FPU标志）开方可以做不同的事情（返回无意义的结果，程序崩溃等）。 这就是为什么这个版本的时候打快 - 但它不计算平方根的一切！
这里是显示错误的微基准怎么能去最后一个例子：
$ 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
...
哎哟：编译器非常聪明，用乘法来代替循环！
现在，如果你将一侧和JavaScript的另一边添加氯化钠，你会得到这样一个复杂的系统，结果是不可预知的字面上。
这里的问题是，对于微基准你试图隔离一段代码，然后评估它的属性，但随后编译器（无论JIT或AOT）会尝试，因为它试图从你的程序中删除所有无用的计算，以阻止你的努力！
微基准有用的，肯定的，但他们是取证分析工具，不是你想用比较两个不同系统的速度的东西！ 为此你需要一些“真正的”（在世界上的一些感觉：东西不能用过于急切的编译器进行优化，以件）工作量：排序算法很受欢迎，尤其如此。
其使用的sqrt基准是特别讨厌的，因为正如我们所看到的，通常他们花费大量的时间执行一个单一的CPU指令超过90％：sqrtsd（FSQRT如果是32位版本），这是当然的，对JavaScript和NaCl相同。 这些基准（如果正确实施）可以作为试金石（如果有的实施速度不同于什么简单的原生版本的展品，那么你正在做的事情错太多），但它们无法作为的氯化钠，JavaScript中，C＃速度比较或Visual Basic。
