Files
memoryweave/go/internal/storage/searchcache.go
T

317 lines
8.9 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 织忆 MemoryWeave — 搜索引擎缓存层(多 Agent 支持)
// G9: L1 内存 + L2 Redis 两级缓存
package storage
import (
"crypto/sha256"
"encoding/json"
"fmt"
"strconv"
"strings"
"sync"
"time"
)
// L2CacheBackend 提供可选的 L2 持久化缓存接口
type L2CacheBackend interface {
Get(key string) ([]byte, bool)
Set(key string, data []byte, ttl time.Duration)
Del(key string)
// DelPrefix 按前缀批量删除(按 namespace / query 失效用,避免逐键枚举)
DelPrefix(prefix string) int
}
// redisL2Adapter 将同包的 RedisCache 适配为 L2CacheBackend
type redisL2Adapter struct{}
func (a *redisL2Adapter) Get(key string) ([]byte, bool) {
// 延迟获取 RedisCache 实例(避免循环 init)
rc := getRedisCacheInstance()
if rc == nil {
return nil, false
}
return rc.Get(key)
}
func (a *redisL2Adapter) Set(key string, data []byte, ttl time.Duration) {
rc := getRedisCacheInstance()
if rc == nil {
return
}
rc.Set(key, data)
}
func (a *redisL2Adapter) Del(key string) {
rc := getRedisCacheInstance()
if rc == nil {
return
}
rc.Del(key)
}
func (a *redisL2Adapter) DelPrefix(prefix string) int {
rc := getRedisCacheInstance()
if rc == nil {
return 0
}
return rc.DelPrefix(prefix)
}
// getRedisCacheInstance 单例获取 RedisCache(延迟初始化)
var (
redisCacheInstance *RedisCache
redisCacheOnce sync.Once
)
func getRedisCacheInstance() *RedisCache {
redisCacheOnce.Do(func() {
// 2026-10-13 t_1c12e000:L2 TTL 与 L1 同步 60s。
// 只改 L1 不改 L2 ⇒ L2 里 1h 的陈旧快照会在 L1 重建(重启/驱逐回填
// 重置 CreatedAt=now)后继续续命 1h ⇒ 写后盲区的陈旧窗口仍远超 60s。
redisCacheInstance = NewRedisCache(60 * time.Second)
})
return redisCacheInstance
}
// SearchCache 基于 LRU + TTL 的搜索缓存(支持可选 L2 Redis)
// Get 时:L1 miss → 查 Redis L2 → 回填 L1
// Set 时:写 L1 + 写 Redis L2(TTL 同步)
type SearchCache struct {
mu sync.RWMutex
entries map[string]*CacheEntry
maxSize int
ttl time.Duration
l2 L2CacheBackend // 可选 L2 缓存(Redis),nil 时只有 L1
// 2026-10-13 t_1c12e000:命中/未命中/失效计数(mu 保护下自增,Stats 在 RLock 下读取)。
hits uint64
misses uint64
invalidated uint64
}
type CacheEntry struct {
Key string `json:"key"`
Results []byte `json:"results"`
CreatedAt time.Time `json:"created_at"`
Hits int `json:"hits"`
}
// newSearchCache 内部构造器(l2 可为 nil)
func newSearchCache(maxSize int, ttl time.Duration, l2 L2CacheBackend) *SearchCache {
sc := &SearchCache{
entries: make(map[string]*CacheEntry),
maxSize: maxSize,
ttl: ttl,
l2: l2,
}
go sc.reaper()
return sc
}
// NewSearchCache 创建纯 L1 内存 SearchCache(向后兼容)
func NewSearchCache(maxSize int, ttl time.Duration) *SearchCache {
return newSearchCache(maxSize, ttl, nil)
}
// NewSearchCacheWithRedis 创建带 Redis L2 的 SearchCache(G9 多级缓存)
func NewSearchCacheWithRedis(maxSize int, ttl time.Duration) *SearchCache {
return newSearchCache(maxSize, ttl, &redisL2Adapter{})
}
// Get 获取缓存结果:L1 miss → 查 L2 → 回填 L1
//
// topK / diversity 参与键构造:召回结果随它们变化(rerank/MMR 取 topK*2、
// 最终按 topK 截断),而调用方 topK 各不相同(eval 用 3 / 5,HTTP 用客户端 Limit)
// ⇒ 键里不含它们会让不同调用方串用同一条缓存、拿到条数不对的结果。
func (sc *SearchCache) Get(query, namespace string, topK int, diversity float64) ([]byte, bool) {
key := cacheKey(query, namespace, topK, diversity)
// L1 查找
sc.mu.RLock()
entry, ok := sc.entries[key]
sc.mu.RUnlock()
if ok && time.Since(entry.CreatedAt) <= sc.ttl {
sc.mu.Lock()
entry.Hits++
sc.hits++ // t_1c12e000:命中计数(L1 命中)
sc.mu.Unlock()
return entry.Results, true
}
// L1 miss,尝试 L2
if sc.l2 != nil {
if data, found := sc.l2.Get(key); found {
// 回填 L1
sc.mu.Lock()
if len(sc.entries) >= sc.maxSize {
sc.evictLRU()
}
sc.entries[key] = &CacheEntry{
Key: key,
Results: data,
CreatedAt: time.Now(),
Hits: 1,
}
sc.hits++ // t_1c12e000:L2 命中(回填 L1)也计为命中
sc.mu.Unlock()
return data, true
}
}
// 两级全 miss
sc.mu.Lock()
sc.misses++ // t_1c12e000:未命中计数(走回源扫表)
sc.mu.Unlock()
return nil, false
}
// Set 写入缓存:写 L1 + 写 L2
func (sc *SearchCache) Set(query, namespace string, topK int, diversity float64, results interface{}) {
key := cacheKey(query, namespace, topK, diversity)
data, err := json.Marshal(results)
if err != nil {
return
}
sc.mu.Lock()
defer sc.mu.Unlock()
// L1 驱逐
if len(sc.entries) >= sc.maxSize {
sc.evictLRU()
}
sc.entries[key] = &CacheEntry{
Key: key,
Results: data,
CreatedAt: time.Now(),
Hits: 0,
}
// L2 写入
if sc.l2 != nil {
sc.l2.Set(key, data, sc.ttl)
}
}
// Stats 返回缓存统计
func (sc *SearchCache) Stats() map[string]interface{} {
sc.mu.RLock()
defer sc.mu.RUnlock()
return map[string]interface{}{
"size": len(sc.entries),
"max_size": sc.maxSize,
"ttl": sc.ttl.String(),
"l2_enabled": sc.l2 != nil,
// t_1c12e000:命中/未命中/失效计数(命中率 = hits/(hits+misses),写频影响可观测)
"hits": sc.hits,
"misses": sc.misses,
"invalidated": sc.invalidated,
}
}
// Invalidate 使指定 namespace 的缓存失效(L1 + L2)。
//
// 旧实现把 entry.Results 反序列化成 map[string]interface{} 再取 ["namespace"],
// 但 Set 存进去的是 []RecallResult(JSON 数组)⇒ 反序列化恒失败 ⇒ parsed 为 nil
// ⇒ 一个键都删不掉:失效是**静默空操作**(探针实测:Invalidate 后缓存仍命中,
// 记忆写入后最长 1h TTL 内持续返回陈旧召回)。
// 现改为按键布局前缀匹配,不再依赖 payload 结构。
func (sc *SearchCache) Invalidate(namespace string) {
prefix := cacheKeyNSPrefix(namespace)
sc.mu.Lock()
removed := 0
for key := range sc.entries {
if strings.HasPrefix(key, prefix) {
delete(sc.entries, key)
removed++
}
}
if removed > 0 {
sc.invalidated += uint64(removed) // t_1c12e000:失效计数(写路径失效的量可观测)
}
sc.mu.Unlock()
if sc.l2 != nil {
sc.l2.DelPrefix(prefix)
}
}
// InvalidateKey 使指定 (query, namespace) 的**全部 topK/diversity 变体**失效(L1 + L2)
func (sc *SearchCache) InvalidateKey(query, namespace string) {
prefix := cacheKeyQueryPrefix(query, namespace)
sc.mu.Lock()
removed := 0
for key := range sc.entries {
if strings.HasPrefix(key, prefix) {
delete(sc.entries, key)
removed++
}
}
if removed > 0 {
sc.invalidated += uint64(removed)
}
sc.mu.Unlock()
if sc.l2 != nil {
sc.l2.DelPrefix(prefix)
}
}
func (sc *SearchCache) evictLRU() {
var oldestKey string
var oldestTime time.Time
for key, entry := range sc.entries {
if oldestKey == "" || entry.CreatedAt.Before(oldestTime) {
oldestKey = key
oldestTime = entry.CreatedAt
}
}
if oldestKey != "" {
delete(sc.entries, oldestKey)
}
}
func (sc *SearchCache) reaper() {
ticker := time.NewTicker(5 * time.Minute)
for range ticker.C {
sc.mu.Lock()
now := time.Now()
for key, entry := range sc.entries {
if now.Sub(entry.CreatedAt) > sc.ttl {
delete(sc.entries, key)
if sc.l2 != nil {
sc.l2.Del(key)
}
}
}
sc.mu.Unlock()
}
}
// cacheKey 构造缓存键。布局刻意做成「可前缀寻址」:
//
// <namespace> \x00 <queryHash(16B hex)> \x00 <topK> \x00 <diversity>
//
// 为什么 namespace 放最前:失效按 namespace 做前缀匹配,无需解析 payload。
func cacheKey(query, namespace string, topK int, diversity float64) string {
h := sha256.Sum256([]byte(query))
return fmt.Sprintf("%s\x00%x\x00%d\x00%s", namespace, h[:16], topK,
strconv.FormatFloat(diversity, 'f', -1, 64))
}
// cacheKeyNSPrefix 某 namespace 下全部键的前缀
func cacheKeyNSPrefix(namespace string) string { return namespace + "\x00" }
// cacheKeyQueryPrefix 某 (query, namespace) 下全部 topK/diversity 变体的前缀
func cacheKeyQueryPrefix(query, namespace string) string {
h := sha256.Sum256([]byte(query))
return fmt.Sprintf("%s\x00%x\x00", namespace, h[:16])
}
// ─── 全局搜索缓存实例(G9:带 Redis L2) ─────────────────────
var SearchCacheInstance *SearchCache
func init() {
// 2026-10-13 t_1c12e000:TTL 1h → 60s(陈旧窗口上限)。
// 写路径(commit→蒸馏→落库)已加 Invalidate(方案 A),60s 是双保险:
// 任何**漏网**写点(新调用方/异常路径)最多让同一 query 读 60s 旧快照,
// 而不是 1h。命中率代价由 Stats() 的 hits/misses 观测后再决定是否收窄。
SearchCacheInstance = NewSearchCacheWithRedis(1000, 60*time.Second)
}