add benchmarks

store/store.go

@@ -317,16 +317,23 @@ func (s *Store) RawGet(key string) ([]*Response, error) {
 
 			var TTL int64
 			var isExpire bool = false
+			var thisKey string
 
 			isExpire = !nodes[i].ExpireTime.Equal(PERMANENT)
 
+			if keys != nil {
+				thisKey = path.Join(key, keys[i])
+			} else {
+				thisKey = key
+			}
+
 			resps[i] = &Response{
 				Action: "GET",
 				Index:  s.Index,
-				Key:    path.Join(key, keys[i]),
+				Key:    thisKey,
 			}
 
-			if !dirs[i] {
+			if dirs == nil || !dirs[i] {
 				resps[i].Value = nodes[i].Value
 			} else {
 				resps[i].Dir = true

store/store_test.go

@@ -2,7 +2,6 @@ package store
 
 import (
 	"encoding/json"
-	"fmt"
 	"testing"
 	"time"
 )
@@ -70,9 +69,6 @@ func TestSaveAndRecovery(t *testing.T) {
 }
 
 func TestExpire(t *testing.T) {
-	fmt.Println(time.Now())
-	fmt.Println("TEST EXPIRE")
-
 	// test expire
 	s := CreateStore(100)
 	s.Set("foo", "bar", time.Now().Add(time.Second*1), 0)
@@ -134,3 +130,79 @@ func TestExpire(t *testing.T) {
 	}
 
 }
+
+func BenchmarkSet(b *testing.B) {
+	s := CreateStore(100)
+
+	keys := GenKeys(10000, 5)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+
+		for i, key := range keys {
+			s.Set(key, "barbarbarbarbar", time.Unix(0, 0), uint64(i))
+		}
+
+		s = CreateStore(100)
+	}
+}
+
+func BenchmarkGet(b *testing.B) {
+	s := CreateStore(100)
+
+	keys := GenKeys(100, 5)
+
+	for i, key := range keys {
+		s.Set(key, "barbarbarbarbar", time.Unix(0, 0), uint64(i))
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+
+		for _, key := range keys {
+			s.Get(key)
+		}
+
+	}
+}
+
+func BenchmarkSetAndGet(b *testing.B) {
+
+}
+
+func BenchmarkSnapshotSave(b *testing.B) {
+	s := CreateStore(100)
+
+	keys := GenKeys(10000, 5)
+
+	for i, key := range keys {
+		s.Set(key, "barbarbarbarbar", time.Unix(0, 0), uint64(i))
+	}
+
+	var state []byte
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		state, _ = s.Save()
+	}
+	b.SetBytes(int64(len(state)))
+}
+
+func BenchmarkSnapshotRecovery(b *testing.B) {
+	s := CreateStore(100)
+
+	keys := GenKeys(10000, 5)
+
+	for i, key := range keys {
+		s.Set(key, "barbarbarbarbar", time.Unix(0, 0), uint64(i))
+	}
+
+	state, _ := s.Save()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		newStore := CreateStore(100)
+		newStore.Recovery(state)
+	}
+	b.SetBytes(int64(len(state)))
+}

store/tree.go

@@ -167,7 +167,7 @@ func (t *tree) list(directory string) ([]Node, []string, []bool, bool) {
 		if !treeNode.Dir {
 			nodes := make([]Node, 1)
 			nodes[0] = treeNode.InternalNode
-			return nodes, make([]string, 1), make([]bool, 1), true
+			return nodes, nil, nil, true
 		}
 		length := len(treeNode.NodeMap)
 		nodes := make([]Node, length)

store/tree_store_test.go

@@ -76,20 +76,15 @@ func TestStoreGet(t *testing.T) {
 		}
 	}
 
-	// speed test
+	keys = GenKeys(100, 10)
+
 	for i := 0; i < 100; i++ {
-		key := "/"
-		depth := rand.Intn(10)
-		for j := 0; j < depth; j++ {
-			key += "/" + strconv.Itoa(rand.Int()%10)
-		}
 		value := strconv.Itoa(rand.Int())
-		ts.set(key, CreateTestNode(value))
-		treeNode, ok := ts.get(key)
+		ts.set(keys[i], CreateTestNode(value))
+		treeNode, ok := ts.get(keys[i])
 
 		if !ok {
 			continue
-			//t.Fatalf("Expect to get node, but not")
 		}
 		if treeNode.Value != value {
 			t.Fatalf("Expect value %s, but got %s", value, treeNode.Value)
@@ -99,6 +94,78 @@ func TestStoreGet(t *testing.T) {
 	ts.traverse(f, true)
 }
 
+func BenchmarkTreeStoreSet(b *testing.B) {
+
+	keys := GenKeys(10000, 10)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+
+		ts := &tree{
+			&treeNode{
+				CreateTestNode("/"),
+				true,
+				make(map[string]*treeNode),
+			},
+		}
+
+		for _, key := range keys {
+			value := strconv.Itoa(rand.Int())
+			ts.set(key, CreateTestNode(value))
+		}
+	}
+}
+
+func BenchmarkTreeStoreGet(b *testing.B) {
+
+	keys := GenKeys(10000, 10)
+
+	ts := &tree{
+		&treeNode{
+			CreateTestNode("/"),
+			true,
+			make(map[string]*treeNode),
+		},
+	}
+
+	for _, key := range keys {
+		value := strconv.Itoa(rand.Int())
+		ts.set(key, CreateTestNode(value))
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, key := range keys {
+			ts.get(key)
+		}
+	}
+}
+
+func BenchmarkTreeStoreList(b *testing.B) {
+
+	keys := GenKeys(10000, 10)
+
+	ts := &tree{
+		&treeNode{
+			CreateTestNode("/"),
+			true,
+			make(map[string]*treeNode),
+		},
+	}
+
+	for _, key := range keys {
+		value := strconv.Itoa(rand.Int())
+		ts.set(key, CreateTestNode(value))
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, key := range keys {
+			ts.list(key)
+		}
+	}
+}
+
 func f(key string, n *Node) {
 	fmt.Println(key, "=", n.Value)
 }

store/watcher_test.go

@@ -1,8 +1,6 @@
 package store
 
 import (
-	"math/rand"
-	"strconv"
 	"testing"
 	"time"
 )
@@ -62,16 +60,7 @@ func TestWatch(t *testing.T) {
 func BenchmarkWatch(b *testing.B) {
 	s := CreateStore(100)
 
-	key := make([]string, 10000)
-	for i := 0; i < 10000; i++ {
-
-		key[i] = "/foo/"
-		depth := rand.Intn(10)
-
-		for j := 0; j < depth; j++ {
-			key[i] += "/" + strconv.Itoa(rand.Int()%10)
-		}
-	}
+	keys := GenKeys(10000, 10)
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -80,7 +69,7 @@ func BenchmarkWatch(b *testing.B) {
 			// create a new watcher
 			watchers[i] = NewWatcher()
 			// add to the watchers list
-			s.AddWatcher(key[i], watchers[i], 0)
+			s.AddWatcher(keys[i], watchers[i], 0)
 		}
 
 		s.watcher.stopWatchers()