First version of turbo cache

.github/workflows/main.yml

@@ -10,13 +10,12 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v1
         with:
-          go-version: 1.13
+          go-version: 1.20
         id: go
       - name: Code checkout
         uses: actions/checkout@v1
       - name: Test
         run: |
-          go test -v ./... -coverprofile=coverage.txt -covermode=atomic
           go test -v ./... -race
       - name: Build
         run: |

bigcache.go

@@ -1,10 +1,9 @@
-package fastcache
+package turbocache
 
 import (
+	"github.com/cespare/xxhash/v2"
 	"sync"
 	"sync/atomic"
-
-	xxhash "github.com/cespare/xxhash/v2"
 )
 
 // maxSubvalueLen is the maximum size of subvalue chunk.
@@ -43,26 +42,30 @@ func (c *Cache) SetBig(k, v []byte) {
 	valueHash := xxhash.Sum64(v)
 
 	// Split v into chunks with up to 64Kb each.
-	subkey := getSubkeyBuf()
-	var i uint64
-	for len(v) > 0 {
-		subkey.B = marshalUint64(subkey.B[:0], valueHash)
-		subkey.B = marshalUint64(subkey.B, uint64(i))
-		i++
-		subvalueLen := maxSubvalueLen
-		if len(v) < subvalueLen {
-			subvalueLen = len(v)
+	subKeyCount := len(v)/maxSubvalueLen + 2
+	uint64Size := 8
+	subkeys := make([]byte, 0, subKeyCount*uint64Size*2)
+	//var i uint64
+	startValueIndex := 0
+	endValueIndex := 0
+	startSubkeyIndex := 0
+	for i := 0; i <= len(v)/maxSubvalueLen; i++ {
+		startValueIndex = i * maxSubvalueLen
+		endValueIndex = (i + 1) * maxSubvalueLen
+		if endValueIndex > len(v) {
+			endValueIndex = len(v)
 		}
-		subvalue := v[:subvalueLen]
-		v = v[subvalueLen:]
-		c.Set(subkey.B, subvalue)
+		subkeys = marshalUint64(subkeys, valueHash)
+		subkeys = marshalUint64(subkeys, uint64(i))
+		bytes := subkeys[startSubkeyIndex:]
+		startSubkeyIndex = len(subkeys)
+		c.Set(bytes, v[startValueIndex:endValueIndex])
 	}
-
 	// Write metavalue, which consists of valueHash and valueLen.
-	subkey.B = marshalUint64(subkey.B[:0], valueHash)
-	subkey.B = marshalUint64(subkey.B, uint64(valueLen))
-	c.Set(k, subkey.B)
-	putSubkeyBuf(subkey)
+	startSubkeyIndex = len(subkeys)
+	subkeys = marshalUint64(subkeys, valueHash)
+	subkeys = marshalUint64(subkeys, uint64(valueLen))
+	c.Set(k, subkeys[startSubkeyIndex:])
 }
 
 // GetBig searches for the value for the given k, appends it to dst
@@ -107,7 +110,7 @@ func (c *Cache) GetBig(dst, k []byte) (r []byte) {
 	var i uint64
 	for uint64(len(dst)-dstLen) < valueLen {
 		subkey.B = marshalUint64(subkey.B[:0], valueHash)
-		subkey.B = marshalUint64(subkey.B, uint64(i))
+		subkey.B = marshalUint64(subkey.B, i)
 		i++
 		dstNew := c.Get(dst, subkey.B)
 		if len(dstNew) == len(dst) {
@@ -133,9 +136,6 @@ func (c *Cache) GetBig(dst, k []byte) (r []byte) {
 
 func getSubkeyBuf() *bytesBuf {
 	v := subkeyPool.Get()
-	if v == nil {
-		return &bytesBuf{}
-	}
 	return v.(*bytesBuf)
 }
 
@@ -144,7 +144,9 @@ func putSubkeyBuf(bb *bytesBuf) {
 	subkeyPool.Put(bb)
 }
 
-var subkeyPool sync.Pool
+var subkeyPool = sync.Pool{New: func() any {
+	return &bytesBuf{}
+}}
 
 type bytesBuf struct {
 	B []byte

bigcache_test.go

@@ -1,4 +1,4 @@
-package fastcache
+package turbocache
 
 import (
 	"bytes"
@@ -7,7 +7,8 @@ import (
 )
 
 func TestSetGetBig(t *testing.T) {
-	c := New(256 * 1024 * 1024)
+	c := New(NewConfig(1024*1024*1024, 3000, 1, 1))
+	defer c.Close()
 	const valuesCount = 10
 	for _, valueSize := range []int{1, 100, 1<<16 - 1, 1 << 16, 1<<16 + 1, 1 << 17, 1<<17 + 1, 1<<17 - 1, 1 << 19} {
 		t.Run(fmt.Sprintf("valueSize_%d", valueSize), func(t *testing.T) {
@@ -26,13 +27,13 @@ func testSetGetBig(t *testing.T, c *Cache, valueSize, valuesCount, seed int) {
 		value := createValue(valueSize, seed)
 		c.SetBig(key, value)
 		m[string(key)] = value
-		buf = c.GetBig(buf[:0], key)
+		buf = c.getBigWithExpectedValue(buf[:0], key, value)
 		if !bytes.Equal(buf, value) {
 			t.Fatalf("seed=%d; unexpected value obtained for key=%q; got len(value)=%d; want len(value)=%d", seed, key, len(buf), len(value))
 		}
 	}
 	var s Stats
-	c.UpdateStats(&s)
+	c.UpdateStats(&s, true)
 	if s.SetBigCalls < uint64(valuesCount) {
 		t.Fatalf("expecting SetBigCalls >= %d; got %d", valuesCount, s.SetBigCalls)
 	}

bigcache_timing_test.go

@@ -1,33 +1,74 @@
-package fastcache
+package turbocache
 
 import (
+	"github.com/ShareChat/turbo-cache/internal/benchmarking"
+	"github.com/VictoriaMetrics/fastcache"
 	"testing"
 )
 
 func BenchmarkSetBig(b *testing.B) {
 	key := []byte("key12345")
 	value := createValue(256*1024, 0)
-	c := New(1024 * 1024)
+	c := New(newCacheConfigBenchmarkParams(1024 * 1024))
 	b.SetBytes(int64(len(value)))
 	b.ReportAllocs()
+	b.ResetTimer()
+	mutexMetrics := benchmarking.NewMutexMetricsCollector()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
+			key[0]++
 			c.SetBig(key, value)
 		}
 	})
+	mutexMetrics.Report(b)
 }
 
 func BenchmarkGetBig(b *testing.B) {
 	key := []byte("key12345")
 	value := createValue(265*1024, 0)
-	c := New(1024 * 1024)
+	c := New(newCacheConfigBenchmarkParams(1024 * 1024))
 	c.SetBig(key, value)
 	b.SetBytes(int64(len(value)))
 	b.ReportAllocs()
+	b.ResetTimer()
+	mutexMetrics := benchmarking.NewMutexMetricsCollector()
 	b.RunParallel(func(pb *testing.PB) {
 		var buf []byte
 		for pb.Next() {
 			buf = c.GetBig(buf[:0], key)
 		}
 	})
+	mutexMetrics.Report(b)
+}
+
+func BenchmarkFastCacheSetBig(b *testing.B) {
+	key := []byte("key12345")
+	value := createValue(256*1024, 0)
+	c := fastcache.New(1024 * 1024)
+	b.SetBytes(int64(len(value)))
+	b.ReportAllocs()
+	mutexMetrics := benchmarking.NewMutexMetricsCollector()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			c.SetBig(key, value)
+		}
+	})
+	mutexMetrics.Report(b)
+}
+
+func BenchmarkFastCacheGetBig(b *testing.B) {
+	key := []byte("key12345")
+	value := createValue(265*1024, 0)
+	c := fastcache.New(1024 * 1024)
+	c.SetBig(key, value)
+	b.SetBytes(int64(len(value)))
+	b.ReportAllocs()
+	mutexMetrics := benchmarking.NewMutexMetricsCollector()
+	b.RunParallel(func(pb *testing.PB) {
+		var buf []byte
+		for pb.Next() {
+			buf = c.GetBig(buf[:0], key)
+		}
+	})
+	mutexMetrics.Report(b)
 }