Question

我偶然发现了这个漂亮的小型仓库，比较了几种编译和解释语言的简单递归fibonacci函数：https://github.com/drujensen/fib。这似乎很公平，因为它不会在任何地方进行任何优化技巧。我知道有更好的方法可以使用Go的功能，但我只是想知道，为什么Go似乎比其他编译和静态类型语言慢得多？我可以在我的机器上用11s确认它看起来与Go非常相似。

Answer 1

原因是递归计算的组合爆炸。在算法101中，他们通常解释为什么Dru Jensen的递归算法是计算Fibonacci数的可怕方法：http://www.cs.toronto.edu/~gfb/csc104/2016W/Lectures/CSC104.2016W.Week-7.Lecture.Fibonacci.I.pdf。 fib过程每次调用时都会调用两次。根据设计，Go没有尾递归：Tail call。根据设计，Go以每个goroutine的非常小的堆栈开始，它必须爆炸性地生长。 No Go程序员想要使用这个算法，这比下一个最慢的慢了382,358,169倍，比最快的慢了18,593,103,127倍，所以优化会牺牲其他地方的性能，这是毫无意义的。

以下是一些Go基准测试结果：

$ go test fib_test.go -bench=.
BenchmarkDruJensen-8             1    9482482595 ns/op
BenchmarkPeterSO1-8       50000000            24.8 ns/op
BenchmarkPeterSO2-8     2000000000             0.51 ns/op

fib_test.go：

package main

import (
    "fmt"
    "testing"
)

// Dru Jensen: https://github.com/drujensen/fib
func fib(n uint64) uint64 {
    if n <= 1 {
        return 1
    } else {
        return fib(n-1) + fib(n-2)
    }
}

func BenchmarkDruJensen(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fib(46)
    }
}

// PeterSO
func fibonacci1(n int) uint64 {
    f := uint64(0)
    a, b := uint64(0), uint64(1)
    for i := 0; i < n; i++ {
        f, a, b = a, b, a+b
        if a > b {
            break
        }
    }
    return f
}

func BenchmarkPeterSO1(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fibonacci1(46)
    }
}

var fibonaccis = []uint64{
    0,
    1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597,
    2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418,
    317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465,
    14930352, 24157817, 39088169, 63245986, 102334155, 165580141,
    267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073,
    4807526976, 7778742049, 12586269025, 20365011074, 32951280099,
    53316291173, 86267571272, 139583862445, 225851433717, 365435296162,
    591286729879, 956722026041, 1548008755920, 2504730781961, 4052739537881,
    6557470319842, 10610209857723, 17167680177565, 27777890035288,
    44945570212853, 72723460248141, 117669030460994, 190392490709135,
    308061521170129, 498454011879264, 806515533049393, 1304969544928657,
    2111485077978050, 3416454622906707, 5527939700884757, 8944394323791464,
    14472334024676221, 23416728348467685, 37889062373143906,
    61305790721611591, 99194853094755497, 160500643816367088,
    259695496911122585, 420196140727489673, 679891637638612258,
    1100087778366101931, 1779979416004714189, 2880067194370816120,
    4660046610375530309, 7540113804746346429, 12200160415121876738,
}

// PeterSO
func fibonacci2(n int) uint64 {
    return fibonaccis[n]
}

func BenchmarkPeterSO2(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fibonacci2(46)
    }
}

任何想法为什么Go在递归的斐波纳契上看起来相对较慢？

1 个答案: