c2d5b24f58
Reduces CPU burn by using a typed List to avoid the expensive type assertions from using an interface. This is the only option for now until Go makes generics generally available. The change brings time spent on the time assertion cummulatively to: 580ms down from 6.88s Explanation: The type assertions were showing up heavily in profiles: * Before this commit ```shell Total: 42.18s ROUTINE ======================== github.com/cosmos/cosmos-sdk/store/cachekv.newMemIterator in /Users/emmanuelodeke/go/src/github.com/cosmos/cosmos-sdk/store/cachekv/memiterator.go 14.01s 18.87s (flat, cum) 44.74% of Total . . 17: items []*kv.Pair . . 18: ascending bool . . 19:} . . 20: . . 21:func newMemIterator(start, end []byte, items *list.List, ascending bool) *memIterator { . 620ms 22: itemsInDomain := make([]*kv.Pair, 0, items.Len()) . . 23: . . 24: var entered bool . . 25: 510ms 870ms 26: for e := items.Front(); e != nil; e = e.Next() { 6.85s 6.88s 27: item := e.Value.(*kv.Pair) 5.71s 8.19s 28: if !dbm.IsKeyInDomain(item.Key, start, end) { 120ms 120ms 29: if entered { . . 30: break . . 31: } . . 32: . . 33: continue . . 34: } . . 35: 820ms 980ms 36: itemsInDomain = append(itemsInDomain, item) . . 37: entered = true . . 38: } . . 39: . 1.21s 40: return &memIterator{ . . 41: start: start, . . 42: end: end, . . 43: items: itemsInDomain, . . 44: ascending: ascending, . . 45: } ``` and given that the list only uses that type, it is only right to lift the code from container/list.List, and only modify Element.Value's type. For emphasis, the code is basically just a retrofit of container/list/list.go but with a typing, and we'll keep it as is until perhaps Go1.17 or Go1.18 or when everyone uses Go1.17+ after generics have landed. * After this commit ```shell Total: 45.25s ROUTINE ======================== github.com/cosmos/cosmos-sdk/store/cachekv.newMemIterator in /Users/emmanuelodeke/go/src/github.com/cosmos/cosmos-sdk/store/cachekv/memiterator.go 4.84s 6.77s (flat, cum) 14.96% of Total . . 16: items []*kv.Pair . . 17: ascending bool . . 18:} . . 19: . . 20:func newMemIterator(start, end []byte, items *kv.List, ascending bool) *memIterator { . 330ms 21: itemsInDomain := make([]*kv.Pair, 0, items.Len()) . . 22: . . 23: var entered bool . . 24: 60ms 160ms 25: for e := items.Front(); e != nil; e = e.Next() { 580ms 580ms 26: item := e.Value 3.68s 4.78s 27: if !dbm.IsKeyInDomain(item.Key, start, end) { 80ms 80ms 28: if entered { . . 29: break . . 30: } . . 31: . . 32: continue . . 33: } . . 34: 440ms 580ms 35: itemsInDomain = append(itemsInDomain, item) . . 36: entered = true . . 37: } . . 38: . 260ms 39: return &memIterator{ . . 40: start: start, . . 41: end: end, . . 42: items: itemsInDomain, . . 43: ascending: ascending, . . 44: } ``` Fixes #8810 |
||
---|---|---|
.. | ||
cache | ||
cachekv | ||
cachemulti | ||
dbadapter | ||
gaskv | ||
iavl | ||
internal | ||
mem | ||
prefix | ||
rootmulti | ||
tracekv | ||
transient | ||
types | ||
README.md | ||
firstlast.go | ||
reexport.go | ||
store.go |
README.md
Store
CacheKV
cachekv.Store
is a wrapper KVStore
which provides buffered writing / cached reading functionalities over the underlying KVStore
.
type Store struct {
cache map[string]cValue
parent types.KVStore
}
Get
Store.Get()
checks Store.cache
first in order to find if there is any cached value associated with the key. If the value exists, the function returns it. If not, the function calls Store.parent.Get()
, sets the key-value pair to the Store.cache
, and returns it.
Set
Store.Set()
sets the key-value pair to the Store.cache
. cValue
has the field dirty bool
which indicates whether the cached value is different from the underlying value. When Store.Set()
cache new pair, the cValue.dirty
is set true so when Store.Write()
is called it can be written to the underlying store.
Iterator
Store.Iterator()
have to traverse on both caches items and the original items. In Store.iterator()
, two iterators are generated for each of them, and merged. memIterator
is essentially a slice of the KVPair
s, used for cached items. mergeIterator
is a combination of two iterators, where traverse happens ordered on both iterators.
CacheMulti
cachemulti.Store
is a wrapper MultiStore
which provides buffered writing / cached reading functionalities over the underlying MutliStore
type Store struct {
db types.CacheKVStore
stores map[types.StoreKey] types.CacheWrap
}
cachemulti.Store
branches all substores in its constructor and hold them in Store.stores
. Store.GetKVStore()
returns the store from Store.stores
, and Store.Write()
recursively calls CacheWrap.Write()
on the substores.
DBAdapter
dbadapter.Store
is a adapter for dbm.DB
making it fulfilling the KVStore
interface.
type Store struct {
dbm.DB
}
dbadapter.Store
embeds dbm.DB
, so most of the KVStore
interface functions are implemented. The other functions(mostly miscellaneous) are manually implemented.
IAVL
iavl.Store
is a base-layer self-balancing merkle tree. It is guaranteed that
- Get & set operations are
O(log n)
, wheren
is the number of elements in the tree - Iteration efficiently returns the sorted elements within the range
- Each tree version is immutable and can be retrieved even after a commit(depending on the pruning settings)
Specification and implementation of IAVL tree can be found in [https://github.com/tendermint/iavl].
GasKV
gaskv.Store
is a wrapper KVStore
which provides gas consuming functionalities over the underlying KVStore
.
type Store struct {
gasMeter types.GasMeter
gasConfig types.GasConfig
parent types.KVStore
}
When each KVStore
methods are called, gaskv.Store
automatically consumes appropriate amount of gas depending on the Store.gasConfig
.
Prefix
prefix.Store
is a wrapper KVStore
which provides automatic key-prefixing functionalities over the underlying KVStore
.
type Store struct {
parent types.KVStore
prefix []byte
}
When Store.{Get, Set}()
is called, the store forwards the call to its parent, with the key prefixed with the Store.prefix
.
When Store.Iterator()
is called, it does not simply prefix the Store.prefix
, since it does not work as intended. In that case, some of the elements are traversed even they are not starting with the prefix.
RootMulti
rootmulti.Store
is a base-layer MultiStore
where multiple KVStore
can be mounted on it and retrieved via object-capability keys. The keys are memory addresses, so it is impossible to forge the key unless an object is a valid owner(or a receiver) of the key, according to the object capability principles.
TraceKV
tracekv.Store
is a wrapper KVStore
which provides operation tracing functionalities over the underlying KVStore
.
type Store struct {
parent types.KVStore
writer io.Writer
context types.TraceContext
}
When each KVStore
methods are called, tracekv.Store
automatically logs traceOperation
to the Store.writer
.
type traceOperation struct {
Operation operation
Key string
Value string
Metadata map[string]interface{}
}
traceOperation.Metadata
is filled with Store.context
when it is not nil. TraceContext
is a map[string]interface{}
.
Transient
transient.Store
is a base-layer KVStore
which is automatically discarded at the end of the block.
type Store struct {
dbadapter.Store
}
Store.Store
is a dbadapter.Store
with a dbm.NewMemDB()
. All KVStore
methods are reused. When Store.Commit()
is called, new dbadapter.Store
is assigned, discarding previous reference and making it garbage collected.