Skip to content

B
b
Commit 5a1179fd authored by Jan Mercl's avatar Jan Mercl
Browse files
Options

Overhaul benchmarks

parent 0496ce60
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1564 additions and 357 deletions
all_test.go
View file @ 5a1179fd
This diff is collapsed.
btree.go
View file @ 5a1179fd
......@@ -35,56 +35,22 @@
// $ make generic | sed -e 's/key/int/g' -e 's/value/int/g' > example/int.go
//
// No other changes to int.go are (strictly) necessary, it compiles just fine.
// In a next step, benchmarks from all_test.go were copied into
// example/bench_test.go without any changes. A comparator is defined in
// bench_test.go like this:
//
// func cmp(a, b int) int {
// return a - b
// }
// Running the benchmarks for 1000 keys on a machine with Intel X5450 CPU @ 3
// GHz, Go release 1.3.
//
// Running the benchmarks on a machine with Intel X5450 CPU @ 3 GHz:
//
// Go release (1.1.2)
//
// $ go test -bench . example/bench_test.go example/int.go
// testing: warning: no tests to run
// PASS
// BenchmarkSetSeq 5000000 590 ns/op
// BenchmarkSetRnd 1000000 1530 ns/op
// BenchmarkGetSeq 10000000 373 ns/op
// BenchmarkGetRnd 2000000 1109 ns/op
// BenchmarkDelSeq 5000000 672 ns/op
// BenchmarkDelRnd 1000000 1275 ns/op
// BenchmarkSeekSeq 5000000 552 ns/op
// BenchmarkSeekRnd 1000000 1108 ns/op
// BenchmarkNext1e3 200000 13414 ns/op
// BenchmarkPrev1e3 200000 13215 ns/op
// ok command-line-arguments 51.372s
// $
//
// Go 1.2rc2
//
// $ go test -bench . example/bench_test.go example/int.go
// testing: warning: no tests to run
// $ go test -bench 1e3 example/all_test.go example/int.go
// PASS
// BenchmarkSetSeq 5000000 535 ns/op
// BenchmarkSetRnd 1000000 1428 ns/op
// BenchmarkGetSeq 10000000 376 ns/op
// BenchmarkGetRnd 2000000 1105 ns/op
// BenchmarkDelSeq 5000000 618 ns/op
// BenchmarkDelRnd 1000000 1213 ns/op
// BenchmarkSeekSeq 5000000 538 ns/op
// BenchmarkSeekRnd 1000000 1088 ns/op
// BenchmarkNext1e3 200000 13410 ns/op
// BenchmarkPrev1e3 200000 13528 ns/op
// ok command-line-arguments 48.823s
// $
//
// Note that the Next and Prev benchmarks enumerate 1000 items (KV pairs), so
// getting the next or previous iterated item is performed in about 13-14 ns.
// This is the nice O(1) property of B+trees usually not found in other tree
// types.
// BenchmarkSetSeq1e3 10000 263951 ns/op
// BenchmarkGetSeq1e3 10000 154410 ns/op
// BenchmarkSetRnd1e3 5000 392690 ns/op
// BenchmarkGetRnd1e3 10000 181776 ns/op
// BenchmarkDelRnd1e3 5000 323795 ns/op
// BenchmarkSeekSeq1e3 10000 235939 ns/op
// BenchmarkSeekRnd1e3 5000 299997 ns/op
// BenchmarkNext1e3 200000 14202 ns/op
// BenchmarkPrev1e3 200000 13842 ns/op
// ok command-line-arguments 30.620s
package b
import (
......
example/Makefile 0 → 100644
View file @ 5a1179fd
.PHONY: all todo clean cover
all: editor
go build
go vet
make todo
editor:
go fmt
go test -i
go test
todo:
@grep -n ^[[:space:]]*_[[:space:]]*=[[:space:]][[:alpha:]][[:alnum:]]* *.go || true
@grep -n TODO *.go || true
@grep -n BUG *.go || true
@grep -n println *.go || true
clean:
@go clean
rm -f *~
cover:
t=$(shell tempfile) ; go test -coverprofile $$t && go tool cover -html $$t && unlink $$t
example/all_test.go 0 → 100644
View file @ 5a1179fd
This diff is collapsed.
example/bench_test.go deleted 100644 → 0
View file @ 0496ce60
// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package b
import (
"math"
"runtime/debug"
"testing"
"github.com/cznic/mathutil"
)
func cmp(a, b int) int {
return a - b
}
func rng() *mathutil.FC32 {
x, err := mathutil.NewFC32(math.MinInt32, math.MaxInt32, false)
if err != nil {
panic(err)
}
return x
}
func BenchmarkSetSeq(b *testing.B) {
r := TreeNew(cmp)
debug.FreeOSMemory()
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Set(i, i)
}
}
func BenchmarkSetRnd(b *testing.B) {
r := TreeNew(cmp)
rng := rng()
a := make([]int, b.N)
for i := range a {
a[i] = rng.Next()
}
debug.FreeOSMemory()
b.ResetTimer()
for _, v := range a {
r.Set(v, 0)
}
}
func BenchmarkGetSeq(b *testing.B) {
r := TreeNew(cmp)
for i := 0; i < b.N; i++ {
r.Set(i, i)
}
debug.FreeOSMemory()
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Get(i)
}
}
func BenchmarkGetRnd(b *testing.B) {
r := TreeNew(cmp)
rng := rng()
a := make([]int, b.N)
for i := range a {
a[i] = rng.Next()
}
for _, v := range a {
r.Set(v, 0)
}
debug.FreeOSMemory()
b.ResetTimer()
for _, v := range a {
r.Get(v)
}
}
func BenchmarkDelSeq(b *testing.B) {
r := TreeNew(cmp)
for i := 0; i < b.N; i++ {
r.Set(i, i)
}
debug.FreeOSMemory()
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Delete(i)
}
}
func BenchmarkDelRnd(b *testing.B) {
r := TreeNew(cmp)
rng := rng()
a := make([]int, b.N)
for i := range a {
a[i] = rng.Next()
}
for _, v := range a {
r.Set(v, 0)
}
debug.FreeOSMemory()
b.ResetTimer()
for _, v := range a {
r.Delete(v)
}
}
func BenchmarkSeekSeq(b *testing.B) {
t := TreeNew(cmp)
for i := 0; i < b.N; i++ {
t.Set(i, 0)
}
debug.FreeOSMemory()
b.ResetTimer()
for i := 0; i < b.N; i++ {
t.Seek(i)
}
}
func BenchmarkSeekRnd(b *testing.B) {
r := TreeNew(cmp)
rng := rng()
a := make([]int, b.N)
for i := range a {
a[i] = rng.Next()
}
for _, v := range a {
r.Set(v, 0)
}
debug.FreeOSMemory()
b.ResetTimer()
for _, v := range a {
r.Seek(v)
}
}
func BenchmarkNext1e3(b *testing.B) {
const N = 1e3
t := TreeNew(cmp)
for i := 0; i < N; i++ {
t.Set(i, 0)
}
debug.FreeOSMemory()
b.ResetTimer()
for i := 0; i < b.N; i++ {
en, err := t.SeekFirst()
if err != nil {
b.Fatal(err)
}
n := 0
for {
if _, _, err = en.Next(); err != nil {
break
}
n++
}
if n != N {
b.Fatal(n)
}
}
}
func BenchmarkPrev1e3(b *testing.B) {
const N = 1e3
t := TreeNew(cmp)
for i := 0; i < N; i++ {
t.Set(i, 0)
}
debug.FreeOSMemory()
b.ResetTimer()
for i := 0; i < b.N; i++ {
en, err := t.SeekLast()
if err != nil {
b.Fatal(err)
}
n := 0
for {
if _, _, err = en.Prev(); err != nil {
break
}
n++
}
if n != N {
b.Fatal(n)
}
}
}
example/int.go
View file @ 5a1179fd
......@@ -2,27 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package b implements a B+tree.
//
// Keys and their associated values are interface{} typed, similarly to all of
// the containers in the standard library.
//
// Semiautomatic production of a type specific variant of this package is
// supported via
//
// $ make generic
//
// Performing it will write to stdout a version of the btree.go file where
// every key type occurrence is replaced by the word 'key' (written in all
// CAPS) and every value type occurrence is replaced by the word 'value'
// (written in all CAPS). Then you have to replace theses strings with your
// desired type(s), using any technique you're comfortable with.
//
// This is how, for example, 'example/int.go' was created:
//
// $ mkdir example
// $ make generic | sed -e 's/key/int/g' -e 's/value/int/g' > example/int.go
//
// Package b implements an int->int B+tree.
package b
import (
......@@ -233,8 +213,8 @@ func (t *Tree) catX(p, q, r *x, pi int) {
t.r = q //TODO recycle r
}
//Delete removes the k's KV pair, if it exists, in which case Delete returns
//true.
// Delete removes the k's KV pair, if it exists, in which case Delete returns
// true.
func (t *Tree) Delete(k int) (ok bool) {
pi := -1
var p *x
......@@ -341,7 +321,7 @@ func (t *Tree) find(q interface{}, k int) (i int, ok bool) {
}
// First returns the first item of the tree in the key collating order, or
// (nil, nil) if the tree is empty.
// (zero-value, zero-value) if the tree is empty.
func (t *Tree) First() (k int, v int) {
if q := t.first; q != nil {
q := &q.d[0]
......@@ -351,7 +331,7 @@ func (t *Tree) First() (k int, v int) {
}
// Get returns the value associated with k and true if it exists. Otherwise Get
// returns (nil, false).
// returns (zero-value, false).
func (t *Tree) Get(k int) (v int, ok bool) {
q := t.r
if q == nil {
......@@ -390,8 +370,8 @@ func (t *Tree) insert(q *d, i int, k int, v int) *d {
return q
}
// Last returns the last item of the tree in the key collating order, or (nil,
// nil) if the tree is empty.
// Last returns the last item of the tree in the key collating order, or
// (zero-value, zero-value) if the tree is empty.
func (t *Tree) Last() (k int, v int) {
if q := t.last; q != nil {
q := &q.d[q.c-1]
......@@ -525,6 +505,84 @@ func (t *Tree) Set(k int, v int) {
return
}
// Put combines Get and Set in a more efficient way where the tree is walked
// only once. The upd(ater) receives (old-value, true) if a KV pair for k
// exists or (zero-value, false) otherwise. It can then return a (new-value,
// true) to create or overwrite the existing value in the KV pair, or
// (whatever, false) if it decides not to create or not to update the value of
// the KV pair.
//
// tree.Set(k, v) conceptually equals
//
// tree.Put(k, func(k, v []byte){ return v, true }([]byte, bool))
//
// modulo the differing return values.
func (t *Tree) Put(k int, upd func(oldV int, exists bool) (newV int, write bool)) (oldV int, written bool) {
pi := -1
var p *x
q := t.r
var newV int
if q != nil {
for {
i, ok := t.find(q, k)
if ok {
switch x := q.(type) {
case *x:
oldV = x.x[i].sep.d[0].v
newV, written = upd(oldV, true)
if !written {
return
}
x.x[i].sep.d[0].v = newV
case *d:
oldV = x.d[i].v
newV, written = upd(oldV, true)
if !written {
return
}
x.d[i].v = newV
}
return
}
switch x := q.(type) {
case *x:
if x.c > 2*kx {
t.splitX(p, &x, pi, &i)
}
pi = i
p = x
q = x.x[i].ch
case *d: // new KV pair
newV, written = upd(newV, false)
if !written {
return
}
switch {
case x.c < 2*kd:
t.insert(x, i, k, newV)
default:
t.overflow(p, x, pi, i, k, newV)
}
return
}
}
}
// new KV pair in empty tree
newV, written = upd(newV, false)
if !written {
return
}
z := t.insert(&d{}, 0, k, newV)
t.r, t.first, t.last = z, z, z
return
}
func (t *Tree) split(p *x, q *d, pi, i int, k int, v int) {
t.ver++
r := &d{}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7