涉及 sin() 的两个非常相似的函数表现出截然不同的性能——为什么？

Question

考虑以下两个以两种不同方式执行相同计算的程序：

// v1.c
#include <stdio.h>
#include <math.h>
int main(void) {
   int i, j;
   int nbr_values = 8192;
   int n_iter = 100000;
   float x;
   for (j = 0; j < nbr_values; j++) {
      x = 1;
      for (i = 0; i < n_iter; i++)
         x = sin(x);
   }
   printf("%f\n", x);
   return 0;
}

和

// v2.c
#include <stdio.h>
#include <math.h>
int main(void) {
   int i, j;
   int nbr_values = 8192;
   int n_iter = 100000;
   float x[nbr_values];
   for (i = 0; i < nbr_values; ++i) {
      x[i] = 1;
   }
   for (i = 0; i < n_iter; i++) {
      for (j = 0; j < nbr_values; ++j) {
         x[j] = sin(x[j]);
      }
   }
   printf("%f\n", x[0]);
   return 0;
}

当我使用带有-O3 -ffast-math 的 gcc 4.7.2 编译它们并在 Sandy Bridge 机器上运行时，第二个程序的速度是第一个程序的两倍。

这是为什么呢？

一个怀疑是v1 中i 循环的连续迭代之间的数据依赖性。但是，我不太明白完整的解释可能是什么。

（受Why is my python/numpy example faster than pure C implementation?启发的问题）

编辑：

这是为v1 生成的程序集：

        movl    $8192, %ebp
        pushq   %rbx
LCFI1:
        subq    $8, %rsp
LCFI2:
        .align 4
L2:
        movl    $100000, %ebx
        movss   LC0(%rip), %xmm0
        jmp     L5
        .align 4
L3:
        call    _sinf
L5:
        subl    $1, %ebx
        jne     L3
        subl    $1, %ebp
        .p2align 4,,2
        jne     L2

对于v2：

        movl    $100000, %r14d
        .align 4
L8:
        xorl    %ebx, %ebx
        .align 4
L9:
        movss   (%r12,%rbx), %xmm0
        call    _sinf
        movss   %xmm0, (%r12,%rbx)
        addq    $4, %rbx
        cmpq    $32768, %rbx
        jne     L9
        subl    $1, %r14d
        jne     L8

Answer 1

完全忽略循环结构，只考虑对sin的调用顺序。 v1 执行以下操作：

x <-- sin(x)
x <-- sin(x)
x <-- sin(x)
...

即sin( )的每一次计算只有在前一次调用的结果可用时才能开始；它必须等待整个先前的计算。这意味着对于 N 次对 sin 的调用，所需的总时间是单个 sin 评估延迟的 819200000 倍。

相比之下，在v2 中，您执行以下操作：

x[0] <-- sin(x[0])
x[1] <-- sin(x[1])
x[2] <-- sin(x[2])
...

请注意，对sin 的每次调用都不依赖于前一次调用。实际上，对sin 的调用都是独立的，只要必要的寄存器和 ALU 资源可用，处理器就可以开始每个调用（无需等待先前的计算完成）。因此，所需时间是 sin 函数的吞吐量的函数，而不是延迟，因此v2 可以在更短的时间内完成。

---

我还应该指出，DeadMG 是正确的，v1 和 v2 在形式上是等价的，并且在完美的世界中，编译器会将它们优化为 100000 个 sin 评估的单个链（或简单地评估编译时的结果）。可悲的是，我们生活在一个不完美的世界中。

Answer 2

在第一个示例中，它运行了 100000 个 sin 循环，8192 次。

在第二个例子中，它运行了 8192 个 sin 循环，100000 次。

除此之外并以不同的方式存储结果，我看不出有任何区别。

但是，真正不同的是，在第二种情况下，每个循环的输入都在更改。所以我怀疑会发生什么，在循环中的某些时候，sin 值变得更容易计算。这可以产生很大的不同。计算 sin 并不完全是微不足道的，它是一个循环计算，直到满足退出条件。