cache: generic cache

The old cache is implemented with the new cache.

The goal of this v2 cache is to improve ergonomics of working with caches

The following benchmark shows the speed difference for the hash functions

```
$ go test -bench=BenchmarkHash ./cache --count 10 | benchstat -col .name -
goos: linux
goarch: amd64
pkg: github.com/upfluence/pkg/cache
cpu: AMD Ryzen 7 PRO 7840U w/ Radeon 780M Graphics
         │  HashFnv64   │             HashMaphash             │
         │    sec/op    │   sec/op     vs base                │
*/8-16      2.178µ ± 0%   4.167µ ± 1%  +91.34% (p=0.000 n=10)
*/16-16     3.788µ ± 1%   4.145µ ± 2%   +9.42% (p=0.000 n=10)
*/64-16    17.119µ ± 8%   4.611µ ± 3%  -73.06% (p=0.000 n=10)
*/256-16    52.51µ ± 4%   11.46µ ± 0%  -78.18% (p=0.000 n=10)
geomean     9.279µ        5.496µ       -40.77%
```

It does not take into account the overhead gained from unboxing the value
types, nor any possible PGO wins.

An example of the keys used are domains, in per-domain shop ratelimiters.

Author: karitham

cache/cache.go

@@ -1,11 +1,16 @@
 package cache
 
-import "io"
+import (
+	"github.com/upfluence/pkg/cache/policy"
+	"github.com/upfluence/pkg/cache/v2"
+)
 
-type Cache interface {
-	Get(string) (interface{}, bool, error)
-	Set(string, interface{}) error
-	Evict(string) error
+type Cache cache.Cache[string, any]
 
-	io.Closer
+func NewCache() Cache {
+	return cache.NewCache[string, any]()
+}
+
+func WithEvictionPolicy(c Cache, ep policy.EvictionPolicy) Cache {
+	return cache.WithEvictionPolicy(c, ep)
 }

cache/cache_test.go

@@ -0,0 +1,72 @@
+package cache
+
+import (
+	"fmt"
+	"hash/maphash"
+	"math/rand/v2"
+	"testing"
+)
+
+const (
+	offset64 uint64 = 14695981039346656037
+	prime64  uint64 = 1099511628211
+)
+
+func generateTestStrings(size, count int) []string {
+	result := make([]string, count)
+
+	for i := 0; i < count; i++ {
+		bytes := make([]byte, size)
+		for j := range bytes {
+			bytes[j] = byte(rand.IntN(256))
+		}
+
+		result[i] = string(bytes)
+	}
+
+	return result
+}
+
+func fnv64aHash(s string) uint64 {
+	h := offset64
+
+	for _, b := range []byte(s) {
+		h ^= uint64(b)
+		h *= prime64
+	}
+
+	return h
+}
+
+func BenchmarkHashFnv64(b *testing.B) {
+	sizes := []int{8, 16, 64, 256}
+	for _, size := range sizes {
+		testData := generateTestStrings(size, 1000)
+
+		b.Run(fmt.Sprintf("%d", size), func(b *testing.B) {
+			b.ResetTimer()
+			for range b.N {
+				for _, s := range testData {
+					fnv64aHash(s)
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkHashMaphash(b *testing.B) {
+	sizes := []int{8, 16, 64, 256}
+	for _, size := range sizes {
+		testData := generateTestStrings(size, 1000)
+		b.Run(fmt.Sprintf("%d", size), func(b *testing.B) {
+			b.ResetTimer()
+			seed := maphash.MakeSeed()
+
+			for range b.N {
+				for _, s := range testData {
+					maphash.String(seed, s)
+				}
+			}
+		})
+	}
+}

cache/lock_cache.go

@@ -0,0 +1,23 @@
+package policy
+
+import (
+	policy "github.com/upfluence/pkg/cache/v2/policy"
+)
+
+var ErrClosed = policy.ErrClosed
+
+type EvictionPolicy = policy.EvictionPolicy[string]
+
+func CombinePolicies(ps ...EvictionPolicy) EvictionPolicy {
+	return policy.CombinePolicies(ps...)
+}
+
+type NopPolicy = policy.NopPolicy[string]
+
+type OpType = policy.OpType
+
+const (
+	Get   = policy.Get
+	Set   = policy.Set
+	Evict = policy.Evict
+)

cache/policy/policy.go

@@ -1,118 +1,11 @@
 package size
 
 import (
-	"container/list"
-	"context"
-	"sync"
-
-	"github.com/upfluence/pkg/cache/policy"
+	"github.com/upfluence/pkg/cache/v2/policy/size"
 )
 
-type Policy struct {
-	sync.Mutex
-
-	size int
-
-	l  *list.List
-	ks map[string]*list.Element
-
-	ctx    context.Context
-	cancel context.CancelFunc
-
-	fn func(string)
-
-	closeOnce sync.Once
-	ch        chan string
-}
-
-func NewLRUPolicy(size int) *Policy {
-	p := Policy{
-		l:    list.New(),
-		size: size,
-		ks:   make(map[string]*list.Element),
-		ch:   make(chan string, 1),
-	}
-
-	p.ctx, p.cancel = context.WithCancel(context.Background())
-	p.fn = p.move
-
-	return &p
-}
-
-func (p *Policy) C() <-chan string {
-	return p.ch
-}
-
-func (p *Policy) Op(k string, op policy.OpType) error {
-	if p.ctx.Err() != nil {
-		return policy.ErrClosed
-	}
-
-	p.Lock()
-
-	switch op {
-	case policy.Set:
-		p.insert(k)
-	case policy.Get:
-		p.fn(k)
-	case policy.Evict:
-		p.evict(k)
-	}
-
-	p.Unlock()
-
-	return nil
-}
-
-func (p *Policy) move(k string) {
-	e, ok := p.ks[k]
-
-	if !ok {
-		return
-	}
-
-	p.l.MoveToBack(e)
-}
-
-func (p *Policy) insert(k string) {
-	if _, ok := p.ks[k]; ok {
-		return
-	}
-
-	var e *list.Element
-
-	if p.l.Len() == 0 {
-		e = p.l.PushFront(k)
-	} else {
-		e = p.l.InsertAfter(k, p.l.Back())
-	}
-
-	p.ks[k] = e
-
-	if p.l.Len() > p.size {
-		v := p.l.Remove(p.l.Front()).(string)
-		delete(p.ks, v)
-
-		select {
-		case <-p.ctx.Done():
-		case p.ch <- v:
-		}
-	}
-}
-
-func (p *Policy) evict(k string) {
-	e, ok := p.ks[k]
-
-	if !ok {
-		return
-	}
-
-	p.l.Remove(e)
-	delete(p.ks, k)
-}
+type Policy = size.Policy
 
-func (p *Policy) Close() error {
-	p.cancel()
-	p.closeOnce.Do(func() { close(p.ch) })
-	return nil
+func NewLRUPolicy(sz int) *Policy {
+	return size.NewLRUPolicy(sz)
 }