New standard GO project layout

[ric-plt/appmgr.git] / internal / sdlgo / bench_test.go

diff --git a/internal/sdlgo/bench_test.go b/internal/sdlgo/bench_test.go
new file mode 100644 (file)
index 0000000..9f70fe6
--- /dev/null
+++ b/internal/sdlgo/bench_test.go
@@ -0,0 +1,173 @@
+package sdlgo_test
+
+import (
+       "fmt"
+       "strconv"
+       "strings"
+       "testing"
+
+       "gitlabe1.ext.net.nokia.com/ric_dev/sdlgo"
+)
+
+type singleBenchmark struct {
+       key       string
+       keySize   int
+       valueSize int
+}
+
+type multiBenchmark struct {
+       keyBase   string
+       keyCount  int
+       keySize   int
+       valueSize int
+}
+
+func (bm singleBenchmark) String(oper string) string {
+       return fmt.Sprintf("op = %s key=%d value=%d", oper, bm.keySize, bm.valueSize)
+}
+
+func (bm multiBenchmark) String(oper string) string {
+       return fmt.Sprintf("op = %s keycnt=%d key=%d value=%d", oper, bm.keyCount, bm.keySize, bm.valueSize)
+}
+func BenchmarkSet(b *testing.B) {
+       benchmarks := []singleBenchmark{
+               {"a", 10, 64},
+               {"b", 10, 1024},
+               {"c", 10, 64 * 1024},
+               {"d", 10, 1024 * 1024},
+               {"e", 10, 10 * 1024 * 1024},
+
+               {"f", 100, 64},
+               {"g", 100, 1024},
+               {"h", 100, 64 * 1024},
+               {"i", 100, 1024 * 1024},
+               {"j", 100, 10 * 1024 * 1024},
+       }
+
+       for _, bm := range benchmarks {
+               b.Run(bm.String("set"), func(b *testing.B) {
+                       key := strings.Repeat(bm.key, bm.keySize)
+                       value := strings.Repeat("1", bm.valueSize)
+                       sdl := sdlgo.Create("namespace")
+
+                       b.ResetTimer()
+                       b.RunParallel(func(pb *testing.PB) {
+                               for pb.Next() {
+                                       err := sdl.Set(key, value)
+                                       if err != nil {
+                                               b.Fatal(err)
+                                       }
+                               }
+                       })
+               })
+       }
+}
+
+func BenchmarkGet(b *testing.B) {
+       benchmarks := []singleBenchmark{
+               {"a", 10, 64},
+               {"b", 10, 1024},
+               {"c", 10, 64 * 1024},
+               {"d", 10, 1024 * 1024},
+               {"e", 10, 10 * 1024 * 1024},
+
+               {"f", 100, 64},
+               {"g", 100, 1024},
+               {"h", 100, 64 * 1024},
+               {"i", 100, 1024 * 1024},
+               {"j", 100, 10 * 1024 * 1024},
+       }
+
+       for _, bm := range benchmarks {
+               b.Run(bm.String("Get"), func(b *testing.B) {
+                       key := strings.Repeat(bm.key, bm.keySize)
+                       value := strings.Repeat("1", bm.valueSize)
+                       sdl := sdlgo.Create("namespace")
+                       if err := sdl.Set(key, value); err != nil {
+                               b.Fatal(err)
+                       }
+                       b.ResetTimer()
+                       b.RunParallel(func(pb *testing.PB) {
+                               for pb.Next() {
+                                       _, err := sdl.Get([]string{key})
+                                       if err != nil {
+                                               b.Fatal(err)
+                                       }
+                               }
+                       })
+               })
+       }
+}
+
+func BenchmarkMultiSet(b *testing.B) {
+       benchmarks := []multiBenchmark{
+               {"a", 2, 10, 64},
+               {"b", 10, 10, 64},
+               {"c", 100, 10, 64},
+               {"d", 1000, 10, 64},
+               {"e", 5000, 10, 64},
+
+               {"f", 2, 100, 64},
+               {"g", 10, 100, 64},
+               {"h", 100, 100, 64},
+               {"i", 1000, 100, 64},
+               {"j", 5000, 100, 64},
+       }
+
+       for _, bm := range benchmarks {
+               b.Run(bm.String("mset"), func(b *testing.B) {
+                       sdl := sdlgo.Create("namespace")
+                       value := strings.Repeat("1", bm.valueSize)
+                       keyVals := make([]string, 0)
+                       for i := 0; i < bm.keyCount; i++ {
+                               key := strings.Repeat(bm.keyBase+strconv.Itoa(i), bm.keySize)
+                               keyVals = append(keyVals, key, value)
+                       }
+                       b.ResetTimer()
+                       b.RunParallel(func(pb *testing.PB) {
+                               for pb.Next() {
+                                       err := sdl.Set(keyVals)
+                                       if err != nil {
+                                               b.Fatal(err)
+                                       }
+                               }
+                       })
+               })
+       }
+}
+
+func BenchmarkMultiGet(b *testing.B) {
+       benchmarks := []multiBenchmark{
+               {"a", 2, 10, 64},
+               {"b", 10, 10, 64},
+               {"c", 100, 10, 64},
+               {"d", 1000, 10, 64},
+               {"e", 5000, 10, 64},
+
+               {"f", 2, 100, 64},
+               {"g", 10, 100, 64},
+               {"h", 100, 100, 64},
+               {"i", 1000, 100, 64},
+               {"j", 5000, 100, 64},
+       }
+
+       for _, bm := range benchmarks {
+               b.Run(bm.String("gset"), func(b *testing.B) {
+                       sdl := sdlgo.Create("namespace")
+                       keyVals := make([]string, 0)
+                       for i := 0; i < bm.keyCount; i++ {
+                               key := strings.Repeat(bm.keyBase+strconv.Itoa(i), bm.keySize)
+                               keyVals = append(keyVals, key)
+                       }
+                       b.ResetTimer()
+                       b.RunParallel(func(pb *testing.PB) {
+                               for pb.Next() {
+                                       _, err := sdl.Get(keyVals)
+                                       if err != nil {
+                                               b.Fatal(err)
+                                       }
+                               }
+                       })
+               })
+       }
+}