Current File : //home/waritko/go/src/cloud.google.com/go/internal/btree/benchmarks_test.go
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// +build go1.7
package btree
import (
"fmt"
"sort"
"testing"
)
const benchmarkTreeSize = 10000
var degrees = []int{2, 8, 32, 64}
func BenchmarkInsert(b *testing.B) {
insertP := perm(benchmarkTreeSize)
for _, d := range degrees {
b.Run(fmt.Sprintf("degree=%d", d), func(b *testing.B) {
i := 0
for i < b.N {
tr := New(d, less)
for _, m := range insertP {
tr.Set(m.Key, m.Value)
i++
if i >= b.N {
return
}
}
}
})
}
}
func BenchmarkDeleteInsert(b *testing.B) {
insertP := perm(benchmarkTreeSize)
for _, d := range degrees {
b.Run(fmt.Sprintf("degree=%d", d), func(b *testing.B) {
tr := New(d, less)
for _, m := range insertP {
tr.Set(m.Key, m.Value)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
m := insertP[i%benchmarkTreeSize]
tr.Delete(m.Key)
tr.Set(m.Key, m.Value)
}
})
}
}
func BenchmarkDeleteInsertCloneOnce(b *testing.B) {
insertP := perm(benchmarkTreeSize)
for _, d := range degrees {
b.Run(fmt.Sprintf("degree=%d", d), func(b *testing.B) {
tr := New(d, less)
for _, m := range insertP {
tr.Set(m.Key, m.Value)
}
tr = tr.Clone()
b.ResetTimer()
for i := 0; i < b.N; i++ {
m := insertP[i%benchmarkTreeSize]
tr.Delete(m.Key)
tr.Set(m.Key, m.Value)
}
})
}
}
func BenchmarkDeleteInsertCloneEachTime(b *testing.B) {
insertP := perm(benchmarkTreeSize)
for _, d := range degrees {
b.Run(fmt.Sprintf("degree=%d", d), func(b *testing.B) {
tr := New(d, less)
for _, m := range insertP {
tr.Set(m.Key, m.Value)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
tr = tr.Clone()
m := insertP[i%benchmarkTreeSize]
tr.Delete(m.Key)
tr.Set(m.Key, m.Value)
}
})
}
}
func BenchmarkDelete(b *testing.B) {
insertP := perm(benchmarkTreeSize)
removeP := perm(benchmarkTreeSize)
for _, d := range degrees {
b.Run(fmt.Sprintf("degree=%d", d), func(b *testing.B) {
i := 0
for i < b.N {
b.StopTimer()
tr := New(d, less)
for _, v := range insertP {
tr.Set(v.Key, v.Value)
}
b.StartTimer()
for _, m := range removeP {
tr.Delete(m.Key)
i++
if i >= b.N {
return
}
}
if tr.Len() > 0 {
panic(tr.Len())
}
}
})
}
}
func BenchmarkGet(b *testing.B) {
insertP := perm(benchmarkTreeSize)
getP := perm(benchmarkTreeSize)
for _, d := range degrees {
b.Run(fmt.Sprintf("degree=%d", d), func(b *testing.B) {
i := 0
for i < b.N {
b.StopTimer()
tr := New(d, less)
for _, v := range insertP {
tr.Set(v.Key, v.Value)
}
b.StartTimer()
for _, m := range getP {
tr.Get(m.Key)
i++
if i >= b.N {
return
}
}
}
})
}
}
func BenchmarkGetWithIndex(b *testing.B) {
insertP := perm(benchmarkTreeSize)
getP := perm(benchmarkTreeSize)
for _, d := range degrees {
b.Run(fmt.Sprintf("degree=%d", d), func(b *testing.B) {
i := 0
for i < b.N {
b.StopTimer()
tr := New(d, less)
for _, v := range insertP {
tr.Set(v.Key, v.Value)
}
b.StartTimer()
for _, m := range getP {
tr.GetWithIndex(m.Key)
i++
if i >= b.N {
return
}
}
}
})
}
}
func BenchmarkGetCloneEachTime(b *testing.B) {
insertP := perm(benchmarkTreeSize)
getP := perm(benchmarkTreeSize)
for _, d := range degrees {
b.Run(fmt.Sprintf("degree=%d", d), func(b *testing.B) {
i := 0
for i < b.N {
b.StopTimer()
tr := New(d, less)
for _, m := range insertP {
tr.Set(m.Key, m.Value)
}
b.StartTimer()
for _, m := range getP {
tr = tr.Clone()
tr.Get(m.Key)
i++
if i >= b.N {
return
}
}
}
})
}
}
func BenchmarkFind(b *testing.B) {
for _, d := range degrees {
var items []item
for i := 0; i < 2*d; i++ {
items = append(items, item{i, i})
}
b.Run(fmt.Sprintf("size=%d", len(items)), func(b *testing.B) {
for _, alg := range []struct {
name string
fun func(Key, []item) (int, bool)
}{
{"binary", findBinary},
{"linear", findLinear},
} {
b.Run(alg.name, func(b *testing.B) {
for i := 0; i < b.N; i++ {
for j := 0; j < len(items); j++ {
alg.fun(items[j].key, items)
}
}
})
}
})
}
}
func findBinary(k Key, s []item) (int, bool) {
i := sort.Search(len(s), func(i int) bool { return less(k, s[i].key) })
// i is the smallest index of s for which key.Less(s[i].Key), or len(s).
if i > 0 && !less(s[i-1], k) {
return i - 1, true
}
return i, false
}
func findLinear(k Key, s []item) (int, bool) {
var i int
for i = 0; i < len(s); i++ {
if less(k, s[i].key) {
break
}
}
if i > 0 && !less(s[i-1].key, k) {
return i - 1, true
}
return i, false
}
type byInts []item
func (a byInts) Len() int {
return len(a)
}
func (a byInts) Less(i, j int) bool {
return a[i].key.(int) < a[j].key.(int)
}
func (a byInts) Swap(i, j int) {
a[i], a[j] = a[j], a[i]
}
Mini Shell