benchmarking
# Node.js
const Benchmark = require("benchmark");
const suite = new Benchmark.Suite();
suite
.add("fib#recursion", () => {
fibRec(10);
})
.add("fib#loop", () => {
fibLoop(10);
})
.on("complete", () => {
console.log(suite[0].toString());
console.log(suite[1].toString());
})
.run({
async: true,
});
function fibRec(n) {
if (n <= 1) {
return n;
}
return fibRec(n - 1) + fibRec(n - 2);
}
function fibLoop(n) {
let f = [0, 1];
for (let i = 2; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2];
}
return f[n];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Output
$ node examples/benchmark_test.js
fib#recursion x 1,343,074 ops/sec ±1.26% (84 runs sampled)
fib#loop x 20,104,517 ops/sec ±3.78% (78 runs sampled)
1
2
3
2
3
# Go
package example
import (
"testing"
)
func BenchmarkFibRec(b *testing.B) {
for n := 0; n < b.N; n++ {
fibRec(10)
}
}
func BenchmarkFibLoop(b *testing.B) {
for n := 0; n < b.N; n++ {
fibLoop(10)
}
}
func fibRec(n int) int {
if n <= 1 {
return n
}
return fibRec(n-1) + fibRec(n-2)
}
func fibLoop(n int) int {
f := make([]int, n+1, n+2)
if n < 2 {
f = f[0:2]
}
f[0] = 0
f[1] = 1
for i := 2; i <= n; i++ {
f[i] = f[i-1] + f[i-2]
}
return f[n]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Output
$ go test -v -bench=. -benchmem examples/benchmark_test.go
goos: darwin
goarch: amd64
BenchmarkFibRec-8 5000000 340 ns/op 0 B/op 0 allocs/op
BenchmarkFibLoop-8 30000000 46.5 ns/op 96 B/op 1 allocs/op
PASS
ok command-line-arguments 3.502s
1
2
3
4
5
6
7
2
3
4
5
6
7
编辑 (opens new window)
上次更新: 2022/09/30, 11:34:22