mirror of
https://github.com/openimsdk/open-im-server.git
synced 2026-05-17 07:19:02 +08:00
feat: add local cache for high frequency reads (#2036)
* feat: msg local cache * feat: msg local cache * feat: msg local cache * feat: msg local cache * feat: msg local cache * feat: msg local cache * fix: mongo * fix: mongo * fix: mongo * openim.yaml * localcache * localcache * localcache * localcache * localcache * localcache * localcache * localcache * localcache * local cache * local cache * local cache * local cache * fix: GroupApplicationAcceptedNotification * fix: GroupApplicationAcceptedNotification * fix: NotificationUserInfoUpdate * feat: cache add single-flight and timing-wheel. * feat: local cache * feat: local cache * feat: local cache * feat: cache add single-flight and timing-wheel. * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: local cache * feat: msg rpc local cache * feat: msg rpc local cache * feat: msg rpc local cache * feat: msg rpc local cache * feat: msg rpc local cache * feat: msg rpc local cache * refactor: refactor the code of push and optimization. * cicd: robot automated Change * refactor: rename cache. * merge * fix: refactor project dir avoid import cycle. * update tools * merge * feat: conversation FindRecvMsgNotNotifyUserIDs * feat: conversation FindRecvMsgNotNotifyUserIDs * feat: conversation FindRecvMsgNotNotifyUserIDs * merge * merge the latest main --------- Co-authored-by: Gordon <46924906+FGadvancer@users.noreply.github.com> Co-authored-by: withchao <withchao@users.noreply.github.com>
This commit is contained in:
chao
@@ -0,0 +1,112 @@
|
||||
package localcache
|
||||
|
||||
import (
|
||||
"context"
|
||||
"github.com/openimsdk/localcache/link"
|
||||
"github.com/openimsdk/localcache/lru"
|
||||
"hash/fnv"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
type Cache[V any] interface {
|
||||
Get(ctx context.Context, key string, fetch func(ctx context.Context) (V, error)) (V, error)
|
||||
GetLink(ctx context.Context, key string, fetch func(ctx context.Context) (V, error), link ...string) (V, error)
|
||||
Del(ctx context.Context, key ...string)
|
||||
DelLocal(ctx context.Context, key ...string)
|
||||
Stop()
|
||||
}
|
||||
|
||||
func New[V any](opts ...Option) Cache[V] {
|
||||
opt := defaultOption()
|
||||
for _, o := range opts {
|
||||
o(opt)
|
||||
}
|
||||
|
||||
c := cache[V]{opt: opt}
|
||||
if opt.localSlotNum > 0 && opt.localSlotSize > 0 {
|
||||
createSimpleLRU := func() lru.LRU[string, V] {
|
||||
if opt.expirationEvict {
|
||||
return lru.NewExpirationLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
|
||||
} else {
|
||||
return lru.NewLayLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
|
||||
}
|
||||
}
|
||||
if opt.localSlotNum == 1 {
|
||||
c.local = createSimpleLRU()
|
||||
} else {
|
||||
c.local = lru.NewSlotLRU[string, V](opt.localSlotNum, func(key string) uint64 {
|
||||
h := fnv.New64a()
|
||||
h.Write(*(*[]byte)(unsafe.Pointer(&key)))
|
||||
return h.Sum64()
|
||||
}, createSimpleLRU)
|
||||
}
|
||||
if opt.linkSlotNum > 0 {
|
||||
c.link = link.New(opt.linkSlotNum)
|
||||
}
|
||||
}
|
||||
return &c
|
||||
}
|
||||
|
||||
type cache[V any] struct {
|
||||
opt *option
|
||||
link link.Link
|
||||
local lru.LRU[string, V]
|
||||
}
|
||||
|
||||
func (c *cache[V]) onEvict(key string, value V) {
|
||||
if c.link != nil {
|
||||
lks := c.link.Del(key)
|
||||
for k := range lks {
|
||||
if key != k { // prevent deadlock
|
||||
c.local.Del(k)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *cache[V]) del(key ...string) {
|
||||
if c.local == nil {
|
||||
return
|
||||
}
|
||||
for _, k := range key {
|
||||
c.local.Del(k)
|
||||
if c.link != nil {
|
||||
lks := c.link.Del(k)
|
||||
for k := range lks {
|
||||
c.local.Del(k)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *cache[V]) Get(ctx context.Context, key string, fetch func(ctx context.Context) (V, error)) (V, error) {
|
||||
return c.GetLink(ctx, key, fetch)
|
||||
}
|
||||
|
||||
func (c *cache[V]) GetLink(ctx context.Context, key string, fetch func(ctx context.Context) (V, error), link ...string) (V, error) {
|
||||
if c.local != nil {
|
||||
return c.local.Get(key, func() (V, error) {
|
||||
if len(link) > 0 {
|
||||
c.link.Link(key, link...)
|
||||
}
|
||||
return fetch(ctx)
|
||||
})
|
||||
} else {
|
||||
return fetch(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *cache[V]) Del(ctx context.Context, key ...string) {
|
||||
for _, fn := range c.opt.delFn {
|
||||
fn(ctx, key...)
|
||||
}
|
||||
c.del(key...)
|
||||
}
|
||||
|
||||
func (c *cache[V]) DelLocal(ctx context.Context, key ...string) {
|
||||
c.del(key...)
|
||||
}
|
||||
|
||||
func (c *cache[V]) Stop() {
|
||||
c.local.Stop()
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
package localcache
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestName(t *testing.T) {
|
||||
c := New[string](WithExpirationEvict())
|
||||
//c := New[string]()
|
||||
ctx := context.Background()
|
||||
|
||||
const (
|
||||
num = 10000
|
||||
tNum = 10000
|
||||
kNum = 100000
|
||||
pNum = 100
|
||||
)
|
||||
|
||||
getKey := func(v uint64) string {
|
||||
return fmt.Sprintf("key_%d", v%kNum)
|
||||
}
|
||||
|
||||
start := time.Now()
|
||||
t.Log("start", start)
|
||||
|
||||
var (
|
||||
get atomic.Int64
|
||||
del atomic.Int64
|
||||
)
|
||||
|
||||
incrGet := func() {
|
||||
if v := get.Add(1); v%pNum == 0 {
|
||||
//t.Log("#get count", v/pNum)
|
||||
}
|
||||
}
|
||||
incrDel := func() {
|
||||
if v := del.Add(1); v%pNum == 0 {
|
||||
//t.Log("@del count", v/pNum)
|
||||
}
|
||||
}
|
||||
|
||||
var wg sync.WaitGroup
|
||||
|
||||
for i := 0; i < tNum; i++ {
|
||||
wg.Add(2)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
for i := 0; i < num; i++ {
|
||||
c.Get(ctx, getKey(rand.Uint64()), func(ctx context.Context) (string, error) {
|
||||
return fmt.Sprintf("index_%d", i), nil
|
||||
})
|
||||
incrGet()
|
||||
}
|
||||
}()
|
||||
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
time.Sleep(time.Second / 10)
|
||||
for i := 0; i < num; i++ {
|
||||
c.Del(ctx, getKey(rand.Uint64()))
|
||||
incrDel()
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
end := time.Now()
|
||||
t.Log("end", end)
|
||||
t.Log("time", end.Sub(start))
|
||||
t.Log("get", get.Load())
|
||||
t.Log("del", del.Load())
|
||||
// 137.35s
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
module github.com/openimsdk/localcache
|
||||
|
||||
go 1.19
|
||||
|
||||
require github.com/hashicorp/golang-lru/v2 v2.0.7
|
||||
@@ -0,0 +1,109 @@
|
||||
package link
|
||||
|
||||
import (
|
||||
"hash/fnv"
|
||||
"sync"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
type Link interface {
|
||||
Link(key string, link ...string)
|
||||
Del(key string) map[string]struct{}
|
||||
}
|
||||
|
||||
func newLinkKey() *linkKey {
|
||||
return &linkKey{
|
||||
data: make(map[string]map[string]struct{}),
|
||||
}
|
||||
}
|
||||
|
||||
type linkKey struct {
|
||||
lock sync.Mutex
|
||||
data map[string]map[string]struct{}
|
||||
}
|
||||
|
||||
func (x *linkKey) link(key string, link ...string) {
|
||||
x.lock.Lock()
|
||||
defer x.lock.Unlock()
|
||||
v, ok := x.data[key]
|
||||
if !ok {
|
||||
v = make(map[string]struct{})
|
||||
x.data[key] = v
|
||||
}
|
||||
for _, k := range link {
|
||||
v[k] = struct{}{}
|
||||
}
|
||||
}
|
||||
|
||||
func (x *linkKey) del(key string) map[string]struct{} {
|
||||
x.lock.Lock()
|
||||
defer x.lock.Unlock()
|
||||
ks, ok := x.data[key]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
delete(x.data, key)
|
||||
return ks
|
||||
}
|
||||
|
||||
func New(n int) Link {
|
||||
if n <= 0 {
|
||||
panic("must be greater than 0")
|
||||
}
|
||||
slots := make([]*linkKey, n)
|
||||
for i := 0; i < len(slots); i++ {
|
||||
slots[i] = newLinkKey()
|
||||
}
|
||||
return &slot{
|
||||
n: uint64(n),
|
||||
slots: slots,
|
||||
}
|
||||
}
|
||||
|
||||
type slot struct {
|
||||
n uint64
|
||||
slots []*linkKey
|
||||
}
|
||||
|
||||
func (x *slot) index(s string) uint64 {
|
||||
h := fnv.New64a()
|
||||
_, _ = h.Write(*(*[]byte)(unsafe.Pointer(&s)))
|
||||
return h.Sum64() % x.n
|
||||
}
|
||||
|
||||
func (x *slot) Link(key string, link ...string) {
|
||||
if len(link) == 0 {
|
||||
return
|
||||
}
|
||||
mk := key
|
||||
lks := make([]string, len(link))
|
||||
for i, k := range link {
|
||||
lks[i] = k
|
||||
}
|
||||
x.slots[x.index(mk)].link(mk, lks...)
|
||||
for _, lk := range lks {
|
||||
x.slots[x.index(lk)].link(lk, mk)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *slot) Del(key string) map[string]struct{} {
|
||||
return x.delKey(key)
|
||||
}
|
||||
|
||||
func (x *slot) delKey(k string) map[string]struct{} {
|
||||
del := make(map[string]struct{})
|
||||
stack := []string{k}
|
||||
for len(stack) > 0 {
|
||||
curr := stack[len(stack)-1]
|
||||
stack = stack[:len(stack)-1]
|
||||
if _, ok := del[curr]; ok {
|
||||
continue
|
||||
}
|
||||
del[curr] = struct{}{}
|
||||
childKeys := x.slots[x.index(curr)].del(curr)
|
||||
for ck := range childKeys {
|
||||
stack = append(stack, ck)
|
||||
}
|
||||
}
|
||||
return del
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
package link
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestName(t *testing.T) {
|
||||
|
||||
v := New(1)
|
||||
|
||||
//v.Link("a:1", "b:1", "c:1", "d:1")
|
||||
v.Link("a:1", "b:1", "c:1")
|
||||
v.Link("z:1", "b:1")
|
||||
|
||||
//v.DelKey("a:1")
|
||||
v.Del("z:1")
|
||||
|
||||
t.Log(v)
|
||||
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
package lru
|
||||
|
||||
import "github.com/hashicorp/golang-lru/v2/simplelru"
|
||||
|
||||
type EvictCallback[K comparable, V any] simplelru.EvictCallback[K, V]
|
||||
|
||||
type LRU[K comparable, V any] interface {
|
||||
Get(key K, fetch func() (V, error)) (V, error)
|
||||
Del(key K) bool
|
||||
Stop()
|
||||
}
|
||||
|
||||
type Target interface {
|
||||
IncrGetHit()
|
||||
IncrGetSuccess()
|
||||
IncrGetFailed()
|
||||
|
||||
IncrDelHit()
|
||||
IncrDelNotFound()
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
package lru
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/golang-lru/v2/expirable"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
func NewExpirationLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) LRU[K, V] {
|
||||
var cb expirable.EvictCallback[K, *expirationLruItem[V]]
|
||||
if onEvict != nil {
|
||||
cb = func(key K, value *expirationLruItem[V]) {
|
||||
onEvict(key, value.value)
|
||||
}
|
||||
}
|
||||
core := expirable.NewLRU[K, *expirationLruItem[V]](size, cb, successTTL)
|
||||
return &ExpirationLRU[K, V]{
|
||||
core: core,
|
||||
successTTL: successTTL,
|
||||
failedTTL: failedTTL,
|
||||
target: target,
|
||||
}
|
||||
}
|
||||
|
||||
type expirationLruItem[V any] struct {
|
||||
lock sync.RWMutex
|
||||
err error
|
||||
value V
|
||||
}
|
||||
|
||||
type ExpirationLRU[K comparable, V any] struct {
|
||||
lock sync.Mutex
|
||||
core *expirable.LRU[K, *expirationLruItem[V]]
|
||||
successTTL time.Duration
|
||||
failedTTL time.Duration
|
||||
target Target
|
||||
}
|
||||
|
||||
func (x *ExpirationLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
|
||||
x.lock.Lock()
|
||||
v, ok := x.core.Get(key)
|
||||
if ok {
|
||||
x.lock.Unlock()
|
||||
x.target.IncrGetSuccess()
|
||||
v.lock.RLock()
|
||||
defer v.lock.RUnlock()
|
||||
return v.value, v.err
|
||||
} else {
|
||||
v = &expirationLruItem[V]{}
|
||||
x.core.Add(key, v)
|
||||
v.lock.Lock()
|
||||
x.lock.Unlock()
|
||||
defer v.lock.Unlock()
|
||||
v.value, v.err = fetch()
|
||||
if v.err == nil {
|
||||
x.target.IncrGetSuccess()
|
||||
} else {
|
||||
x.target.IncrGetFailed()
|
||||
x.core.Remove(key)
|
||||
}
|
||||
return v.value, v.err
|
||||
}
|
||||
}
|
||||
|
||||
func (x *ExpirationLRU[K, V]) Del(key K) bool {
|
||||
x.lock.Lock()
|
||||
ok := x.core.Remove(key)
|
||||
x.lock.Unlock()
|
||||
if ok {
|
||||
x.target.IncrDelHit()
|
||||
} else {
|
||||
x.target.IncrDelNotFound()
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
func (x *ExpirationLRU[K, V]) Stop() {
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
package lru
|
||||
|
||||
import (
|
||||
"github.com/hashicorp/golang-lru/v2/simplelru"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
type layLruItem[V any] struct {
|
||||
lock sync.Mutex
|
||||
expires int64
|
||||
err error
|
||||
value V
|
||||
}
|
||||
|
||||
func NewLayLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) *LayLRU[K, V] {
|
||||
var cb simplelru.EvictCallback[K, *layLruItem[V]]
|
||||
if onEvict != nil {
|
||||
cb = func(key K, value *layLruItem[V]) {
|
||||
onEvict(key, value.value)
|
||||
}
|
||||
}
|
||||
core, err := simplelru.NewLRU[K, *layLruItem[V]](size, cb)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return &LayLRU[K, V]{
|
||||
core: core,
|
||||
successTTL: successTTL,
|
||||
failedTTL: failedTTL,
|
||||
target: target,
|
||||
}
|
||||
}
|
||||
|
||||
type LayLRU[K comparable, V any] struct {
|
||||
lock sync.Mutex
|
||||
core *simplelru.LRU[K, *layLruItem[V]]
|
||||
successTTL time.Duration
|
||||
failedTTL time.Duration
|
||||
target Target
|
||||
}
|
||||
|
||||
func (x *LayLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
|
||||
x.lock.Lock()
|
||||
v, ok := x.core.Get(key)
|
||||
if ok {
|
||||
x.lock.Unlock()
|
||||
v.lock.Lock()
|
||||
expires, value, err := v.expires, v.value, v.err
|
||||
if expires != 0 && expires > time.Now().UnixMilli() {
|
||||
v.lock.Unlock()
|
||||
x.target.IncrGetHit()
|
||||
return value, err
|
||||
}
|
||||
} else {
|
||||
v = &layLruItem[V]{}
|
||||
x.core.Add(key, v)
|
||||
v.lock.Lock()
|
||||
x.lock.Unlock()
|
||||
}
|
||||
defer v.lock.Unlock()
|
||||
if v.expires > time.Now().UnixMilli() {
|
||||
return v.value, v.err
|
||||
}
|
||||
v.value, v.err = fetch()
|
||||
if v.err == nil {
|
||||
v.expires = time.Now().Add(x.successTTL).UnixMilli()
|
||||
x.target.IncrGetSuccess()
|
||||
} else {
|
||||
v.expires = time.Now().Add(x.failedTTL).UnixMilli()
|
||||
x.target.IncrGetFailed()
|
||||
}
|
||||
return v.value, v.err
|
||||
}
|
||||
|
||||
func (x *LayLRU[K, V]) Del(key K) bool {
|
||||
x.lock.Lock()
|
||||
ok := x.core.Remove(key)
|
||||
x.lock.Unlock()
|
||||
if ok {
|
||||
x.target.IncrDelHit()
|
||||
} else {
|
||||
x.target.IncrDelNotFound()
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
func (x *LayLRU[K, V]) Stop() {
|
||||
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
package lru
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"hash/fnv"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
type cacheTarget struct {
|
||||
getHit int64
|
||||
getSuccess int64
|
||||
getFailed int64
|
||||
delHit int64
|
||||
delNotFound int64
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrGetHit() {
|
||||
atomic.AddInt64(&r.getHit, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrGetSuccess() {
|
||||
atomic.AddInt64(&r.getSuccess, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrGetFailed() {
|
||||
atomic.AddInt64(&r.getFailed, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrDelHit() {
|
||||
atomic.AddInt64(&r.delHit, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) IncrDelNotFound() {
|
||||
atomic.AddInt64(&r.delNotFound, 1)
|
||||
}
|
||||
|
||||
func (r *cacheTarget) String() string {
|
||||
return fmt.Sprintf("getHit: %d, getSuccess: %d, getFailed: %d, delHit: %d, delNotFound: %d", r.getHit, r.getSuccess, r.getFailed, r.delHit, r.delNotFound)
|
||||
}
|
||||
|
||||
func TestName(t *testing.T) {
|
||||
target := &cacheTarget{}
|
||||
l := NewSlotLRU[string, string](100, func(k string) uint64 {
|
||||
h := fnv.New64a()
|
||||
h.Write(*(*[]byte)(unsafe.Pointer(&k)))
|
||||
return h.Sum64()
|
||||
}, func() LRU[string, string] {
|
||||
return NewExpirationLRU[string, string](100, time.Second*60, time.Second, target, nil)
|
||||
})
|
||||
//l := NewInertiaLRU[string, string](1000, time.Second*20, time.Second*5, target)
|
||||
|
||||
fn := func(key string, n int, fetch func() (string, error)) {
|
||||
for i := 0; i < n; i++ {
|
||||
//v, err := l.Get(key, fetch)
|
||||
//if err == nil {
|
||||
// t.Log("key", key, "value", v)
|
||||
//} else {
|
||||
// t.Error("key", key, err)
|
||||
//}
|
||||
v, err := l.Get(key, fetch)
|
||||
//time.Sleep(time.Second / 100)
|
||||
func(v ...any) {}(v, err)
|
||||
}
|
||||
}
|
||||
|
||||
tmp := make(map[string]struct{})
|
||||
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < 10000; i++ {
|
||||
wg.Add(1)
|
||||
key := fmt.Sprintf("key_%d", i%200)
|
||||
tmp[key] = struct{}{}
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
//t.Log(key)
|
||||
fn(key, 10000, func() (string, error) {
|
||||
//time.Sleep(time.Second * 3)
|
||||
//t.Log(time.Now(), "key", key, "fetch")
|
||||
//if rand.Uint32()%5 == 0 {
|
||||
// return "value_" + key, nil
|
||||
//}
|
||||
//return "", errors.New("rand error")
|
||||
return "value_" + key, nil
|
||||
})
|
||||
}()
|
||||
|
||||
//wg.Add(1)
|
||||
//go func() {
|
||||
// defer wg.Done()
|
||||
// for i := 0; i < 10; i++ {
|
||||
// l.Del(key)
|
||||
// time.Sleep(time.Second / 3)
|
||||
// }
|
||||
//}()
|
||||
}
|
||||
wg.Wait()
|
||||
t.Log(len(tmp))
|
||||
t.Log(target.String())
|
||||
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
package lru
|
||||
|
||||
func NewSlotLRU[K comparable, V any](slotNum int, hash func(K) uint64, create func() LRU[K, V]) LRU[K, V] {
|
||||
x := &slotLRU[K, V]{
|
||||
n: uint64(slotNum),
|
||||
slots: make([]LRU[K, V], slotNum),
|
||||
hash: hash,
|
||||
}
|
||||
for i := 0; i < slotNum; i++ {
|
||||
x.slots[i] = create()
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
type slotLRU[K comparable, V any] struct {
|
||||
n uint64
|
||||
slots []LRU[K, V]
|
||||
hash func(k K) uint64
|
||||
}
|
||||
|
||||
func (x *slotLRU[K, V]) getIndex(k K) uint64 {
|
||||
return x.hash(k) % x.n
|
||||
}
|
||||
|
||||
func (x *slotLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
|
||||
return x.slots[x.getIndex(key)].Get(key, fetch)
|
||||
}
|
||||
|
||||
func (x *slotLRU[K, V]) Del(key K) bool {
|
||||
return x.slots[x.getIndex(key)].Del(key)
|
||||
}
|
||||
|
||||
func (x *slotLRU[K, V]) Stop() {
|
||||
for _, slot := range x.slots {
|
||||
slot.Stop()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
package localcache
|
||||
|
||||
import (
|
||||
"context"
|
||||
"github.com/openimsdk/localcache/lru"
|
||||
"time"
|
||||
)
|
||||
|
||||
func defaultOption() *option {
|
||||
return &option{
|
||||
localSlotNum: 500,
|
||||
localSlotSize: 20000,
|
||||
linkSlotNum: 500,
|
||||
expirationEvict: false,
|
||||
localSuccessTTL: time.Minute,
|
||||
localFailedTTL: time.Second * 5,
|
||||
delFn: make([]func(ctx context.Context, key ...string), 0, 2),
|
||||
target: emptyTarget{},
|
||||
}
|
||||
}
|
||||
|
||||
type option struct {
|
||||
localSlotNum int
|
||||
localSlotSize int
|
||||
linkSlotNum int
|
||||
// expirationEvict: true means that the cache will be actively cleared when the timer expires,
|
||||
// false means that the cache will be lazily deleted.
|
||||
expirationEvict bool
|
||||
localSuccessTTL time.Duration
|
||||
localFailedTTL time.Duration
|
||||
delFn []func(ctx context.Context, key ...string)
|
||||
target lru.Target
|
||||
}
|
||||
|
||||
type Option func(o *option)
|
||||
|
||||
func WithExpirationEvict() Option {
|
||||
return func(o *option) {
|
||||
o.expirationEvict = true
|
||||
}
|
||||
}
|
||||
|
||||
func WithLazy() Option {
|
||||
return func(o *option) {
|
||||
o.expirationEvict = false
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalDisable() Option {
|
||||
return WithLinkSlotNum(0)
|
||||
}
|
||||
|
||||
func WithLinkDisable() Option {
|
||||
return WithLinkSlotNum(0)
|
||||
}
|
||||
|
||||
func WithLinkSlotNum(linkSlotNum int) Option {
|
||||
return func(o *option) {
|
||||
o.linkSlotNum = linkSlotNum
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalSlotNum(localSlotNum int) Option {
|
||||
return func(o *option) {
|
||||
o.localSlotNum = localSlotNum
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalSlotSize(localSlotSize int) Option {
|
||||
return func(o *option) {
|
||||
o.localSlotSize = localSlotSize
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalSuccessTTL(localSuccessTTL time.Duration) Option {
|
||||
if localSuccessTTL < 0 {
|
||||
panic("localSuccessTTL should be greater than 0")
|
||||
}
|
||||
return func(o *option) {
|
||||
o.localSuccessTTL = localSuccessTTL
|
||||
}
|
||||
}
|
||||
|
||||
func WithLocalFailedTTL(localFailedTTL time.Duration) Option {
|
||||
if localFailedTTL < 0 {
|
||||
panic("localFailedTTL should be greater than 0")
|
||||
}
|
||||
return func(o *option) {
|
||||
o.localFailedTTL = localFailedTTL
|
||||
}
|
||||
}
|
||||
|
||||
func WithTarget(target lru.Target) Option {
|
||||
if target == nil {
|
||||
panic("target should not be nil")
|
||||
}
|
||||
return func(o *option) {
|
||||
o.target = target
|
||||
}
|
||||
}
|
||||
|
||||
func WithDeleteKeyBefore(fn func(ctx context.Context, key ...string)) Option {
|
||||
if fn == nil {
|
||||
panic("fn should not be nil")
|
||||
}
|
||||
return func(o *option) {
|
||||
o.delFn = append(o.delFn, fn)
|
||||
}
|
||||
}
|
||||
|
||||
type emptyTarget struct{}
|
||||
|
||||
func (e emptyTarget) IncrGetHit() {}
|
||||
|
||||
func (e emptyTarget) IncrGetSuccess() {}
|
||||
|
||||
func (e emptyTarget) IncrGetFailed() {}
|
||||
|
||||
func (e emptyTarget) IncrDelHit() {}
|
||||
|
||||
func (e emptyTarget) IncrDelNotFound() {}
|
||||
@@ -0,0 +1,9 @@
|
||||
package localcache
|
||||
|
||||
func AnyValue[V any](v any, err error) (V, error) {
|
||||
if err != nil {
|
||||
var zero V
|
||||
return zero, err
|
||||
}
|
||||
return v.(V), nil
|
||||
}
|
||||
Reference in New Issue
Block a user