129 lines
2.7 KiB
Go
129 lines
2.7 KiB
Go
package blobovniczatree
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
|
|
utilSync "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/sync"
|
|
"github.com/hashicorp/golang-lru/v2/simplelru"
|
|
)
|
|
|
|
// dbCache caches sharedDB instances that are NOT open for Put.
|
|
//
|
|
// Uses dbManager for opening/closing sharedDB instances.
|
|
// Stores a reference to an cached sharedDB, so dbManager does not close it.
|
|
type dbCache struct {
|
|
cacheGuard *sync.RWMutex
|
|
cache simplelru.LRUCache[string, *sharedDB]
|
|
pathLock *utilSync.KeyLocker[string] // the order of locks is important: pathLock first, cacheGuard second
|
|
closed bool
|
|
nonCached map[string]struct{}
|
|
|
|
dbManager *dbManager
|
|
}
|
|
|
|
func newDBCache(size int, dbManager *dbManager) *dbCache {
|
|
cache, err := simplelru.NewLRU(size, func(_ string, evictedDB *sharedDB) {
|
|
evictedDB.Close()
|
|
})
|
|
if err != nil {
|
|
// occurs only if the size is not positive
|
|
panic(fmt.Errorf("could not create LRU cache of size %d: %w", size, err))
|
|
}
|
|
return &dbCache{
|
|
cacheGuard: &sync.RWMutex{},
|
|
cache: cache,
|
|
dbManager: dbManager,
|
|
pathLock: utilSync.NewKeyLocker[string](),
|
|
nonCached: make(map[string]struct{}),
|
|
}
|
|
}
|
|
|
|
func (c *dbCache) Open() {
|
|
c.cacheGuard.Lock()
|
|
defer c.cacheGuard.Unlock()
|
|
|
|
c.closed = false
|
|
}
|
|
|
|
func (c *dbCache) Close() {
|
|
c.cacheGuard.Lock()
|
|
defer c.cacheGuard.Unlock()
|
|
c.cache.Purge()
|
|
c.closed = true
|
|
}
|
|
|
|
func (c *dbCache) GetOrCreate(path string) *sharedDB {
|
|
value := c.getExisted(path)
|
|
if value != nil {
|
|
return value
|
|
}
|
|
return c.create(path)
|
|
}
|
|
|
|
func (c *dbCache) EvictAndMarkNonCached(path string) {
|
|
c.pathLock.Lock(path)
|
|
defer c.pathLock.Unlock(path)
|
|
|
|
c.cacheGuard.Lock()
|
|
defer c.cacheGuard.Unlock()
|
|
|
|
c.cache.Remove(path)
|
|
c.nonCached[path] = struct{}{}
|
|
}
|
|
|
|
func (c *dbCache) RemoveFromNonCached(path string) {
|
|
c.pathLock.Lock(path)
|
|
defer c.pathLock.Unlock(path)
|
|
|
|
c.cacheGuard.Lock()
|
|
defer c.cacheGuard.Unlock()
|
|
|
|
delete(c.nonCached, path)
|
|
}
|
|
|
|
func (c *dbCache) getExisted(path string) *sharedDB {
|
|
c.cacheGuard.Lock()
|
|
defer c.cacheGuard.Unlock()
|
|
|
|
if value, ok := c.cache.Get(path); ok {
|
|
return value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *dbCache) create(path string) *sharedDB {
|
|
c.pathLock.Lock(path)
|
|
defer c.pathLock.Unlock(path)
|
|
|
|
value := c.getExisted(path)
|
|
if value != nil {
|
|
return value
|
|
}
|
|
|
|
value = c.dbManager.GetByPath(path)
|
|
|
|
_, err := value.Open() // open db to hold reference, closed by evictedDB.Close() or if cache closed
|
|
if err != nil {
|
|
return value
|
|
}
|
|
if added := c.put(path, value); !added {
|
|
value.Close()
|
|
}
|
|
return value
|
|
}
|
|
|
|
func (c *dbCache) put(path string, db *sharedDB) bool {
|
|
c.cacheGuard.Lock()
|
|
defer c.cacheGuard.Unlock()
|
|
|
|
_, isNonCached := c.nonCached[path]
|
|
|
|
if !isNonCached && !c.closed {
|
|
c.cache.Add(path, db)
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|