268 lines
7.2 KiB
Go
268 lines
7.2 KiB
Go
package cachekv
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"sort"
|
|
"sync"
|
|
"time"
|
|
|
|
dbm "github.com/tendermint/tm-db"
|
|
|
|
"github.com/cosmos/cosmos-sdk/internal/conv"
|
|
"github.com/cosmos/cosmos-sdk/store/listenkv"
|
|
"github.com/cosmos/cosmos-sdk/store/tracekv"
|
|
"github.com/cosmos/cosmos-sdk/store/types"
|
|
"github.com/cosmos/cosmos-sdk/telemetry"
|
|
"github.com/cosmos/cosmos-sdk/types/kv"
|
|
)
|
|
|
|
// If value is nil but deleted is false, it means the parent doesn't have the
|
|
// key. (No need to delete upon Write())
|
|
type cValue struct {
|
|
value []byte
|
|
dirty bool
|
|
}
|
|
|
|
// Store wraps an in-memory cache around an underlying types.KVStore.
|
|
type Store struct {
|
|
mtx sync.Mutex
|
|
cache map[string]*cValue
|
|
deleted map[string]struct{}
|
|
unsortedCache map[string]struct{}
|
|
sortedCache *dbm.MemDB // always ascending sorted
|
|
parent types.KVStore
|
|
}
|
|
|
|
var _ types.CacheKVStore = (*Store)(nil)
|
|
|
|
// NewStore creates a new Store object
|
|
func NewStore(parent types.KVStore) *Store {
|
|
return &Store{
|
|
cache: make(map[string]*cValue),
|
|
deleted: make(map[string]struct{}),
|
|
unsortedCache: make(map[string]struct{}),
|
|
sortedCache: dbm.NewMemDB(),
|
|
parent: parent,
|
|
}
|
|
}
|
|
|
|
// GetStoreType implements Store.
|
|
func (store *Store) GetStoreType() types.StoreType {
|
|
return store.parent.GetStoreType()
|
|
}
|
|
|
|
// Get implements types.KVStore.
|
|
func (store *Store) Get(key []byte) (value []byte) {
|
|
store.mtx.Lock()
|
|
defer store.mtx.Unlock()
|
|
defer telemetry.MeasureSince(time.Now(), "store", "cachekv", "get")
|
|
|
|
types.AssertValidKey(key)
|
|
|
|
cacheValue, ok := store.cache[conv.UnsafeBytesToStr(key)]
|
|
if !ok {
|
|
value = store.parent.Get(key)
|
|
store.setCacheValue(key, value, false, false)
|
|
} else {
|
|
value = cacheValue.value
|
|
}
|
|
|
|
return value
|
|
}
|
|
|
|
// Set implements types.KVStore.
|
|
func (store *Store) Set(key []byte, value []byte) {
|
|
store.mtx.Lock()
|
|
defer store.mtx.Unlock()
|
|
defer telemetry.MeasureSince(time.Now(), "store", "cachekv", "set")
|
|
|
|
types.AssertValidKey(key)
|
|
types.AssertValidValue(value)
|
|
|
|
store.setCacheValue(key, value, false, true)
|
|
}
|
|
|
|
// Has implements types.KVStore.
|
|
func (store *Store) Has(key []byte) bool {
|
|
value := store.Get(key)
|
|
return value != nil
|
|
}
|
|
|
|
// Delete implements types.KVStore.
|
|
func (store *Store) Delete(key []byte) {
|
|
store.mtx.Lock()
|
|
defer store.mtx.Unlock()
|
|
defer telemetry.MeasureSince(time.Now(), "store", "cachekv", "delete")
|
|
|
|
types.AssertValidKey(key)
|
|
store.setCacheValue(key, nil, true, true)
|
|
}
|
|
|
|
// Implements Cachetypes.KVStore.
|
|
func (store *Store) Write() {
|
|
store.mtx.Lock()
|
|
defer store.mtx.Unlock()
|
|
defer telemetry.MeasureSince(time.Now(), "store", "cachekv", "write")
|
|
|
|
// We need a copy of all of the keys.
|
|
// Not the best, but probably not a bottleneck depending.
|
|
keys := make([]string, 0, len(store.cache))
|
|
|
|
for key, dbValue := range store.cache {
|
|
if dbValue.dirty {
|
|
keys = append(keys, key)
|
|
}
|
|
}
|
|
|
|
sort.Strings(keys)
|
|
|
|
// TODO: Consider allowing usage of Batch, which would allow the write to
|
|
// at least happen atomically.
|
|
for _, key := range keys {
|
|
cacheValue := store.cache[key]
|
|
|
|
switch {
|
|
case store.isDeleted(key):
|
|
store.parent.Delete([]byte(key))
|
|
case cacheValue.value == nil:
|
|
// Skip, it already doesn't exist in parent.
|
|
default:
|
|
store.parent.Set([]byte(key), cacheValue.value)
|
|
}
|
|
}
|
|
|
|
// Clear the cache
|
|
store.cache = make(map[string]*cValue)
|
|
store.deleted = make(map[string]struct{})
|
|
store.unsortedCache = make(map[string]struct{})
|
|
store.sortedCache = dbm.NewMemDB()
|
|
}
|
|
|
|
// CacheWrap implements CacheWrapper.
|
|
func (store *Store) CacheWrap() types.CacheWrap {
|
|
return NewStore(store)
|
|
}
|
|
|
|
// CacheWrapWithTrace implements the CacheWrapper interface.
|
|
func (store *Store) CacheWrapWithTrace(w io.Writer, tc types.TraceContext) types.CacheWrap {
|
|
return NewStore(tracekv.NewStore(store, w, tc))
|
|
}
|
|
|
|
// CacheWrapWithListeners implements the CacheWrapper interface.
|
|
func (store *Store) CacheWrapWithListeners(storeKey types.StoreKey, listeners []types.WriteListener) types.CacheWrap {
|
|
return NewStore(listenkv.NewStore(store, storeKey, listeners))
|
|
}
|
|
|
|
//----------------------------------------
|
|
// Iteration
|
|
|
|
// Iterator implements types.KVStore.
|
|
func (store *Store) Iterator(start, end []byte) types.Iterator {
|
|
return store.iterator(start, end, true)
|
|
}
|
|
|
|
// ReverseIterator implements types.KVStore.
|
|
func (store *Store) ReverseIterator(start, end []byte) types.Iterator {
|
|
return store.iterator(start, end, false)
|
|
}
|
|
|
|
func (store *Store) iterator(start, end []byte, ascending bool) types.Iterator {
|
|
store.mtx.Lock()
|
|
defer store.mtx.Unlock()
|
|
|
|
var parent, cache types.Iterator
|
|
|
|
if ascending {
|
|
parent = store.parent.Iterator(start, end)
|
|
} else {
|
|
parent = store.parent.ReverseIterator(start, end)
|
|
}
|
|
|
|
store.dirtyItems(start, end)
|
|
cache = newMemIterator(start, end, store.sortedCache, store.deleted, ascending)
|
|
|
|
return newCacheMergeIterator(parent, cache, ascending)
|
|
}
|
|
|
|
// Constructs a slice of dirty items, to use w/ memIterator.
|
|
func (store *Store) dirtyItems(start, end []byte) {
|
|
n := len(store.unsortedCache)
|
|
unsorted := make([]*kv.Pair, 0)
|
|
// If the unsortedCache is too big, its costs too much to determine
|
|
// whats in the subset we are concerned about.
|
|
// If you are interleaving iterator calls with writes, this can easily become an
|
|
// O(N^2) overhead.
|
|
// Even without that, too many range checks eventually becomes more expensive
|
|
// than just not having the cache.
|
|
if n >= 1024 {
|
|
for key := range store.unsortedCache {
|
|
cacheValue := store.cache[key]
|
|
unsorted = append(unsorted, &kv.Pair{Key: []byte(key), Value: cacheValue.value})
|
|
}
|
|
} else {
|
|
// else do a linear scan to determine if the unsorted pairs are in the pool.
|
|
for key := range store.unsortedCache {
|
|
if dbm.IsKeyInDomain(conv.UnsafeStrToBytes(key), start, end) {
|
|
cacheValue := store.cache[key]
|
|
unsorted = append(unsorted, &kv.Pair{Key: []byte(key), Value: cacheValue.value})
|
|
}
|
|
}
|
|
}
|
|
store.clearUnsortedCacheSubset(unsorted)
|
|
}
|
|
|
|
func (store *Store) clearUnsortedCacheSubset(unsorted []*kv.Pair) {
|
|
n := len(store.unsortedCache)
|
|
if len(unsorted) == n { // This pattern allows the Go compiler to emit the map clearing idiom for the entire map.
|
|
for key := range store.unsortedCache {
|
|
delete(store.unsortedCache, key)
|
|
}
|
|
} else { // Otherwise, normally delete the unsorted keys from the map.
|
|
for _, kv := range unsorted {
|
|
delete(store.unsortedCache, conv.UnsafeBytesToStr(kv.Key))
|
|
}
|
|
}
|
|
sort.Slice(unsorted, func(i, j int) bool {
|
|
return bytes.Compare(unsorted[i].Key, unsorted[j].Key) < 0
|
|
})
|
|
|
|
for _, item := range unsorted {
|
|
if item.Value == nil {
|
|
// deleted element, tracked by store.deleted
|
|
// setting arbitrary value
|
|
store.sortedCache.Set(item.Key, []byte{})
|
|
continue
|
|
}
|
|
err := store.sortedCache.Set(item.Key, item.Value)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------
|
|
// etc
|
|
|
|
// Only entrypoint to mutate store.cache.
|
|
func (store *Store) setCacheValue(key, value []byte, deleted bool, dirty bool) {
|
|
keyStr := conv.UnsafeBytesToStr(key)
|
|
store.cache[keyStr] = &cValue{
|
|
value: value,
|
|
dirty: dirty,
|
|
}
|
|
if deleted {
|
|
store.deleted[keyStr] = struct{}{}
|
|
} else {
|
|
delete(store.deleted, keyStr)
|
|
}
|
|
if dirty {
|
|
store.unsortedCache[conv.UnsafeBytesToStr(key)] = struct{}{}
|
|
}
|
|
}
|
|
|
|
func (store *Store) isDeleted(key string) bool {
|
|
_, ok := store.deleted[key]
|
|
return ok
|
|
}
|