perf: simplify cachekv store with copy-on-write btree

CHANGELOG.md

@@ -124,6 +124,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (x/auth/vesting) [#13502](https://github.com/cosmos/cosmos-sdk/pull/13502) Add Amino Msg registration for `MsgCreatePeriodicVestingAccount`.
 * (x/auth)[#13780](https://github.com/cosmos/cosmos-sdk/pull/13780) `id` (type of int64) in `AccountAddressByID` grpc query is now deprecated, update to account-id(type of uint64) to use `AccountAddressByID`.
 * (x/group) [#13876](https://github.com/cosmos/cosmos-sdk/pull/13876) Fix group MinExecutionPeriod that is checked on execution now, instead of voting period end.
+* (store) [#]() simplify cachekv store with copy-on-write btree, it's consensus-breaking because iteration is done on isolated view now, while it's not the case before.
 
 ### API Breaking Changes
 

store/cachekv/internal/memcache.go

@@ -0,0 +1,93 @@
+package internal
+
+import (
+	"bytes"
+	"errors"
+
+	"github.com/tidwall/btree"
+)
+
+var errKeyEmpty = errors.New("key cannot be empty")
+
+const (
+	// The approximate number of items and children per B-tree node. Tuned with benchmarks.
+	// copied from memdb.
+	bTreeDegree = 32
+)
+
+// MemCache implements the in-memory cache for cachekv store,
+// we don't use MemDB here because cachekv is used extensively in sdk core path,
+// we need it to be as fast as possible, while `MemDB` is mainly used as a mocking db in unit tests.
+//
+// We choose tidwall/btree over google/btree here because it provides API to implement step iterator directly.
+type MemCache struct {
+	tree *btree.BTreeG[item]
+}
+
+// NewMemCache creates a wrapper around `btree.BTreeG`.
+func NewMemCache() MemCache {
+	return MemCache{tree: btree.NewBTreeGOptions(byKeys, btree.Options{
+		Degree:  bTreeDegree,
+		NoLocks: false,
+	})}
+}
+
+// Set set a cache entry, dirty means it's newly set,
+// `nil` value means a deletion.
+func (bt MemCache) Set(key, value []byte, dirty bool) {
+	bt.tree.Set(item{key: key, value: value, dirty: dirty})
+}
+
+// Get returns (value, found)
+func (bt MemCache) Get(key []byte) ([]byte, bool) {
+	i, found := bt.tree.Get(item{key: key})
+	if !found {
+		return nil, false
+	}
+	return i.value, true
+}
+
+// ScanDirtyItems iterate over the dirty entries.
+func (bt MemCache) ScanDirtyItems(fn func(key, value []byte)) {
+	bt.tree.Scan(func(item item) bool {
+		if item.dirty {
+			fn(item.key, item.value)
+		}
+		return true
+	})
+}
+
+// Copy the cache. This is a copy-on-write operation and is very fast because
+// it only performs a shadowed copy.
+func (bt MemCache) Copy() MemCache {
+	return MemCache{tree: bt.tree.IsoCopy()}
+}
+
+// Iterator iterates on a isolated view of the cache, not affected by future modifications.
+func (bt MemCache) Iterator(start, end []byte) *memIterator {
+	if (start != nil && len(start) == 0) || (end != nil && len(end) == 0) {
+		panic(errKeyEmpty)
+	}
+	return NewMemIterator(start, end, bt.Copy(), true)
+}
+
+// ReverseIterator iterates on a isolated view of the cache, not affected by future modifications.
+func (bt MemCache) ReverseIterator(start, end []byte) *memIterator {
+	if (start != nil && len(start) == 0) || (end != nil && len(end) == 0) {
+		panic(errKeyEmpty)
+	}
+	return NewMemIterator(start, end, bt.Copy(), false)
+}
+
+// item represents a cached key-value pair and the entry of the cache btree.
+// If dirty is true, it indicates the cached value is newly set, maybe different from the underlying value.
+type item struct {
+	key   []byte
+	value []byte
+	dirty bool
+}
+
+// byKeys compares the items by key
+func byKeys(a, b item) bool {
+	return bytes.Compare(a.key, b.key) == -1
+}