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
108 lines
1.8 KiB
Go
108 lines
1.8 KiB
Go
package cachekv
|
|
|
|
import (
|
|
"errors"
|
|
|
|
dbm "github.com/tendermint/tm-db"
|
|
|
|
"github.com/cosmos/cosmos-sdk/types/kv"
|
|
)
|
|
|
|
// Iterates over iterKVCache items.
|
|
// if key is nil, means it was deleted.
|
|
// Implements Iterator.
|
|
type memIterator struct {
|
|
start, end []byte
|
|
items []*kv.Pair
|
|
ascending bool
|
|
}
|
|
|
|
func newMemIterator(start, end []byte, items *kv.List, ascending bool) *memIterator {
|
|
itemsInDomain := make([]*kv.Pair, 0, items.Len())
|
|
|
|
var entered bool
|
|
|
|
for e := items.Front(); e != nil; e = e.Next() {
|
|
item := e.Value
|
|
if !dbm.IsKeyInDomain(item.Key, start, end) {
|
|
if entered {
|
|
break
|
|
}
|
|
|
|
continue
|
|
}
|
|
|
|
itemsInDomain = append(itemsInDomain, item)
|
|
entered = true
|
|
}
|
|
|
|
return &memIterator{
|
|
start: start,
|
|
end: end,
|
|
items: itemsInDomain,
|
|
ascending: ascending,
|
|
}
|
|
}
|
|
|
|
func (mi *memIterator) Domain() ([]byte, []byte) {
|
|
return mi.start, mi.end
|
|
}
|
|
|
|
func (mi *memIterator) Valid() bool {
|
|
return len(mi.items) > 0
|
|
}
|
|
|
|
func (mi *memIterator) assertValid() {
|
|
if err := mi.Error(); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func (mi *memIterator) Next() {
|
|
mi.assertValid()
|
|
|
|
if mi.ascending {
|
|
mi.items = mi.items[1:]
|
|
} else {
|
|
mi.items = mi.items[:len(mi.items)-1]
|
|
}
|
|
}
|
|
|
|
func (mi *memIterator) Key() []byte {
|
|
mi.assertValid()
|
|
|
|
if mi.ascending {
|
|
return mi.items[0].Key
|
|
}
|
|
|
|
return mi.items[len(mi.items)-1].Key
|
|
}
|
|
|
|
func (mi *memIterator) Value() []byte {
|
|
mi.assertValid()
|
|
|
|
if mi.ascending {
|
|
return mi.items[0].Value
|
|
}
|
|
|
|
return mi.items[len(mi.items)-1].Value
|
|
}
|
|
|
|
func (mi *memIterator) Close() error {
|
|
mi.start = nil
|
|
mi.end = nil
|
|
mi.items = nil
|
|
|
|
return nil
|
|
}
|
|
|
|
// Error returns an error if the memIterator is invalid defined by the Valid
|
|
// method.
|
|
func (mi *memIterator) Error() error {
|
|
if !mi.Valid() {
|
|
return errors.New("invalid memIterator")
|
|
}
|
|
|
|
return nil
|
|
}
|