add lru option

Author: lxzan

benchmark/benchmark_test.go

@@ -12,6 +12,7 @@ import (
 
 const (
 	sharding   = 128
+	capacity   = 10000
 	benchcount = 1 << 20
 )
 
@@ -20,8 +21,9 @@ var (
 
 	options = []memorycache.Option{
 		memorycache.WithBucketNum(sharding),
-		memorycache.WithBucketSize(benchcount/sharding/10, benchcount/sharding),
-		memorycache.WithSwissTable(),
+		memorycache.WithBucketSize(capacity/10, capacity),
+		memorycache.WithSwissTable(true),
+		memorycache.WithLRU(true),
 	}
 )
 
@@ -87,9 +89,9 @@ func BenchmarkMemoryCache_SetAndGet(b *testing.B) {
 
 func BenchmarkRistretto_Set(b *testing.B) {
 	var mc, _ = ristretto.NewCache(&ristretto.Config{
-		NumCounters: benchcount * 10, // number of keys to track frequency of (10M).
-		MaxCost:     1 << 30,         // maximum cost of cache (1GB).
-		BufferItems: 64,              // number of keys per Get buffer.
+		NumCounters: capacity * sharding * 10, // number of keys to track frequency of (10M).
+		MaxCost:     1 << 30,                  // maximum cost of cache (1GB).
+		BufferItems: 64,                       // number of keys per Get buffer.
 	})
 	b.RunParallel(func(pb *testing.PB) {
 		var i = 0
@@ -103,9 +105,9 @@ func BenchmarkRistretto_Set(b *testing.B) {
 
 func BenchmarkRistretto_Get(b *testing.B) {
 	var mc, _ = ristretto.NewCache(&ristretto.Config{
-		NumCounters: benchcount * 10, // number of keys to track frequency of (10M).
-		MaxCost:     1 << 30,         // maximum cost of cache (1GB).
-		BufferItems: 64,              // number of keys per Get buffer.
+		NumCounters: capacity * sharding * 10, // number of keys to track frequency of (10M).
+		MaxCost:     1 << 30,                  // maximum cost of cache (1GB).
+		BufferItems: 64,                       // number of keys per Get buffer.
 	})
 	for i := 0; i < benchcount; i++ {
 		mc.SetWithTTL(benchkeys[i%benchcount], 1, 1, time.Hour)
@@ -124,9 +126,9 @@ func BenchmarkRistretto_Get(b *testing.B) {
 
 func BenchmarkRistretto_SetAndGet(b *testing.B) {
 	var mc, _ = ristretto.NewCache(&ristretto.Config{
-		NumCounters: benchcount * 10, // number of keys to track frequency of (10M).
-		MaxCost:     1 << 30,         // maximum cost of cache (1GB).
-		BufferItems: 64,              // number of keys per Get buffer.
+		NumCounters: capacity * sharding * 10, // number of keys to track frequency of (10M).
+		MaxCost:     1 << 30,                  // maximum cost of cache (1GB).
+		BufferItems: 64,                       // number of keys per Get buffer.
 	})
 	for i := 0; i < benchcount; i++ {
 		mc.SetWithTTL(benchkeys[i%benchcount], 1, 1, time.Hour)
@@ -148,7 +150,7 @@ func BenchmarkRistretto_SetAndGet(b *testing.B) {
 }
 
 func BenchmarkTheine_Set(b *testing.B) {
-	mc, _ := theine.NewBuilder[string, int](benchcount).Build()
+	mc, _ := theine.NewBuilder[string, int](sharding * capacity).Build()
 	b.RunParallel(func(pb *testing.PB) {
 		i := 0
 		for pb.Next() {
@@ -160,7 +162,7 @@ func BenchmarkTheine_Set(b *testing.B) {
 }
 
 func BenchmarkTheine_Get(b *testing.B) {
-	mc, _ := theine.NewBuilder[string, int](benchcount).Build()
+	mc, _ := theine.NewBuilder[string, int](sharding * capacity).Build()
 	for i := 0; i < benchcount; i++ {
 		mc.SetWithTTL(benchkeys[i%benchcount], 1, 1, time.Hour)
 	}
@@ -177,7 +179,7 @@ func BenchmarkTheine_Get(b *testing.B) {
 }
 
 func BenchmarkTheine_SetAndGet(b *testing.B) {
-	mc, _ := theine.NewBuilder[string, int](benchcount).Build()
+	mc, _ := theine.NewBuilder[string, int](sharding * capacity).Build()
 	for i := 0; i < benchcount; i++ {
 		mc.SetWithTTL(benchkeys[i%benchcount], 1, 1, time.Hour)
 	}

cache.go

@@ -27,7 +27,7 @@ type MemoryCache[K comparable, V any] struct {
 // New 创建缓存数据库实例
 // Creating a Cached Database Instance
 func New[K comparable, V any](options ...Option) *MemoryCache[K, V] {
-	var conf = &config{TimeCacheEnabled: true}
+	var conf = &config{CachedTime: true}
 	options = append(options, withInitialize())
 	for _, fn := range options {
 		fn(conf)
@@ -46,10 +46,10 @@ func New[K comparable, V any](options ...Option) *MemoryCache[K, V] {
 
 	for i, _ := range mc.storage {
 		mc.storage[i] = &bucket[K, V]{
-			MaxCapacity: conf.MaxCapacity,
-			Map:         containers.NewMap[K, *Element[K, V]](conf.InitialSize, conf.SwissTable),
-			Heap:        newHeap[K, V](conf.InitialSize),
-			List:        new(queue[K, V]),
+			conf: conf,
+			Map:  containers.NewMap[K, *Element[K, V]](conf.BucketSize, conf.SwissTable),
+			Heap: newHeap[K, V](conf.BucketSize),
+			List: newQueue[K, V](conf.LRU),
 		}
 	}
 
@@ -66,11 +66,11 @@ func New[K comparable, V any](options ...Option) *MemoryCache[K, V] {
 			case now := <-ticker.C:
 				var sum = 0
 				for _, b := range mc.storage {
-					sum += b.ExpireCheck(now.UnixMilli(), conf.MaxKeysDeleted)
+					sum += b.ExpireCheck(now.UnixMilli(), conf.DeleteLimits)
 				}
 
 				// 删除数量超过阈值, 缩小时间间隔
-				if d1 := utils.SelectValue(sum > conf.BucketNum*conf.MaxKeysDeleted*7/10, conf.MinInterval, conf.MaxInterval); d1 != d0 {
+				if d1 := utils.SelectValue(sum > conf.BucketNum*conf.DeleteLimits*7/10, conf.MinInterval, conf.MaxInterval); d1 != d0 {
 					d0 = d1
 					ticker.Reset(d0)
 				}
@@ -102,9 +102,9 @@ func New[K comparable, V any](options ...Option) *MemoryCache[K, V] {
 func (c *MemoryCache[K, V]) Clear() {
 	for _, b := range c.storage {
 		b.Lock()
-		b.Heap = newHeap[K, V](c.conf.InitialSize)
-		b.Map = containers.NewMap[K, *Element[K, V]](c.conf.InitialSize, c.conf.SwissTable)
-		b.List = new(queue[K, V])
+		b.Heap = newHeap[K, V](c.conf.BucketSize)
+		b.Map = containers.NewMap[K, *Element[K, V]](c.conf.BucketSize, c.conf.SwissTable)
+		b.List = newQueue[K, V](c.conf.LRU)
 		b.Unlock()
 	}
 }
@@ -123,7 +123,7 @@ func (c *MemoryCache[K, V]) getBucket(key K) *bucket[K, V] {
 }
 
 func (c *MemoryCache[K, V]) getTimestamp() int64 {
-	if c.conf.TimeCacheEnabled {
+	if c.conf.CachedTime {
 		return c.timestamp.Load()
 	}
 	return time.Now().UnixMilli()
@@ -276,10 +276,10 @@ func (c *MemoryCache[K, V]) Len() int {
 
 type bucket[K comparable, V any] struct {
 	sync.Mutex
-	MaxCapacity int
-	Map         containers.Map[K, *Element[K, V]]
-	Heap        *heap[K, V]
-	List        *queue[K, V]
+	conf *config
+	Map  containers.Map[K, *Element[K, V]]
+	Heap *heap[K, V]
+	List *queue[K, V]
 }
 
 // ExpireCheck 过期时间检查
@@ -314,8 +314,9 @@ func (c *bucket[K, V]) UpdateTTL(ele *Element[K, V], expireAt int64) {
 }
 
 func (c *bucket[K, V]) Insert(key K, value V, expireAt int64, cb CallbackFunc[*Element[K, V]]) {
-	if c.List.Len() >= c.MaxCapacity {
-		c.Delete(c.List.Front(), ReasonEvicted)
+	if c.Heap.Len() >= c.conf.BucketCap {
+		head := utils.SelectValue(c.conf.LRU, c.List.Front(), c.Heap.Front())
+		c.Delete(head, ReasonEvicted)
 	}
 
 	var ele = &Element[K, V]{Key: key, Value: value, ExpireAt: expireAt, cb: cb}

cache_test.go

@@ -28,7 +28,7 @@ func TestMemoryCache(t *testing.T) {
 		var db = New[string, any](
 			WithInterval(10*time.Millisecond, 10*time.Millisecond),
 			WithBucketNum(1),
-			WithTimeCache(false),
+			WithCachedTime(false),
 		)
 		db.Set("a", 1, 100*time.Millisecond)
 		db.Set("b", 1, 300*time.Millisecond)
@@ -45,7 +45,7 @@ func TestMemoryCache(t *testing.T) {
 	t.Run("", func(t *testing.T) {
 		var db = New[string, any](
 			WithInterval(10*time.Millisecond, 10*time.Millisecond),
-			WithTimeCache(false),
+			WithCachedTime(false),
 		)
 		db.Set("a", 1, 100*time.Millisecond)
 		db.Set("b", 1, 200*time.Millisecond)
@@ -62,7 +62,7 @@ func TestMemoryCache(t *testing.T) {
 	t.Run("", func(t *testing.T) {
 		var db = New[string, any](
 			WithInterval(10*time.Millisecond, 10*time.Millisecond),
-			WithTimeCache(false),
+			WithCachedTime(false),
 		)
 		db.Set("a", 1, 100*time.Millisecond)
 		db.Set("b", 1, 200*time.Millisecond)
@@ -80,7 +80,7 @@ func TestMemoryCache(t *testing.T) {
 		var mc = New[string, any](
 			WithInterval(10*time.Millisecond, 10*time.Millisecond),
 			WithBucketNum(1),
-			WithTimeCache(false),
+			WithCachedTime(false),
 		)
 		var m1 = make(map[string]int)
 		var m2 = make(map[string]int64)
@@ -121,9 +121,9 @@ func TestMemoryCache(t *testing.T) {
 	t.Run("expire", func(t *testing.T) {
 		var mc = New[string, any](
 			WithBucketNum(1),
-			WithMaxKeysDeleted(3),
+			WithDeleteLimits(3),
 			WithInterval(50*time.Millisecond, 100*time.Millisecond),
-			WithTimeCache(false),
+			WithCachedTime(false),
 		)
 		mc.Set("a", 1, 150*time.Millisecond)
 		mc.Set("b", 1, 150*time.Millisecond)
@@ -161,6 +161,7 @@ func TestMemoryCache_Set(t *testing.T) {
 		var mc = New[string, any](
 			WithBucketNum(1),
 			WithBucketSize(0, 2),
+			WithLRU(true),
 		)
 		mc.Set("ming", 1, 3*time.Hour)
 		mc.Set("hong", 1, 1*time.Hour)
@@ -578,7 +579,10 @@ func TestMemoryCache_Range(t *testing.T) {
 
 func TestMemoryCache_LRU(t *testing.T) {
 	const count = 10000
-	var mc = New[string, int](WithBucketNum(1))
+	var mc = New[string, int](
+		WithBucketNum(1),
+		WithLRU(true),
+	)
 	var indexes []int
 	for i := 0; i < count; i++ {
 		indexes = append(indexes, i)
@@ -605,7 +609,9 @@ func TestMemoryCache_LRU(t *testing.T) {
 }
 
 func TestMemoryCache_Random(t *testing.T) {
-	var mc = New[string, int]()
+	var mc = New[string, int](
+		WithLRU(true),
+	)
 	const count = 10000
 	for i := 0; i < count; i++ {
 		var key = string(utils.AlphabetNumeric.Generate(3))

options.go

@@ -7,12 +7,12 @@ import (
 )
 
 const (
-	defaultBucketNum      = 16
-	defaultMinInterval    = 5 * time.Second
-	defaultMaxInterval    = 30 * time.Second
-	defaultMaxKeysDeleted = 1000
-	defaultInitialSize    = 1000
-	defaultMaxCapacity    = 100000
+	defaultBucketNum    = 16
+	defaultMinInterval  = 5 * time.Second
+	defaultMaxInterval  = 30 * time.Second
+	defaultDeleteLimits = 1000
+	defaultBucketSize   = 1000
+	defaultBucketCap    = 100000
 )
 
 type Option func(c *config)
@@ -25,20 +25,20 @@ func WithBucketNum(num int) Option {
 	}
 }
 
-// WithMaxKeysDeleted 设置每次TTL检查最大删除key数量. (单个存储桶)
+// WithDeleteLimits 设置每次TTL检查最大删除key数量. (单个存储桶)
 // Set the maximum number of keys to be deleted per TTL check (single bucket)
-func WithMaxKeysDeleted(num int) Option {
+func WithDeleteLimits(num int) Option {
 	return func(c *config) {
-		c.MaxKeysDeleted = num
+		c.DeleteLimits = num
 	}
 }
 
 // WithBucketSize 设置初始化大小和最大容量. 超过最大容量会被清除. (单个存储桶)
 // Set the initial size and maximum capacity. Exceeding the maximum capacity will be erased. (Single bucket)
 func WithBucketSize(size, cap int) Option {
 	return func(c *config) {
-		c.InitialSize = size
-		c.MaxCapacity = cap
+		c.BucketSize = size
+		c.BucketCap = cap
 	}
 }
 
@@ -51,19 +51,27 @@ func WithInterval(min, max time.Duration) Option {
 	}
 }
 
-// WithTimeCache 是否开启时间缓存
+// WithCachedTime 是否开启时间缓存
 // Whether to turn on time caching
-func WithTimeCache(enabled bool) Option {
+func WithCachedTime(enabled bool) Option {
 	return func(c *config) {
-		c.TimeCacheEnabled = enabled
+		c.CachedTime = enabled
 	}
 }
 
 // WithSwissTable 使用swiss table替代runtime map
 // Using swiss table instead of runtime map
-func WithSwissTable() Option {
+func WithSwissTable(enabled bool) Option {
 	return func(c *config) {
-		c.SwissTable = true
+		c.SwissTable = enabled
+	}
+}
+
+// WithLRU 是否开启LRU缓存驱逐算法. 默认为false
+// Whether to enable LRU cache eviction. Default is false
+func WithLRU(enabled bool) Option {
+	return func(c *config) {
+		c.LRU = enabled
 	}
 }
 
@@ -82,16 +90,46 @@ func withInitialize() Option {
 			c.MaxInterval = defaultMaxInterval
 		}
 
-		if c.MaxKeysDeleted <= 0 {
-			c.MaxKeysDeleted = defaultMaxKeysDeleted
+		if c.DeleteLimits <= 0 {
+			c.DeleteLimits = defaultDeleteLimits
 		}
 
-		if c.InitialSize <= 0 {
-			c.InitialSize = defaultInitialSize
+		if c.BucketSize <= 0 {
+			c.BucketSize = defaultBucketSize
 		}
 
-		if c.MaxCapacity <= 0 {
-			c.MaxCapacity = defaultMaxCapacity
+		if c.BucketCap <= 0 {
+			c.BucketCap = defaultBucketCap
 		}
 	}
 }
+
+type config struct {
+	// 检查周期, 默认30s, 最小检查周期为5s
+	// Check period, default 30s, minimum 5s.
+	MinInterval, MaxInterval time.Duration
+
+	// 存储桶的初始化大小和最大容量, 默认为1000和100000
+	// Initialized bucket size and maximum capacity, defaults to 1000 and 100000.
+	BucketSize, BucketCap int
+
+	// 存储桶数量, 默认为16
+	// Number of buckets, default is 16
+	BucketNum int
+
+	// 每次检查至多删除key的数量(单个存储桶)
+	// The number of keys to be deleted per check (for a single bucket).
+	DeleteLimits int
+
+	// 是否开启时间缓存, 默认为true
+	// Whether to enable time caching, true by default.
+	CachedTime bool
+
+	// 是否使用swiss table, 默认为false
+	// Whether to use swiss table, false by default.
+	SwissTable bool
+
+	// 是否开启LRU缓存驱逐算法. 默认为false
+	// Whether to enable LRU cache eviction. Default is false
+	LRU bool
+}