是什么让这个函数运行得慢得多？

Question

我一直在尝试做一个实验，看看函数中的局部变量是否存储在堆栈中。

所以我写了一点性能测试

function test(fn, times){
    var i = times;
    var t = Date.now()
    while(i--){
        fn()
    }
    return Date.now() - t;
} 
ene
function straight(){
    var a = 1
    var b = 2
    var c = 3
    var d = 4
    var e = 5
    a = a * 5
    b = Math.pow(b, 10)
    c = Math.pow(c, 11)
    d = Math.pow(d, 12)
    e = Math.pow(e, 25)
}
function inversed(){
    var a = 1
    var b = 2
    var c = 3
    var d = 4
    var e = 5
    e = Math.pow(e, 25)
    d = Math.pow(d, 12)
    c = Math.pow(c, 11)
    b = Math.pow(b, 10)
    a = a * 5
}

我希望反函数的工作速度更快。相反，一个惊人的结果出来了。

在我测试其中一个函数之前，它的运行速度比测试第二个函数快 10 倍。

例子：

> test(straight, 10000000)
30
> test(straight, 10000000)
32
> test(inversed, 10000000)
390
> test(straight, 10000000)
392
> test(inversed, 10000000)
390

以替代顺序测试时的行为相同。

> test(inversed, 10000000)
25
> test(straight, 10000000)
392
> test(inversed, 10000000)
394

我在 Chrome 浏览器和 Node.js 中都对其进行了测试，但我完全不知道为什么会发生这种情况。 效果会一直持续到我刷新当前页面或重启 Node REPL。

如此显着（大约差 12 倍）性能的原因是什么？

PS。由于它似乎只在某些环境中有效，请编写您用来测试它的环境。

我的是：

操作系统：Ubuntu 14.04
节点 v0.10.37
Chrome 43.0.2357.134（官方版本）（64位）

/编辑
在 Firefox 39 上，无论顺序如何，每次测试都需要大约 5500 毫秒。它似乎只发生在特定引擎上。

/Edit2
将函数内联到测试函数使其始终在同一时间运行。
如果函数参数始终是相同的函数，是否有可能进行内联函数参数的优化？

Answer 1

一旦你用两个不同的函数fn() 调用test，它内部的调用点就变成了超多态，V8 无法内联它。

V8 中的函数调用（相对于方法调用o.m(...)）伴随着一个元素内联缓存，而不是真正的多态内联缓存。

由于 V8 无法在 fn() 调用站点内联，因此无法对您的代码应用各种优化。如果您查看IRHydra 中的代码（为了方便您，我上传了编译工件），您会注意到test 的第一个优化版本（当它专门用于fn = straight 时）有一个完全空的主循环。

V8 刚刚内联了 straight 并删除了您希望使用死代码消除优化进行基准测试的所有代码。在旧版本的 V8 而不是 DCE 上，V8 只会通过 LCM 将代码提升出循环 - 因为代码是完全循环不变的。

当straight 未内联时，V8 无法应用这些优化 - 因此性能差异。较新版本的 V8 仍将 DCE 应用于 straight 和 inversed 本身，将它们变成空函数

所以性能差异并不大（大约 2-3 倍）。较旧的 V8 对 DCE 的攻击性不够——这将体现在内联和非内联情况之间的更大差异，因为内联情况的峰值性能完全是激进的循环不变代码运动 (LICM) 的结果。

在相关说明中，这说明了为什么不应该这样编写基准测试 - 因为它们的结果没有任何用处，因为您最终会测量一个空循环。

如果您对多态性及其在 V8 中的含义感兴趣，请查看我的帖子 "What's up with monomorphism"（“并非所有缓存都相同”部分讨论了与函数调用相关的缓存）。我还建议通读我的一篇关于微基准测试危险的演讲，例如来自 GOTO Chicago 2015 (video) 的最新 "Benchmarking JS" 演讲 - 它可能会帮助您避免常见的陷阱。

Answer 2

你误解了堆栈。

虽然“真正的”堆栈确实只有Push 和Pop 操作，但这并不真正适用于用于执行的那种堆栈。除了Push 和Pop，你还可以随机访问任何变量，只要你有它的地址。这意味着本地人的顺序无关紧要，即使编译器没有为您重新排序。在伪汇编中，你似乎认为

var x = 1;
var y = 2;

x = x + 1;
y = y + 1;

翻译成类似的东西

push 1 ; x
push 2 ; y

; get y and save it
pop tmp
; get x and put it in the accumulator
pop a
; add 1 to the accumulator
add a, 1
; store the accumulator back in x
push a
; restore y
push tmp
; ... and add 1 to y

其实真正的代码更像是这样的：

push 1 ; x
push 2 ; y

add [bp], 1
add [bp+4], 1

如果线程堆栈真的是一个真实的、严格的堆栈，这是不可能的，真的。在这种情况下，操作的顺序和本地人将比现在更重要。相反，通过允许随机访问堆栈上的值，您可以为编译器和 CPU 节省大量工作。

要回答您的实际问题，我怀疑这两个函数实际上都没有做任何事情。你只是修改了局部变量，你的函数没有返回任何东西——编译器完全删除函数体，甚至可能是函数调用是完全合法的。如果确实如此，那么您观察到的任何性能差异都可能只是一个测量工件，或者与调用函数/迭代的固有成本有关的东西。

Answer 3

将函数内联到测试函数使其始终在同一时间运行。
如果函数参数始终是相同的函数，是否有可能进行内联函数参数的优化？

是的，这似乎正是您所观察到的。正如@Luaan 已经提到的，编译器可能会丢弃您的straight 和inverse 函数的主体，因为它们没有任何副作用，而只是操作一些局部变量。

当您第一次调用test(…, 100000) 时，优化编译器在经过一些迭代后意识到被调用的fn() 始终是相同的，并将其内联，避免了代价高昂的函数调用。它现在所做的只是将变量递减 1000 万次并针对 0 进行测试。

但是当你用不同的fn 调用test 时，它必须去优化。它稍后可能会再次进行一些其他优化，但现在知道有两个不同的函数要调用，它不能再内联它们了。

由于您真正衡量的唯一内容是函数调用，这会导致结果出现严重差异。

查看函数中的局部变量是否存储在堆栈中的实验

关于您的实际问题，不，单个变量不存储在堆栈中 (stack machine)，而是存储在寄存器中 (register machine)。在您的函数中声明或使用它们的顺序并不重要。

然而，它们存储在the stack，作为所谓的“堆栈帧”的一部分。每个函数调用都有一帧，存储其执行上下文的变量。在您的情况下，堆栈可能如下所示：

[straight: a, b, c, d, e]
[test: fn, times, i, t]
…