Optimize memory usage

[roseduan]

package kv

import (
    "fmt"
    "github.com/cockroachdb/pebble"
    "github.com/rosedblabs/rosedb/v2"
    "math"
    "math/rand"
    "sync"
    "testing"
    "time"
)

var pebbledb *pebble.DB
var rdb *rosedb.DB

func init() {
    var err error
    opt := &pebble.Options{BytesPerSync: math.MaxInt, WALBytesPerSync: math.MaxInt}
    pebbledb, err = pebble.Open("/tmp/pebble-bench", opt)
    if err != nil {
        panic(err)
    }

    options := rosedb.DefaultOptions
    options.DirPath = "/tmp/rosedb-bench"
    rdb, err = rosedb.Open(options)
    if err != nil {
        panic(err)
    }
}

func BenchmarkPebble_Get(b *testing.B) {
    for i := 0; i < 1000000; i++ {
        pebbledb.Set(GetTestKey(i), RandomValue(128), &pebble.WriteOptions{Sync: false})
    }

    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, _, err := pebbledb.Get(GetTestKey(i))
        if err != nil && err != pebble.ErrNotFound {
            panic(err)
        }
    }
}

func BenchmarkRoseDB_Get(b *testing.B) {
    for i := 0; i < 1000000; i++ {
        rdb.Put(GetTestKey(i), RandomValue(128))
    }

    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, err := rdb.Get(GetTestKey(i))
        if err != nil && err != rosedb.ErrKeyNotFound {
            panic(err)
        }
    }
}

var (
    lock    = sync.Mutex{}
    randStr = rand.New(rand.NewSource(time.Now().Unix()))
    letters = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
)

// GetTestKey get formated key, for test only
func GetTestKey(i int) []byte {
    return []byte(fmt.Sprintf("rosedb-test-key-%09d", i))
}

// RandomValue generate random value, for test only
func RandomValue(n int) []byte {
    b := make([]byte, n)
    for i := range b {
        lock.Lock()
        b[i] = letters[randStr.Intn(len(letters))]
        lock.Unlock()
    }
    return []byte("rosedb-test-value-" + string(b))
}

Run RoseDB:

go test -v -bench=BenchmarkRoseDB_Get -memprofile rosedb.out

Run Pebble:

go test -v -bench=BenchmarkPebble_Get -memprofile pebble.out

Analyze:

go tool pprof rosedb.out
go tool pprof pebble.out