Improved benchmark test suite for various key/value sizes

.gitignore

@@ -3,5 +3,6 @@
 
 /coverage.txt
 /bitcask
+/bitcaskd
 /tmp
 /dist

.goreleaser.yml

@@ -1,10 +1,18 @@
 builds:
   - 
+    binary: bitcask
     main: ./cmd/bitcask
     flags: -tags "static_build"
     ldflags: -w -X .Version={{.Version}} -X .Commit={{.Commit}}
     env:
       - CGO_ENABLED=0
+  - 
+    binary: bitcaskd
+    main: ./cmd/bitcaskd
+    flags: -tags "static_build"
+    ldflags: -w -X .Version={{.Version}} -X .Commit={{.Commit}}
+    env:
+      - CGO_ENABLED=0
 sign:
   artifacts: checksum
 archive:

Makefile

@@ -1,18 +1,24 @@
 .PHONY: dev build generate install image release profile bench test clean
 
 CGO_ENABLED=0
+VERSION=$(shell git describe --abbrev=0 --tags)
 COMMIT=$(shell git rev-parse --short HEAD)
 
 all: dev
 
 dev: build
 	@./bitcask --version
+	@./bitcaskd --version
 
 build: clean generate
 	@go build \
 		-tags "netgo static_build" -installsuffix netgo \
-		-ldflags "-w -X $(shell go list)/.Commit=$(COMMIT)" \
+		-ldflags "-w -X $(shell go list).Version=$(VERSION) -X $(shell go list).Commit=$(COMMIT)" \
 		./cmd/bitcask/...
+	@go build \
+		-tags "netgo static_build" -installsuffix netgo \
+		-ldflags "-w -X $(shell go list).Version=$(VERSION) -X $(shell go list).Commit=$(COMMIT)" \
+		./cmd/bitcaskd/...
 
 generate:
 	@go generate $(shell go list)/...

README.md

@@ -12,6 +12,10 @@ A Bitcask (LSM+WAL) Key/Value Store written in Go.
 
 * Embeddable
 * Builtin CLI
+* Builtin Redis-compatible server
+* Predictable read/write performance
+* Low latecny
+* High throughput (See: [Performance](README.md#Performance)
 
 ## Install
 
@@ -54,6 +58,38 @@ $ bitcask -p /tmp/db get Hello
 World
 ```
 
+## Usage (server)
+
+There is also a builtin very  simple Redis-compatible server called `bitcaskd`:
+
+```#!bash
+$ ./bitcaskd ./tmp
+INFO[0000] starting bitcaskd v0.0.7@146f777              bind=":6379" path=./tmp
+```
+
+Example session:
+
+```
+$ telnet localhost 6379
+Trying ::1...
+Connected to localhost.
+Escape character is '^]'.
+SET foo bar
++OK
+GET foo
+$3
+bar
+DEL foo
+:1
+GET foo
+$-1
+PING
++PONG
+QUIT
++OK
+Connection closed by foreign host.
+```
+
 ## Performance
 
 Benchmarks run on a 11" Macbook with a 1.4Ghz Intel Core i7:
@@ -61,13 +97,32 @@ Benchmarks run on a 11" Macbook with a 1.4Ghz Intel Core i7:
 ```
 $ make bench
 ...
-BenchmarkGet-4   	  300000	      5065 ns/op	     144 B/op	       4 allocs/op
-BenchmarkPut-4   	  100000	     14640 ns/op	     699 B/op	       7 allocs/op
+BenchmarkGet/128B-4         	  200000	      5780 ns/op	     400 B/op	       5 allocs/op
+BenchmarkGet/256B-4         	  200000	      6138 ns/op	     656 B/op	       5 allocs/op
+BenchmarkGet/512B-4         	  200000	      5967 ns/op	    1200 B/op	       5 allocs/op
+BenchmarkGet/1K-4           	  200000	      6290 ns/op	    2288 B/op	       5 allocs/op
+BenchmarkGet/2K-4           	  200000	      6293 ns/op	    4464 B/op	       5 allocs/op
+BenchmarkGet/4K-4           	  200000	      7673 ns/op	    9072 B/op	       5 allocs/op
+BenchmarkGet/8K-4           	  200000	     10373 ns/op	   17776 B/op	       5 allocs/op
+BenchmarkGet/16K-4          	  100000	     14227 ns/op	   34928 B/op	       5 allocs/op
+BenchmarkGet/32K-4          	  100000	     25953 ns/op	   73840 B/op	       5 allocs/op
+BenchmarkPut/128B-4         	  100000	     17353 ns/op	     680 B/op	       5 allocs/op
+BenchmarkPut/256B-4         	  100000	     18620 ns/op	     808 B/op	       5 allocs/op
+BenchmarkPut/512B-4         	  100000	     19068 ns/op	    1096 B/op	       5 allocs/op
+BenchmarkPut/1K-4           	  100000	     23738 ns/op	    1673 B/op	       5 allocs/op
+BenchmarkPut/2K-4           	   50000	     25118 ns/op	    2826 B/op	       5 allocs/op
+BenchmarkPut/4K-4           	   50000	     44605 ns/op	    5389 B/op	       5 allocs/op
+BenchmarkPut/8K-4           	   30000	     55237 ns/op	   10001 B/op	       5 allocs/op
+BenchmarkPut/16K-4          	   20000	     78966 ns/op	   18972 B/op	       5 allocs/op
+BenchmarkPut/32K-4          	   10000	    116253 ns/op	   41520 B/op	       5 allocs/op
 ```
 
-* ~30,000 reads/sec for non-active data
-* ~180,000 reads/sec for active data
-* ~60,000 writes/sec
+For 128B values:
+
+* ~180,000 reads/sec
+*  ~60,000 writes/sec
+
+The full benchmark above shows linear performance as you increase key/value sizes.
 
 ## License
 

bitcask.go

@@ -135,7 +135,7 @@ func (b *Bitcask) setMaxDatafileSize(size int64) error {
 	return nil
 }
 
-func MaxDatafileSize(size int64) func(*Bitcask) error {
+func WithMaxDatafileSize(size int64) func(*Bitcask) error {
 	return func(b *Bitcask) error {
 		return b.setMaxDatafileSize(size)
 	}

bitcask_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"strings"
+	"sync"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -140,7 +141,7 @@ func TestMerge(t *testing.T) {
 		)
 
 		t.Run("Open", func(t *testing.T) {
-			db, err = Open(testdir, MaxDatafileSize(1024))
+			db, err = Open(testdir, WithMaxDatafileSize(1024))
 			assert.NoError(err)
 		})
 
@@ -198,6 +199,86 @@ func TestMerge(t *testing.T) {
 	})
 }
 
+func TestConcurrent(t *testing.T) {
+	var (
+		db  *Bitcask
+		err error
+	)
+
+	assert := assert.New(t)
+
+	testdir, err := ioutil.TempDir("", "bitcask")
+	assert.NoError(err)
+
+	t.Run("Setup", func(t *testing.T) {
+		t.Run("Open", func(t *testing.T) {
+			db, err = Open(testdir)
+			assert.NoError(err)
+		})
+
+		t.Run("Put", func(t *testing.T) {
+			err = db.Put("foo", []byte("bar"))
+			assert.NoError(err)
+		})
+	})
+
+	t.Run("Concurrent", func(t *testing.T) {
+		t.Run("Put", func(t *testing.T) {
+			f := func(wg *sync.WaitGroup, x int) {
+				defer func() {
+					wg.Done()
+				}()
+				for i := 0; i <= 100; i++ {
+					if i%x == 0 {
+						key := fmt.Sprintf("k%d", i)
+						value := []byte(fmt.Sprintf("v%d", i))
+						err := db.Put(key, value)
+						assert.NoError(err)
+					}
+				}
+			}
+
+			wg := &sync.WaitGroup{}
+
+			go f(wg, 2)
+			wg.Add(1)
+
+			go f(wg, 3)
+			wg.Add(1)
+
+			wg.Wait()
+		})
+
+		t.Run("Get", func(t *testing.T) {
+			f := func(wg *sync.WaitGroup, N int) {
+				defer func() {
+					wg.Done()
+				}()
+				for i := 0; i <= N; i++ {
+					value, err := db.Get("foo")
+					assert.NoError(err)
+					assert.Equal([]byte("bar"), value)
+				}
+			}
+
+			wg := &sync.WaitGroup{}
+
+			go f(wg, 100)
+			wg.Add(1)
+
+			go f(wg, 100)
+			wg.Add(1)
+
+			wg.Wait()
+		})
+
+		t.Run("Close", func(t *testing.T) {
+			err = db.Close()
+			assert.NoError(err)
+		})
+	})
+}
+
 func TestLocking(t *testing.T) {
 	assert := assert.New(t)
 
@@ -213,6 +294,11 @@ func TestLocking(t *testing.T) {
 	assert.Equal("error: cannot acquire lock", err.Error())
 }
 
+type benchmarkTestCase struct {
+	name string
+	size int
+}
+
 func BenchmarkGet(b *testing.B) {
 	testdir, err := ioutil.TempDir("", "bitcask")
 	if err != nil {
@@ -225,20 +311,39 @@ func BenchmarkGet(b *testing.B) {
 	}
 	defer db.Close()
 
-	err = db.Put("foo", []byte("bar"))
-	if err != nil {
-		b.Fatal(err)
+	tests := []benchmarkTestCase{
+		{"128B", 128},
+		{"256B", 256},
+		{"512B", 512},
+		{"1K", 1024},
+		{"2K", 2048},
+		{"4K", 4096},
+		{"8K", 8192},
+		{"16K", 16384},
+		{"32K", 32768},
 	}
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		val, err := db.Get("foo")
-		if err != nil {
-			b.Fatal(err)
-		}
-		if string(val) != "bar" {
-			b.Errorf("expected val=bar got=%s", val)
-		}
+	for _, tt := range tests {
+		b.Run(tt.name, func(b *testing.B) {
+			key := "foo"
+			value := []byte(strings.Repeat(" ", tt.size))
+
+			err = db.Put(key, value)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				val, err := db.Get(key)
+				if err != nil {
+					b.Fatal(err)
+				}
+				if string(val) != string(value) {
+					b.Errorf("unexpected value")
+				}
+			}
+		})
 	}
 }
 
@@ -254,11 +359,29 @@ func BenchmarkPut(b *testing.B) {
 	}
 	defer db.Close()
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		err := db.Put(fmt.Sprintf("key%d", i), []byte("bar"))
-		if err != nil {
-			b.Fatal(err)
-		}
+	tests := []benchmarkTestCase{
+		{"128B", 128},
+		{"256B", 256},
+		{"512B", 512},
+		{"1K", 1024},
+		{"2K", 2048},
+		{"4K", 4096},
+		{"8K", 8192},
+		{"16K", 16384},
+		{"32K", 32768},
+	}
+
+	for _, tt := range tests {
+		b.Run(tt.name, func(b *testing.B) {
+			key := "foo"
+			value := []byte(strings.Repeat(" ", tt.size))
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				err := db.Put(key, value)
+				if err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
 	}
 }

cmd/bitcaskd/main.go

@@ -0,0 +1,123 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+	flag "github.com/spf13/pflag"
+	"github.com/tidwall/redcon"
+
+	"github.com/prologic/bitcask"
+)
+
+var (
+	bind            string
+	debug           bool
+	version         bool
+	maxDatafileSize int64
+)
+
+func init() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "Usage: %s [options] <path>\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+
+	flag.BoolVarP(&version, "version", "v", false, "display version information")
+	flag.BoolVarP(&debug, "debug", "d", false, "enable debug logging")
+
+	flag.StringVarP(&bind, "bind", "b", ":6379", "interface and port to bind to")
+
+	flag.Int64Var(&maxDatafileSize, "max-datafile-size", 1<<20, "maximum datafile size in bytes")
+}
+
+func main() {
+	flag.Parse()
+
+	if debug {
+		log.SetLevel(log.DebugLevel)
+	} else {
+		log.SetLevel(log.InfoLevel)
+	}
+
+	if version {
+		fmt.Printf("bitcaskd version %s", bitcask.FullVersion())
+		os.Exit(0)
+	}
+
+	if len(flag.Args()) < 1 {
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	path := flag.Arg(0)
+
+	db, err := bitcask.Open(path, bitcask.WithMaxDatafileSize(maxDatafileSize))
+	if err != nil {
+		log.WithError(err).WithField("path", path).Error("error opening database")
+		os.Exit(1)
+	}
+
+	log.WithField("bind", bind).WithField("path", path).Infof("starting bitcaskd v%s", bitcask.FullVersion())
+
+	err = redcon.ListenAndServe(bind,
+		func(conn redcon.Conn, cmd redcon.Command) {
+			switch strings.ToLower(string(cmd.Args[0])) {
+			case "ping":
+				conn.WriteString("PONG")
+			case "quit":
+				conn.WriteString("OK")
+				conn.Close()
+			case "set":
+				if len(cmd.Args) != 3 {
+					conn.WriteError("ERR wrong number of arguments for '" + string(cmd.Args[0]) + "' command")
+					return
+				}
+				key := string(cmd.Args[1])
+				value := cmd.Args[2]
+				err = db.Put(key, value)
+				if err != nil {
+					conn.WriteString(fmt.Sprintf("ERR: %s", err))
+				} else {
+					conn.WriteString("OK")
+				}
+			case "get":
+				if len(cmd.Args) != 2 {
+					conn.WriteError("ERR wrong number of arguments for '" + string(cmd.Args[0]) + "' command")
+					return
+				}
+				key := string(cmd.Args[1])
+				value, err := db.Get(key)
+				if err != nil {
+					conn.WriteNull()
+				} else {
+					conn.WriteBulk(value)
+				}
+			case "del":
+				if len(cmd.Args) != 2 {
+					conn.WriteError("ERR wrong number of arguments for '" + string(cmd.Args[0]) + "' command")
+					return
+				}
+				key := string(cmd.Args[1])
+				err := db.Delete(key)
+				if err != nil {
+					conn.WriteInt(0)
+				} else {
+					conn.WriteInt(1)
+				}
+			default:
+				conn.WriteError("ERR unknown command '" + string(cmd.Args[0]) + "'")
+			}
+		},
+		func(conn redcon.Conn) bool {
+			return true
+		},
+		func(conn redcon.Conn, err error) {
+		},
+	)
+	if err != nil {
+		log.WithError(err).Fatal("oops")
+	}
+}

datafile.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sync"
 	"time"
 
 	pb "github.com/prologic/bitcask/proto"
@@ -20,6 +21,8 @@ var (
 )
 
 type Datafile struct {
+	sync.RWMutex
+
 	id  int
 	r   *os.File
 	w   *os.File
@@ -102,17 +105,23 @@ func (df *Datafile) Size() (int64, error) {
 	return stat.Size(), nil
 }
 
-func (df *Datafile) Read() (pb.Entry, error) {
-	var e pb.Entry
+func (df *Datafile) Read() (e pb.Entry, err error) {
+	df.Lock()
+	defer df.Unlock()
+
 	return e, df.dec.Decode(&e)
 }
 
 func (df *Datafile) ReadAt(index int64) (e pb.Entry, err error) {
+	df.Lock()
+	defer df.Unlock()
+
 	_, err = df.r.Seek(index, os.SEEK_SET)
 	if err != nil {
 		return
 	}
-	return df.Read()
+
+	return e, df.dec.Decode(&e)
 }
 
 func (df *Datafile) Write(e pb.Entry) (int64, error) {
@@ -130,7 +139,10 @@ func (df *Datafile) Write(e pb.Entry) (int64, error) {
 	e.Index = index
 	e.Timestamp = time.Now().Unix()
 
+	df.Lock()
 	err = df.enc.Encode(&e)
+	df.Unlock()
+
 	if err != nil {
 		return -1, err
 	}

go.mod

@@ -12,7 +12,9 @@ require (
 	github.com/prometheus/client_golang v0.9.2 // indirect
 	github.com/sirupsen/logrus v1.3.0
 	github.com/spf13/cobra v0.0.3
+	github.com/spf13/pflag v1.0.3
 	github.com/spf13/viper v1.3.1
 	github.com/stretchr/testify v1.3.0
+	github.com/tidwall/redcon v0.9.0
 	gopkg.in/vmihailenco/msgpack.v2 v2.9.1
 )

go.sum

@@ -67,6 +67,8 @@ github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/tidwall/redcon v0.9.0 h1:tiT9DLAoohsdNaFg9Si5dRsv9+FjvZYnhMOEtSFwBqA=
+github.com/tidwall/redcon v0.9.0/go.mod h1:bdYBm4rlcWpst2XMwKVzWDF9CoUxEbUmM7CQrKeOZas=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=

streampb/stream.go

@@ -16,26 +16,27 @@ const (
 
 // NewEncoder creates a streaming protobuf encoder.
 func NewEncoder(w io.Writer) *Encoder {
-	return &Encoder{w: w, prefixBuf: make([]byte, prefixSize)}
+	return &Encoder{w}
 }
 
 // Encoder wraps an underlying io.Writer and allows you to stream
 // proto encodings on it.
 type Encoder struct {
-	w         io.Writer
-	prefixBuf []byte
+	w io.Writer
 }
 
 // Encode takes any proto.Message and streams it to the underlying writer.
 // Messages are framed with a length prefix.
 func (e *Encoder) Encode(msg proto.Message) error {
+	prefixBuf := make([]byte, prefixSize)
+
 	buf, err := proto.Marshal(msg)
 	if err != nil {
 		return err
 	}
-	binary.BigEndian.PutUint64(e.prefixBuf, uint64(len(buf)))
+	binary.BigEndian.PutUint64(prefixBuf, uint64(len(buf)))
 
-	if _, err := e.w.Write(e.prefixBuf); err != nil {
+	if _, err := e.w.Write(prefixBuf); err != nil {
 		return errors.Wrap(err, "failed writing length prefix")
 	}
 
@@ -45,28 +46,26 @@ func (e *Encoder) Encode(msg proto.Message) error {
 
 // NewDecoder creates a streaming protobuf decoder.
 func NewDecoder(r io.Reader) *Decoder {
-	return &Decoder{
-		r:         r,
-		prefixBuf: make([]byte, prefixSize),
-	}
+	return &Decoder{r: r}
 }
 
 // Decoder wraps an underlying io.Reader and allows you to stream
 // proto decodings on it.
 type Decoder struct {
-	r         io.Reader
-	prefixBuf []byte
+	r io.Reader
 }
 
 // Decode takes a proto.Message and unmarshals the next payload in the
 // underlying io.Reader. It returns an EOF when it's done.
 func (d *Decoder) Decode(v proto.Message) error {
-	_, err := io.ReadFull(d.r, d.prefixBuf)
+	prefixBuf := make([]byte, prefixSize)
+
+	_, err := io.ReadFull(d.r, prefixBuf)
 	if err != nil {
 		return err
 	}
 
-	n := binary.BigEndian.Uint64(d.prefixBuf)
+	n := binary.BigEndian.Uint64(prefixBuf)
 
 	buf := make([]byte, n)