C++ 为什么我的程序这么慢？

有人决定做一个快速测试，看看本地客户端在速度方面与javascript相比有多快。他们通过运行10000 sqrt计算并测量所需时间来实现这一点。使用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);

clock_t=clock（）；
浮动结果=0；
对于（int i=0；i<10000000；++i）{
结果+=sqrt（i）；
}
t=时钟（）-t；
浮点tt=（（浮点）t）/时钟每秒；
pp:：Var Var_reply=pp:：Var（tt）；
邮递信息（var_回复）；

---

注：此问题是出现在

中的某个内容的编辑版本。注：此答案是出现在

中的某个内容的编辑版本

微基准点很棘手：除非你很好地理解自己在做什么，否则很容易进行苹果与橙子的比较，而这与你想要观察/测量的行为根本不相关

我将使用您自己的示例进行详细说明（我将排除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

第一个版本实际上调用了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

啊，哦，循环完全被消除了！所有的计算都是在编译时进行的，更糟糕的是，这两个“时钟”调用都是在启动循环体之前执行的

如果我们把它放在单独的函数中呢

$ 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

呃哦：编译器足够聪明，可以用乘法代替循环

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

这里的问题是，对于microbenchmark，您试图隔离一段代码，然后评估它的属性，但是编译器（无论是JIT还是AOT）将试图阻止您的工作，因为它试图从您的程序中删除所有无用的计算

微基准当然有用，但它们是法医分析工具，而不是用来比较两个不同系统的速度的东西！为此，您需要一些“真实的”（从某种意义上说：某些东西不能通过过于急切的编译器优化成碎片）工作负载：排序算法尤其流行

---

使用sqrt的基准测试尤其糟糕，因为正如我们所看到的，它们通常花费90%以上的时间执行一条CPU指令：sqrtsd（如果是32位版本，则为fsqrt），这当然与JavaScript和NaCl相同。这些基准测试（如果正确实现）可以作为一个试金石测试（如果某些实现的速度与简单的本机版本的速度相差太大，那么您就做错了），但它们在比较NaCl、JavaScript、C#或Visual Basic的速度时是无用的。

等等，你复制了一个人的问题，然后用另一个人的答案从邮件列表中自己回答。是的，并将两者都归因于。这似乎是一个应该分享的答案。如果原始海报想要张贴他们的东西，我很乐意把这个拿下来。我并不是想占上风，只是想传播一个我发现非常有用的答案。这样做完全可以，但我认为你可以将此作为社区维基答案发布，因为你并不完全是答案的作者。为什么不将其设置为维基？而且，无论是问题还是答案都写得不是特别好。堆栈溢出时要转储的内容很多。此外，你可能应该征得他们的同意，谷歌集团。考虑到披露时间的长短，最好把披露放在帖子的顶部。

$ 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
...

$ 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
...