perf: pool cachekv.Store to reduce allocation pressure

Replace per-tx cachekv.Store allocation with sync.Pool recycling for both
standard and giga variants. Add CacheMultiStore.Release() and ReleaseDB()
to return stores to pools at lifecycle boundaries (Cleanup,
RevertToSnapshot, CleanupForTracer). Release replaced stores in
SetKVStores/SetGigaKVStores and unused db store in OCC scheduler.

Reset() replaces sync.Map fields with fresh instances (not Clear(), which
is slower due to internal trie node walking and causes more allocations
when repopulated).

Targeting the #1 flat allocator from profiling: cachekv.NewStore at
9 GB / 157M objects over 30s at 8600 TPS.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pdrobnjak

giga/deps/store/cachekv.go

@@ -22,15 +22,36 @@ type Store struct {
 
 var _ types.CacheKVStore = (*Store)(nil)
 
+var storePool = sync.Pool{
+	New: func() any {
+		return &Store{
+			cache:   &sync.Map{},
+			deleted: &sync.Map{},
+		}
+	},
+}
+
 // NewStore creates a new Store object
 func NewStore(parent types.KVStore, storeKey types.StoreKey, cacheSize int) *Store {
-	return &Store{
-		cache:     &sync.Map{},
-		deleted:   &sync.Map{},
-		parent:    parent,
-		storeKey:  storeKey,
-		cacheSize: cacheSize,
-	}
+	s := storePool.Get().(*Store)
+	s.parent = parent
+	s.storeKey = storeKey
+	s.cacheSize = cacheSize
+	return s
+}
+
+// Reset clears all cached state, making the store ready for reuse.
+func (store *Store) Reset() {
+	store.cache = &sync.Map{}
+	store.deleted = &sync.Map{}
+	store.parent = nil
+	store.storeKey = nil
+}
+
+// Release resets the store and returns it to the pool.
+func (store *Store) Release() {
+	store.Reset()
+	storePool.Put(store)
 }
 
 func (store *Store) GetWorkingHash() ([]byte, error) {

giga/deps/tasks/scheduler.go

@@ -508,6 +508,11 @@ func (s *scheduler) prepareTask(task *deliverTxTask) {
 			return vs[k]
 		})
 
+		// Release the db store since OCC scheduler doesn't use it
+		if r, ok := ms.(interface{ ReleaseDB() }); ok {
+			r.ReleaseDB()
+		}
+
 		ctx = ctx.WithMultiStore(ms)
 	}
 

giga/deps/xevm/state/state.go

@@ -116,6 +116,18 @@ func (s *DBImpl) RevertToSnapshot(rev int) {
 		panic("invalid revision number")
 	}
 
+	// Release current ctx's CMS (being abandoned)
+	type releasable interface{ Release() }
+	if r, ok := s.ctx.MultiStore().(releasable); ok {
+		r.Release()
+	}
+	// Release abandoned snapshots (rev+1..end), but not rev (becomes new ctx)
+	for i := len(s.snapshottedCtxs) - 1; i > rev; i-- {
+		if r, ok := s.snapshottedCtxs[i].MultiStore().(releasable); ok {
+			r.Release()
+		}
+	}
+
 	s.ctx = s.snapshottedCtxs[rev]
 	s.snapshottedCtxs = s.snapshottedCtxs[:rev]
 

giga/deps/xevm/state/statedb.go

@@ -80,13 +80,29 @@ func (s *DBImpl) SetEVM(evm *vm.EVM) {}
 func (s *DBImpl) AddPreimage(_ common.Hash, _ []byte) {}
 
 func (s *DBImpl) Cleanup() {
+	s.releaseIntermediateStores()
 	s.tempState = nil
 	s.logger = nil
 	s.snapshottedCtxs = nil
 }
 
+// releaseIntermediateStores returns cachekv stores from intermediate CMS snapshots
+// back to their pools. Never releases snapshottedCtxs[0] — it belongs to the caller.
+func (s *DBImpl) releaseIntermediateStores() {
+	type releasable interface{ Release() }
+	if r, ok := s.ctx.MultiStore().(releasable); ok {
+		r.Release()
+	}
+	for i := len(s.snapshottedCtxs) - 1; i > 0; i-- {
+		if r, ok := s.snapshottedCtxs[i].MultiStore().(releasable); ok {
+			r.Release()
+		}
+	}
+}
+
 func (s *DBImpl) CleanupForTracer() {
 	s.flushCtxs()
+	s.releaseIntermediateStores()
 	if len(s.snapshottedCtxs) > 0 {
 		s.ctx = s.snapshottedCtxs[0]
 	}

sei-cosmos/store/cachekv/store.go

@@ -27,17 +27,39 @@ type Store struct {
 
 var _ types.CacheKVStore = (*Store)(nil)
 
+var storePool = sync.Pool{
+	New: func() any {
+		return &Store{
+			cache:         &sync.Map{},
+			deleted:       &sync.Map{},
+			unsortedCache: &sync.Map{},
+		}
+	},
+}
+
 // NewStore creates a new Store object
 func NewStore(parent types.KVStore, storeKey types.StoreKey, cacheSize int) *Store {
-	return &Store{
-		cache:         &sync.Map{},
-		deleted:       &sync.Map{},
-		unsortedCache: &sync.Map{},
-		sortedCache:   nil,
-		parent:        parent,
-		storeKey:      storeKey,
-		cacheSize:     cacheSize,
-	}
+	s := storePool.Get().(*Store)
+	s.parent = parent
+	s.storeKey = storeKey
+	s.cacheSize = cacheSize
+	return s
+}
+
+// Reset clears all cached state, making the store ready for reuse.
+func (store *Store) Reset() {
+	store.cache = &sync.Map{}
+	store.deleted = &sync.Map{}
+	store.unsortedCache = &sync.Map{}
+	store.sortedCache = nil
+	store.parent = nil
+	store.storeKey = nil
+}
+
+// Release resets the store and returns it to the pool.
+func (store *Store) Release() {
+	store.Reset()
+	storePool.Put(store)
 }
 
 func (store *Store) GetWorkingHash() ([]byte, error) {

sei-cosmos/store/cachemulti/store.go

@@ -281,21 +281,66 @@ func (cms Store) StoreKeys() []types.StoreKey {
 	return keys
 }
 
+// Release returns all cachekv stores to their pools.
+func (cms Store) Release() {
+	type releasable interface{ Release() }
+	if r, ok := cms.db.(releasable); ok {
+		r.Release()
+	}
+	for k, s := range cms.stores {
+		if r, ok := s.(releasable); ok {
+			r.Release()
+		}
+		delete(cms.stores, k)
+	}
+	for k, s := range cms.gigaStores {
+		if r, ok := s.(releasable); ok {
+			r.Release()
+		}
+		delete(cms.gigaStores, k)
+	}
+	for k := range cms.parents {
+		delete(cms.parents, k)
+	}
+}
+
+// ReleaseDB releases the db cachekv store back to its pool.
+func (cms Store) ReleaseDB() {
+	type releasable interface{ Release() }
+	if r, ok := cms.db.(releasable); ok {
+		r.Release()
+	}
+}
+
 // SetKVStores sets the underlying KVStores via a handler for each key
 func (cms Store) SetKVStores(handler func(sk types.StoreKey, s types.KVStore) types.CacheWrap) types.MultiStore {
 	// Force-create any lazy stores
 	for k := range cms.parents {
 		cms.getOrCreateStore(k)
 	}
+	type releasable interface{ Release() }
 	for k, s := range cms.stores {
-		cms.stores[k] = handler(k, s.(types.KVStore))
+		newStore := handler(k, s.(types.KVStore))
+		if newStore != s {
+			if r, ok := s.(releasable); ok {
+				r.Release()
+			}
+		}
+		cms.stores[k] = newStore
 	}
 	return cms
 }
 
 func (cms Store) SetGigaKVStores(handler func(sk types.StoreKey, s types.KVStore) types.KVStore) types.MultiStore {
+	type releasable interface{ Release() }
 	for k, s := range cms.gigaStores {
-		cms.gigaStores[k] = handler(k, s)
+		newStore := handler(k, s)
+		if newStore != s {
+			if r, ok := s.(releasable); ok {
+				r.Release()
+			}
+		}
+		cms.gigaStores[k] = newStore
 	}
 	return cms
 }

x/evm/state/state.go

@@ -121,6 +121,18 @@ func (s *DBImpl) RevertToSnapshot(rev int) {
 		panic("invalid revision number")
 	}
 
+	// Release current ctx's CMS (being abandoned)
+	type releasable interface{ Release() }
+	if r, ok := s.ctx.MultiStore().(releasable); ok {
+		r.Release()
+	}
+	// Release abandoned snapshots (rev+1..end), but not rev (becomes new ctx)
+	for i := len(s.snapshottedCtxs) - 1; i > rev; i-- {
+		if r, ok := s.snapshottedCtxs[i].MultiStore().(releasable); ok {
+			r.Release()
+		}
+	}
+
 	s.ctx = s.snapshottedCtxs[rev]
 	s.snapshottedCtxs = s.snapshottedCtxs[:rev]
 

x/evm/state/statedb.go

@@ -80,13 +80,29 @@ func (s *DBImpl) SetEVM(evm *vm.EVM) {}
 func (s *DBImpl) AddPreimage(_ common.Hash, _ []byte) {}
 
 func (s *DBImpl) Cleanup() {
+	s.releaseIntermediateStores()
 	s.tempState = nil
 	s.logger = nil
 	s.snapshottedCtxs = nil
 }
 
+// releaseIntermediateStores returns cachekv stores from intermediate CMS snapshots
+// back to their pools. Never releases snapshottedCtxs[0] — it belongs to the caller.
+func (s *DBImpl) releaseIntermediateStores() {
+	type releasable interface{ Release() }
+	if r, ok := s.ctx.MultiStore().(releasable); ok {
+		r.Release()
+	}
+	for i := len(s.snapshottedCtxs) - 1; i > 0; i-- {
+		if r, ok := s.snapshottedCtxs[i].MultiStore().(releasable); ok {
+			r.Release()
+		}
+	}
+}
+
 func (s *DBImpl) CleanupForTracer() {
 	s.flushCtxs()
+	s.releaseIntermediateStores()
 	if len(s.snapshottedCtxs) > 0 {
 		s.ctx = s.snapshottedCtxs[0]
 	}