perf: Amortize clearing unsorted cache entries (Juno genesis fix)

CHANGELOG.md

@@ -56,6 +56,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * [#12634](https://github.com/cosmos/cosmos-sdk/pull/12634) Move `sdk.Dec` to math package.
 * [#12596](https://github.com/cosmos/cosmos-sdk/pull/12596) Remove all imports of the non-existent gogo/protobuf v1.3.3 to ease downstream use and go workspaces. 
 * [#12187](https://github.com/cosmos/cosmos-sdk/pull/12187) Add batch operation for x/nft module.
+* [#12886](https://github.com/cosmos/cosmos-sdk/pull/12886) Amortize cost of processing cache KV store
 
 ### State Machine Breaking
 

store/cachekv/search_benchmark_test.go

@@ -0,0 +1,36 @@
+package cachekv
+
+import (
+	db "github.com/tendermint/tm-db"
+	"strconv"
+	"testing"
+)
+
+func BenchmarkLargeUnsortedMisses(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		cache := map[string]*cValue{}
+		unsorted := map[string]struct{}{}
+		for i := 0; i < 100_000; i++ {
+			key := "A" + strconv.Itoa(i)
+			unsorted[key] = struct{}{}
+			cache[key] = &cValue{}
+		}
+
+		for i := 0; i < 100_000; i++ {
+			key := "Z" + strconv.Itoa(i)
+			unsorted[key] = struct{}{}
+			cache[key] = &cValue{}
+		}
+
+		store := Store{
+			cache:         cache,
+			unsortedCache: unsorted,
+			sortedCache:   db.NewMemDB(),
+		}
+		for k := 0; k < 10000; k++ {
+			// cache has A + Z values
+			// these are within range, but match nothing
+			store.dirtyItems([]byte("B1"), []byte("B2"))
+		}
+	}
+}

store/cachekv/store.go

@@ -13,6 +13,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/store/tracekv"
 	"github.com/cosmos/cosmos-sdk/store/types"
 	"github.com/cosmos/cosmos-sdk/types/kv"
+	"github.com/tendermint/tendermint/libs/math"
 )
 
 // cValue represents a cached value.
@@ -280,6 +281,7 @@ const (
 
 // Constructs a slice of dirty items, to use w/ memIterator.
 func (store *Store) dirtyItems(start, end []byte) {
+	const THRESHOLD = 1024
 	startStr, endStr := conv.UnsafeBytesToStr(start), conv.UnsafeBytesToStr(end)
 	if startStr > endStr {
 		// Nothing to do here.
@@ -294,7 +296,7 @@ func (store *Store) dirtyItems(start, end []byte) {
 	// O(N^2) overhead.
 	// Even without that, too many range checks eventually becomes more expensive
 	// than just not having the cache.
-	if n < 1024 {
+	if n < THRESHOLD {
 		for key := range store.unsortedCache {
 			if dbm.IsKeyInDomain(conv.UnsafeStrToBytes(key), start, end) {
 				cacheValue := store.cache[key]
@@ -325,6 +327,15 @@ func (store *Store) dirtyItems(start, end []byte) {
 		startIndex = 0
 	}
 
+	// since we took the time to sort the cache, we should use that effort
+	// we store at least THRESHOLD values -- cost of storing all is amortized across multiple calls
+	if endIndex-startIndex < THRESHOLD {
+		endIndex = math.MinInt(startIndex+THRESHOLD, len(strL)-1)
+		if endIndex-startIndex < THRESHOLD {
+			startIndex = math.MaxInt(endIndex-THRESHOLD, 0)
+		}
+	}
+
 	kvL := make([]*kv.Pair, 0)
 	for i := startIndex; i <= endIndex; i++ {
 		key := strL[i]