qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-09-25 05:20:13 -06:00
Code Releases Activity

math/big: use run for benchmarks

Browse Source 
shortens code and gives an example of the use of Run.

Change-Id: I75ffaf762218a589274b4b62e19022e31e805d1b
Reviewed-on: https://go-review.googlesource.com/23424
Reviewed-by: Russ Cox <rsc@golang.org>
Run-TryBot: Marcel van Lohuizen <mpvl@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
This commit is contained in:
Marcel van Lohuizen 2016-05-25 14:57:49 +02:00
parent 23cb8864b5
commit 07f0c19a30
1 changed files with 60 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
src/math/big/arith_test.go
View File

@ -5,6 +5,7 @@
package big package big
import ( import (
"fmt"
"math/rand" "math/rand"
"testing" "testing"
) )
@ -118,27 +119,35 @@ func rndV(n int) []Word {
return v return v
} }
func benchmarkFunVV(b *testing.B, f funVV, n int) { var benchSizes = []struct {
x := rndV(n) name string
y := rndV(n) n int
z := make([]Word, n) }{
b.SetBytes(int64(n * _W)) {"1", 1},
b.ResetTimer() {"2", 2},
for i := 0; i < b.N; i++ { {"3", 3},
f(z, x, y) {"4", 4},
} {"5", 5},
{"1e1", 1e1},
{"1e2", 1e2},
{"1e3", 1e3},
{"1e4", 1e4},
{"1e5", 1e5},
} }
func BenchmarkAddVV_1(b *testing.B) { benchmarkFunVV(b, addVV, 1) } func BenchmarkAddVV(b *testing.B) {
func BenchmarkAddVV_2(b *testing.B) { benchmarkFunVV(b, addVV, 2) } for _, tc := range benchSizes {
func BenchmarkAddVV_3(b *testing.B) { benchmarkFunVV(b, addVV, 3) } x := rndV(tc.n)
func BenchmarkAddVV_4(b *testing.B) { benchmarkFunVV(b, addVV, 4) } y := rndV(tc.n)
func BenchmarkAddVV_5(b *testing.B) { benchmarkFunVV(b, addVV, 5) } z := make([]Word, tc.n)
func BenchmarkAddVV_1e1(b *testing.B) { benchmarkFunVV(b, addVV, 1e1) } b.Run(fmt.Sprint(tc.name), func(b *testing.B) {
func BenchmarkAddVV_1e2(b *testing.B) { benchmarkFunVV(b, addVV, 1e2) } b.SetBytes(int64(tc.n * _W))
func BenchmarkAddVV_1e3(b *testing.B) { benchmarkFunVV(b, addVV, 1e3) } for i := 0; i < b.N; i++ {
func BenchmarkAddVV_1e4(b *testing.B) { benchmarkFunVV(b, addVV, 1e4) } addVV(z, x, y)
func BenchmarkAddVV_1e5(b *testing.B) { benchmarkFunVV(b, addVV, 1e5) } }
})
}
}
type funVW func(z, x []Word, y Word) (c Word) type funVW func(z, x []Word, y Word) (c Word)
type argVW struct { type argVW struct {
@ -236,28 +245,20 @@ func TestFunVW(t *testing.T) {
} }
} }
func benchmarkFunVW(b *testing.B, f funVW, n int) { func BenchmarkAddVW(b *testing.B) {
x := rndV(n) for _, tc := range benchSizes {
y := rndW() x := rndV(tc.n)
z := make([]Word, n) y := rndW()
b.SetBytes(int64(n * _S)) z := make([]Word, tc.n)
b.ResetTimer() b.Run(fmt.Sprint(tc.name), func(b *testing.B) {
for i := 0; i < b.N; i++ { b.SetBytes(int64(tc.n * _S))
f(z, x, y) for i := 0; i < b.N; i++ {
addVW(z, x, y)
}
})
} }
} }
func BenchmarkAddVW_1(b *testing.B) { benchmarkFunVW(b, addVW, 1) }
func BenchmarkAddVW_2(b *testing.B) { benchmarkFunVW(b, addVW, 2) }
func BenchmarkAddVW_3(b *testing.B) { benchmarkFunVW(b, addVW, 3) }
func BenchmarkAddVW_4(b *testing.B) { benchmarkFunVW(b, addVW, 4) }
func BenchmarkAddVW_5(b *testing.B) { benchmarkFunVW(b, addVW, 5) }
func BenchmarkAddVW_1e1(b *testing.B) { benchmarkFunVW(b, addVW, 1e1) }
func BenchmarkAddVW_1e2(b *testing.B) { benchmarkFunVW(b, addVW, 1e2) }
func BenchmarkAddVW_1e3(b *testing.B) { benchmarkFunVW(b, addVW, 1e3) }
func BenchmarkAddVW_1e4(b *testing.B) { benchmarkFunVW(b, addVW, 1e4) }
func BenchmarkAddVW_1e5(b *testing.B) { benchmarkFunVW(b, addVW, 1e5) }
type funVWW func(z, x []Word, y, r Word) (c Word) type funVWW func(z, x []Word, y, r Word) (c Word)
type argVWW struct { type argVWW struct {
z, x nat z, x nat
@ -382,28 +383,20 @@ func TestMulAddWWW(t *testing.T) {
} }
} }
func benchmarkAddMulVVW(b *testing.B, n int) { func BenchmarkAddMulVVW(b *testing.B) {
x := rndV(n) for _, tc := range benchSizes {
y := rndW() x := rndV(tc.n)
z := make([]Word, n) y := rndW()
b.SetBytes(int64(n * _W)) z := make([]Word, tc.n)
b.ResetTimer() b.Run(fmt.Sprint(tc.n), func(b *testing.B) {
for i := 0; i < b.N; i++ { b.SetBytes(int64(tc.n * _W))
addMulVVW(z, x, y) for i := 0; i < b.N; i++ {
addMulVVW(z, x, y)
}
})
} }
} }
func BenchmarkAddMulVVW_1(b *testing.B) { benchmarkAddMulVVW(b, 1) }
func BenchmarkAddMulVVW_2(b *testing.B) { benchmarkAddMulVVW(b, 2) }
func BenchmarkAddMulVVW_3(b *testing.B) { benchmarkAddMulVVW(b, 3) }
func BenchmarkAddMulVVW_4(b *testing.B) { benchmarkAddMulVVW(b, 4) }
func BenchmarkAddMulVVW_5(b *testing.B) { benchmarkAddMulVVW(b, 5) }
func BenchmarkAddMulVVW_1e1(b *testing.B) { benchmarkAddMulVVW(b, 1e1) }
func BenchmarkAddMulVVW_1e2(b *testing.B) { benchmarkAddMulVVW(b, 1e2) }
func BenchmarkAddMulVVW_1e3(b *testing.B) { benchmarkAddMulVVW(b, 1e3) }
func BenchmarkAddMulVVW_1e4(b *testing.B) { benchmarkAddMulVVW(b, 1e4) }
func BenchmarkAddMulVVW_1e5(b *testing.B) { benchmarkAddMulVVW(b, 1e5) }
func testWordBitLen(t *testing.T, fname string, f func(Word) int) { func testWordBitLen(t *testing.T, fname string, f func(Word) int) {
for i := 0; i <= _W; i++ { for i := 0; i <= _W; i++ {
x := Word(1) << uint(i-1) // i == 0 => x == 0 x := Word(1) << uint(i-1) // i == 0 => x == 0
@ -420,23 +413,15 @@ func TestWordBitLen(t *testing.T) {
} }
// runs b.N iterations of bitLen called on a Word containing (1 << nbits)-1. // runs b.N iterations of bitLen called on a Word containing (1 << nbits)-1.
func benchmarkBitLenN(b *testing.B, nbits uint) { func BenchmarkBitLen(b *testing.B) {
testword := Word((uint64(1) << nbits) - 1) // Individual bitLen tests. Numbers chosen to examine both sides
for i := 0; i < b.N; i++ { // of powers-of-two boundaries.
bitLen(testword) for _, nbits := range []uint{0, 1, 2, 3, 4, 5, 8, 9, 16, 17, 31} {
testword := Word((uint64(1) << nbits) - 1)
b.Run(fmt.Sprint(nbits), func(b *testing.B) {
for i := 0; i < b.N; i++ {
bitLen(testword)
}
})
} }
} }
// Individual bitLen tests. Numbers chosen to examine both sides
// of powers-of-two boundaries.
func BenchmarkBitLen0(b *testing.B) { benchmarkBitLenN(b, 0) }
func BenchmarkBitLen1(b *testing.B) { benchmarkBitLenN(b, 1) }
func BenchmarkBitLen2(b *testing.B) { benchmarkBitLenN(b, 2) }
func BenchmarkBitLen3(b *testing.B) { benchmarkBitLenN(b, 3) }
func BenchmarkBitLen4(b *testing.B) { benchmarkBitLenN(b, 4) }
func BenchmarkBitLen5(b *testing.B) { benchmarkBitLenN(b, 5) }
func BenchmarkBitLen8(b *testing.B) { benchmarkBitLenN(b, 8) }
func BenchmarkBitLen9(b *testing.B) { benchmarkBitLenN(b, 9) }
func BenchmarkBitLen16(b *testing.B) { benchmarkBitLenN(b, 16) }
func BenchmarkBitLen17(b *testing.B) { benchmarkBitLenN(b, 17) }
func BenchmarkBitLen31(b *testing.B) { benchmarkBitLenN(b, 31) }