1
package kv
2
 
3
import (
4
	"context"
5
	"crypto/rand"
6
	"os"
7
	"testing"
8
	"time"
9
 
10
	"go.miragespace.co/specter/kv/aof"
11
	"go.miragespace.co/specter/kv/memory"
12
	"go.miragespace.co/specter/kv/sqlite3"
13
	"go.miragespace.co/specter/spec/chord"
14
 
15
	"go.uber.org/zap"
16
	"go.uber.org/zap/zapcore"
17
)
18
 
19
var e1 error
20
var e2 error
21
var e3 error
22
 
23
func BenchmarkSqliteKVPut(b *testing.B) {
24
	config := zap.NewDevelopmentConfig()
25
	config.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
26
	// Redirect everything to stderr
27
	config.OutputPaths = []string{"/dev/null"}
28
	logger, err := config.Build()
29
	if err != nil {
30
		b.Errorf("setting up logger: %v", err)
31
	}
32
 
33
	dir, err := os.MkdirTemp("", "sqlite")
34
	if err != nil {
35
		b.Errorf("creating temporary storage: %v", err)
36
	}
37
	b.Cleanup(func() {
38
		os.RemoveAll(dir)
39
	})
40
 
41
	cfg := sqlite3.Config{
42
		Logger:  logger,
43
		HashFn:  chord.Hash,
44
		DataDir: dir,
45
	}
46
 
47
	kv, err := sqlite3.New(cfg)
48
	if err != nil {
49
		b.Errorf("initializing kv: %v", err)
50
	}
51
 
52
	key := make([]byte, 32)
53
	value := make([]byte, 256)
54
 
55
	c := context.Background()
56
	b.ResetTimer()
57
 
58
	var putErr error
59
	for i := 0; i < b.N; i++ {
60
		b.StopTimer()
61
		rand.Read(key)
62
		rand.Read(value)
63
		b.StartTimer()
64
		putErr = kv.Put(c, key, value)
65
	}
66
	e3 = putErr
67
}
68
 
69
func BenchmarkAOFKVPut(b *testing.B) {
70
	config := zap.NewDevelopmentConfig()
71
	config.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
72
	// Redirect everything to stderr
73
	config.OutputPaths = []string{"/dev/null"}
74
	logger, err := config.Build()
75
	if err != nil {
76
		b.Errorf("setting up logger: %v", err)
77
	}
78
 
79
	dir, err := os.MkdirTemp("", "aof")
80
	if err != nil {
81
		b.Errorf("creating temporary storage: %v", err)
82
	}
83
	b.Cleanup(func() {
84
		os.RemoveAll(dir)
85
	})
86
 
87
	cfg := aof.Config{
88
		Logger:        logger,
89
		HasnFn:        chord.Hash,
90
		DataDir:       dir,
91
		FlushInterval: time.Second,
92
	}
93
 
94
	kv, err := aof.New(cfg)
95
	if err != nil {
96
		b.Errorf("initializing kv: %v", err)
97
	}
98
	b.Cleanup(kv.Stop)
99
 
100
	key := make([]byte, 32)
101
	value := make([]byte, 256)
102
 
103
	go kv.Start()
104
	c := context.Background()
105
	b.ResetTimer()
106
 
107
	var putErr error
108
	for i := 0; i < b.N; i++ {
109
		b.StopTimer()
110
		rand.Read(key)
111
		rand.Read(value)
112
		b.StartTimer()
113
		putErr = kv.Put(c, key, value)
114
	}
115
	e1 = putErr
116
}
117
 
118
func BenchmarkMemoryKVPut(b *testing.B) {
119
	kv := memory.WithHashFn(chord.Hash)
120
 
121
	key := make([]byte, 32)
122
	value := make([]byte, 256)
123
 
124
	c := context.Background()
125
	b.ResetTimer()
126
 
127
	var putErr error
128
	for i := 0; i < b.N; i++ {
129
		b.StopTimer()
130
		rand.Read(key)
131
		rand.Read(value)
132
		b.StartTimer()
133
		putErr = kv.Put(c, key, value)
134
	}
135
	e2 = putErr
136
}