forked from mirror/go-ethereum
Péter Szilágyi
5 years ago
parent
7e38996301
commit
e567675473
@ -0,0 +1,116 @@ |
||||
// Copyright 2019 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package snapshot |
||||
|
||||
import ( |
||||
"bytes" |
||||
"sort" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
) |
||||
|
||||
// AccountIterator is an iterator to step over all the accounts in a snapshot,
|
||||
// which may or may npt be composed of multiple layers.
|
||||
type AccountIterator interface { |
||||
// Seek steps the iterator forward as many elements as needed, so that after
|
||||
// calling Next(), the iterator will be at a key higher than the given hash.
|
||||
Seek(hash common.Hash) |
||||
|
||||
// Next steps the iterator forward one element, returning false if exhausted,
|
||||
// or an error if iteration failed for some reason (e.g. root being iterated
|
||||
// becomes stale and garbage collected).
|
||||
Next() bool |
||||
|
||||
// Error returns any failure that occurred during iteration, which might have
|
||||
// caused a premature iteration exit (e.g. snapshot stack becoming stale).
|
||||
Error() error |
||||
|
||||
// Key returns the hash of the account the iterator is currently at.
|
||||
Key() common.Hash |
||||
|
||||
// Value returns the RLP encoded slim account the iterator is currently at.
|
||||
// An error will be returned if the iterator becomes invalid (e.g. snaph
|
||||
Value() []byte |
||||
} |
||||
|
||||
// diffAccountIterator is an account iterator that steps over the accounts (both
|
||||
// live and deleted) contained within a single
|
||||
type diffAccountIterator struct { |
||||
layer *diffLayer |
||||
index int |
||||
} |
||||
|
||||
func (dl *diffLayer) newAccountIterator() *diffAccountIterator { |
||||
dl.AccountList() |
||||
return &diffAccountIterator{layer: dl, index: -1} |
||||
} |
||||
|
||||
// Seek steps the iterator forward as many elements as needed, so that after
|
||||
// calling Next(), the iterator will be at a key higher than the given hash.
|
||||
func (it *diffAccountIterator) Seek(key common.Hash) { |
||||
// Search uses binary search to find and return the smallest index i
|
||||
// in [0, n) at which f(i) is true
|
||||
index := sort.Search(len(it.layer.accountList), func(i int) bool { |
||||
return bytes.Compare(key[:], it.layer.accountList[i][:]) < 0 |
||||
}) |
||||
it.index = index - 1 |
||||
} |
||||
|
||||
// Next steps the iterator forward one element, returning false if exhausted.
|
||||
func (it *diffAccountIterator) Next() bool { |
||||
if it.index < len(it.layer.accountList) { |
||||
it.index++ |
||||
} |
||||
return it.index < len(it.layer.accountList) |
||||
} |
||||
|
||||
// Error returns any failure that occurred during iteration, which might have
|
||||
// caused a premature iteration exit (e.g. snapshot stack becoming stale).
|
||||
//
|
||||
// A diff layer is immutable after creation content wise and can always be fully
|
||||
// iterated without error, so this method always returns nil.
|
||||
func (it *diffAccountIterator) Error() error { |
||||
return nil |
||||
} |
||||
|
||||
// Key returns the hash of the account the iterator is currently at.
|
||||
func (it *diffAccountIterator) Key() common.Hash { |
||||
if it.index < len(it.layer.accountList) { |
||||
return it.layer.accountList[it.index] |
||||
} |
||||
return common.Hash{} |
||||
} |
||||
|
||||
// Value returns the RLP encoded slim account the iterator is currently at.
|
||||
func (it *diffAccountIterator) Value() []byte { |
||||
it.layer.lock.RLock() |
||||
defer it.layer.lock.RUnlock() |
||||
|
||||
hash := it.layer.accountList[it.index] |
||||
if data, ok := it.layer.accountData[hash]; ok { |
||||
return data |
||||
} |
||||
panic("iterator references non-existent layer account") |
||||
} |
||||
|
||||
func (dl *diffLayer) iterators() []AccountIterator { |
||||
if parent, ok := dl.parent.(*diffLayer); ok { |
||||
iterators := parent.iterators() |
||||
return append(iterators, dl.newAccountIterator()) |
||||
} |
||||
return []AccountIterator{dl.newAccountIterator()} |
||||
} |
||||
@ -0,0 +1,115 @@ |
||||
// Copyright 2019 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package snapshot |
||||
|
||||
import ( |
||||
"bytes" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
) |
||||
|
||||
// binaryAccountIterator is a simplistic iterator to step over the accounts in
|
||||
// a snapshot, which may or may npt be composed of multiple layers. Performance
|
||||
// wise this iterator is slow, it's meant for cross validating the fast one,
|
||||
type binaryAccountIterator struct { |
||||
a *diffAccountIterator |
||||
b AccountIterator |
||||
aDone bool |
||||
bDone bool |
||||
k common.Hash |
||||
fail error |
||||
} |
||||
|
||||
// newBinaryAccountIterator creates a simplistic account iterator to step over
|
||||
// all the accounts in a slow, but eaily verifyable way.
|
||||
func (dl *diffLayer) newBinaryAccountIterator() AccountIterator { |
||||
parent, ok := dl.parent.(*diffLayer) |
||||
if !ok { |
||||
// parent is the disk layer
|
||||
return dl.newAccountIterator() |
||||
} |
||||
l := &binaryAccountIterator{ |
||||
a: dl.newAccountIterator(), |
||||
b: parent.newBinaryAccountIterator(), |
||||
} |
||||
l.aDone = !l.a.Next() |
||||
l.bDone = !l.b.Next() |
||||
return l |
||||
} |
||||
|
||||
// Seek steps the iterator forward as many elements as needed, so that after
|
||||
// calling Next(), the iterator will be at a key higher than the given hash.
|
||||
func (it *binaryAccountIterator) Seek(key common.Hash) { |
||||
panic("todo: implement") |
||||
} |
||||
|
||||
// Next steps the iterator forward one element, returning false if exhausted,
|
||||
// or an error if iteration failed for some reason (e.g. root being iterated
|
||||
// becomes stale and garbage collected).
|
||||
func (it *binaryAccountIterator) Next() bool { |
||||
if it.aDone && it.bDone { |
||||
return false |
||||
} |
||||
nextB := it.b.Key() |
||||
first: |
||||
nextA := it.a.Key() |
||||
if it.aDone { |
||||
it.bDone = !it.b.Next() |
||||
it.k = nextB |
||||
return true |
||||
} |
||||
if it.bDone { |
||||
it.aDone = !it.a.Next() |
||||
it.k = nextA |
||||
return true |
||||
} |
||||
if diff := bytes.Compare(nextA[:], nextB[:]); diff < 0 { |
||||
it.aDone = !it.a.Next() |
||||
it.k = nextA |
||||
return true |
||||
} else if diff == 0 { |
||||
// Now we need to advance one of them
|
||||
it.aDone = !it.a.Next() |
||||
goto first |
||||
} |
||||
it.bDone = !it.b.Next() |
||||
it.k = nextB |
||||
return true |
||||
} |
||||
|
||||
// Error returns any failure that occurred during iteration, which might have
|
||||
// caused a premature iteration exit (e.g. snapshot stack becoming stale).
|
||||
func (it *binaryAccountIterator) Error() error { |
||||
return it.fail |
||||
} |
||||
|
||||
// Key returns the hash of the account the iterator is currently at.
|
||||
func (it *binaryAccountIterator) Key() common.Hash { |
||||
return it.k |
||||
} |
||||
|
||||
// Value returns the RLP encoded slim account the iterator is currently at, or
|
||||
// nil if the iterated snapshot stack became stale (you can check Error after
|
||||
// to see if it failed or not).
|
||||
func (it *binaryAccountIterator) Value() []byte { |
||||
blob, err := it.a.layer.AccountRLP(it.k) |
||||
if err != nil { |
||||
it.fail = err |
||||
return nil |
||||
} |
||||
return blob |
||||
} |
||||
@ -0,0 +1,211 @@ |
||||
// Copyright 2019 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package snapshot |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"sort" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
) |
||||
|
||||
// fastAccountIterator is a more optimized multi-layer iterator which maintains a
|
||||
// direct mapping of all iterators leading down to the bottom layer
|
||||
type fastAccountIterator struct { |
||||
iterators []AccountIterator |
||||
initiated bool |
||||
fail error |
||||
} |
||||
|
||||
// The fast iterator does not query parents as much.
|
||||
func (dl *diffLayer) newFastAccountIterator() AccountIterator { |
||||
f := &fastAccountIterator{ |
||||
iterators: dl.iterators(), |
||||
initiated: false, |
||||
} |
||||
f.Seek(common.Hash{}) |
||||
return f |
||||
} |
||||
|
||||
// Len returns the number of active iterators
|
||||
func (fi *fastAccountIterator) Len() int { |
||||
return len(fi.iterators) |
||||
} |
||||
|
||||
// Less implements sort.Interface
|
||||
func (fi *fastAccountIterator) Less(i, j int) bool { |
||||
a := fi.iterators[i].Key() |
||||
b := fi.iterators[j].Key() |
||||
return bytes.Compare(a[:], b[:]) < 0 |
||||
} |
||||
|
||||
// Swap implements sort.Interface
|
||||
func (fi *fastAccountIterator) Swap(i, j int) { |
||||
fi.iterators[i], fi.iterators[j] = fi.iterators[j], fi.iterators[i] |
||||
} |
||||
|
||||
func (fi *fastAccountIterator) Seek(key common.Hash) { |
||||
// We need to apply this across all iterators
|
||||
var seen = make(map[common.Hash]struct{}) |
||||
|
||||
length := len(fi.iterators) |
||||
for i, it := range fi.iterators { |
||||
it.Seek(key) |
||||
for { |
||||
if !it.Next() { |
||||
// To be removed
|
||||
// swap it to the last position for now
|
||||
fi.iterators[i], fi.iterators[length-1] = fi.iterators[length-1], fi.iterators[i] |
||||
length-- |
||||
break |
||||
} |
||||
v := it.Key() |
||||
if _, exist := seen[v]; !exist { |
||||
seen[v] = struct{}{} |
||||
break |
||||
} |
||||
} |
||||
} |
||||
// Now remove those that were placed in the end
|
||||
fi.iterators = fi.iterators[:length] |
||||
// The list is now totally unsorted, need to re-sort the entire list
|
||||
sort.Sort(fi) |
||||
fi.initiated = false |
||||
} |
||||
|
||||
// Next implements the Iterator interface. It returns false if no more elemnts
|
||||
// can be retrieved (false == exhausted)
|
||||
func (fi *fastAccountIterator) Next() bool { |
||||
if len(fi.iterators) == 0 { |
||||
return false |
||||
} |
||||
if !fi.initiated { |
||||
// Don't forward first time -- we had to 'Next' once in order to
|
||||
// do the sorting already
|
||||
fi.initiated = true |
||||
return true |
||||
} |
||||
return fi.innerNext(0) |
||||
} |
||||
|
||||
// innerNext handles the next operation internally,
|
||||
// and should be invoked when we know that two elements in the list may have
|
||||
// the same value.
|
||||
// For example, if the list becomes [2,3,5,5,8,9,10], then we should invoke
|
||||
// innerNext(3), which will call Next on elem 3 (the second '5'). It will continue
|
||||
// along the list and apply the same operation if needed
|
||||
func (fi *fastAccountIterator) innerNext(pos int) bool { |
||||
if !fi.iterators[pos].Next() { |
||||
//Exhausted, remove this iterator
|
||||
fi.remove(pos) |
||||
if len(fi.iterators) == 0 { |
||||
return false |
||||
} |
||||
return true |
||||
} |
||||
if pos == len(fi.iterators)-1 { |
||||
// Only one iterator left
|
||||
return true |
||||
} |
||||
// We next:ed the elem at 'pos'. Now we may have to re-sort that elem
|
||||
val, neighbour := fi.iterators[pos].Key(), fi.iterators[pos+1].Key() |
||||
diff := bytes.Compare(val[:], neighbour[:]) |
||||
if diff < 0 { |
||||
// It is still in correct place
|
||||
return true |
||||
} |
||||
if diff == 0 { |
||||
// It has same value as the neighbour. So still in correct place, but
|
||||
// we need to iterate on the neighbour
|
||||
fi.innerNext(pos + 1) |
||||
return true |
||||
} |
||||
// At this point, the elem is in the wrong location, but the
|
||||
// remaining list is sorted. Find out where to move the elem
|
||||
iterationNeeded := false |
||||
index := sort.Search(len(fi.iterators), func(n int) bool { |
||||
if n <= pos { |
||||
// No need to search 'behind' us
|
||||
return false |
||||
} |
||||
if n == len(fi.iterators)-1 { |
||||
// Can always place an elem last
|
||||
return true |
||||
} |
||||
neighbour := fi.iterators[n+1].Key() |
||||
diff := bytes.Compare(val[:], neighbour[:]) |
||||
if diff == 0 { |
||||
// The elem we're placing it next to has the same value,
|
||||
// so it's going to need further iteration
|
||||
iterationNeeded = true |
||||
} |
||||
return diff < 0 |
||||
}) |
||||
fi.move(pos, index) |
||||
if iterationNeeded { |
||||
fi.innerNext(index) |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// move moves an iterator to another position in the list
|
||||
func (fi *fastAccountIterator) move(index, newpos int) { |
||||
if newpos > len(fi.iterators)-1 { |
||||
newpos = len(fi.iterators) - 1 |
||||
} |
||||
var ( |
||||
elem = fi.iterators[index] |
||||
middle = fi.iterators[index+1 : newpos+1] |
||||
suffix []AccountIterator |
||||
) |
||||
if newpos < len(fi.iterators)-1 { |
||||
suffix = fi.iterators[newpos+1:] |
||||
} |
||||
fi.iterators = append(fi.iterators[:index], middle...) |
||||
fi.iterators = append(fi.iterators, elem) |
||||
fi.iterators = append(fi.iterators, suffix...) |
||||
} |
||||
|
||||
// remove drops an iterator from the list
|
||||
func (fi *fastAccountIterator) remove(index int) { |
||||
fi.iterators = append(fi.iterators[:index], fi.iterators[index+1:]...) |
||||
} |
||||
|
||||
// Error returns any failure that occurred during iteration, which might have
|
||||
// caused a premature iteration exit (e.g. snapshot stack becoming stale).
|
||||
func (fi *fastAccountIterator) Error() error { |
||||
return fi.fail |
||||
} |
||||
|
||||
// Key returns the current key
|
||||
func (fi *fastAccountIterator) Key() common.Hash { |
||||
return fi.iterators[0].Key() |
||||
} |
||||
|
||||
// Value returns the current key
|
||||
func (fi *fastAccountIterator) Value() []byte { |
||||
panic("todo") |
||||
} |
||||
|
||||
// Debug is a convencience helper during testing
|
||||
func (fi *fastAccountIterator) Debug() { |
||||
for _, it := range fi.iterators { |
||||
fmt.Printf(" %v ", it.Key()[31]) |
||||
} |
||||
fmt.Println() |
||||
} |
||||
@ -0,0 +1,396 @@ |
||||
// Copyright 2019 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package snapshot |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/binary" |
||||
"math/rand" |
||||
"testing" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
) |
||||
|
||||
// TestIteratorBasics tests some simple single-layer iteration
|
||||
func TestIteratorBasics(t *testing.T) { |
||||
var ( |
||||
accounts = make(map[common.Hash][]byte) |
||||
storage = make(map[common.Hash]map[common.Hash][]byte) |
||||
) |
||||
// Fill up a parent
|
||||
for i := 0; i < 100; i++ { |
||||
h := randomHash() |
||||
data := randomAccount() |
||||
accounts[h] = data |
||||
if rand.Intn(20) < 10 { |
||||
accStorage := make(map[common.Hash][]byte) |
||||
value := make([]byte, 32) |
||||
rand.Read(value) |
||||
accStorage[randomHash()] = value |
||||
storage[h] = accStorage |
||||
} |
||||
} |
||||
// Add some (identical) layers on top
|
||||
parent := newDiffLayer(emptyLayer(), common.Hash{}, accounts, storage) |
||||
it := parent.newAccountIterator() |
||||
verifyIterator(t, 100, it) |
||||
} |
||||
|
||||
type testIterator struct { |
||||
values []byte |
||||
} |
||||
|
||||
func newTestIterator(values ...byte) *testIterator { |
||||
return &testIterator{values} |
||||
} |
||||
|
||||
func (ti *testIterator) Seek(common.Hash) { |
||||
panic("implement me") |
||||
} |
||||
|
||||
func (ti *testIterator) Next() bool { |
||||
ti.values = ti.values[1:] |
||||
if len(ti.values) == 0 { |
||||
return false |
||||
} |
||||
return true |
||||
} |
||||
|
||||
func (ti *testIterator) Error() error { |
||||
panic("implement me") |
||||
} |
||||
|
||||
func (ti *testIterator) Key() common.Hash { |
||||
return common.BytesToHash([]byte{ti.values[0]}) |
||||
} |
||||
|
||||
func (ti *testIterator) Value() []byte { |
||||
panic("implement me") |
||||
} |
||||
|
||||
func TestFastIteratorBasics(t *testing.T) { |
||||
type testCase struct { |
||||
lists [][]byte |
||||
expKeys []byte |
||||
} |
||||
for i, tc := range []testCase{ |
||||
{lists: [][]byte{{0, 1, 8}, {1, 2, 8}, {2, 9}, {4}, |
||||
{7, 14, 15}, {9, 13, 15, 16}}, |
||||
expKeys: []byte{0, 1, 2, 4, 7, 8, 9, 13, 14, 15, 16}}, |
||||
{lists: [][]byte{{0, 8}, {1, 2, 8}, {7, 14, 15}, {8, 9}, |
||||
{9, 10}, {10, 13, 15, 16}}, |
||||
expKeys: []byte{0, 1, 2, 7, 8, 9, 10, 13, 14, 15, 16}}, |
||||
} { |
||||
var iterators []AccountIterator |
||||
for _, data := range tc.lists { |
||||
iterators = append(iterators, newTestIterator(data...)) |
||||
|
||||
} |
||||
fi := &fastAccountIterator{ |
||||
iterators: iterators, |
||||
initiated: false, |
||||
} |
||||
count := 0 |
||||
for fi.Next() { |
||||
if got, exp := fi.Key()[31], tc.expKeys[count]; exp != got { |
||||
t.Errorf("tc %d, [%d]: got %d exp %d", i, count, got, exp) |
||||
} |
||||
count++ |
||||
} |
||||
} |
||||
} |
||||
|
||||
func verifyIterator(t *testing.T, expCount int, it AccountIterator) { |
||||
var ( |
||||
i = 0 |
||||
last = common.Hash{} |
||||
) |
||||
for it.Next() { |
||||
v := it.Key() |
||||
if bytes.Compare(last[:], v[:]) >= 0 { |
||||
t.Errorf("Wrong order:\n%x \n>=\n%x", last, v) |
||||
} |
||||
i++ |
||||
} |
||||
if i != expCount { |
||||
t.Errorf("iterator len wrong, expected %d, got %d", expCount, i) |
||||
} |
||||
} |
||||
|
||||
// TestIteratorTraversal tests some simple multi-layer iteration
|
||||
func TestIteratorTraversal(t *testing.T) { |
||||
var ( |
||||
storage = make(map[common.Hash]map[common.Hash][]byte) |
||||
) |
||||
|
||||
mkAccounts := func(args ...string) map[common.Hash][]byte { |
||||
accounts := make(map[common.Hash][]byte) |
||||
for _, h := range args { |
||||
accounts[common.HexToHash(h)] = randomAccount() |
||||
} |
||||
return accounts |
||||
} |
||||
// entries in multiple layers should only become output once
|
||||
parent := newDiffLayer(emptyLayer(), common.Hash{}, |
||||
mkAccounts("0xaa", "0xee", "0xff", "0xf0"), storage) |
||||
|
||||
child := parent.Update(common.Hash{}, |
||||
mkAccounts("0xbb", "0xdd", "0xf0"), storage) |
||||
|
||||
child = child.Update(common.Hash{}, |
||||
mkAccounts("0xcc", "0xf0", "0xff"), storage) |
||||
|
||||
// single layer iterator
|
||||
verifyIterator(t, 3, child.newAccountIterator()) |
||||
// multi-layered binary iterator
|
||||
verifyIterator(t, 7, child.newBinaryAccountIterator()) |
||||
// multi-layered fast iterator
|
||||
verifyIterator(t, 7, child.newFastAccountIterator()) |
||||
} |
||||
|
||||
func TestIteratorLargeTraversal(t *testing.T) { |
||||
// This testcase is a bit notorious -- all layers contain the exact
|
||||
// same 200 accounts.
|
||||
var storage = make(map[common.Hash]map[common.Hash][]byte) |
||||
mkAccounts := func(num int) map[common.Hash][]byte { |
||||
accounts := make(map[common.Hash][]byte) |
||||
for i := 0; i < num; i++ { |
||||
h := common.Hash{} |
||||
binary.BigEndian.PutUint64(h[:], uint64(i+1)) |
||||
accounts[h] = randomAccount() |
||||
} |
||||
return accounts |
||||
} |
||||
parent := newDiffLayer(emptyLayer(), common.Hash{}, |
||||
mkAccounts(200), storage) |
||||
child := parent.Update(common.Hash{}, |
||||
mkAccounts(200), storage) |
||||
for i := 2; i < 100; i++ { |
||||
child = child.Update(common.Hash{}, |
||||
mkAccounts(200), storage) |
||||
} |
||||
// single layer iterator
|
||||
verifyIterator(t, 200, child.newAccountIterator()) |
||||
// multi-layered binary iterator
|
||||
verifyIterator(t, 200, child.newBinaryAccountIterator()) |
||||
// multi-layered fast iterator
|
||||
verifyIterator(t, 200, child.newFastAccountIterator()) |
||||
} |
||||
|
||||
// BenchmarkIteratorTraversal is a bit a bit notorious -- all layers contain the exact
|
||||
// same 200 accounts. That means that we need to process 2000 items, but only
|
||||
// spit out 200 values eventually.
|
||||
//
|
||||
//BenchmarkIteratorTraversal/binary_iterator-6 2008 573290 ns/op 9520 B/op 199 allocs/op
|
||||
//BenchmarkIteratorTraversal/fast_iterator-6 1946 575596 ns/op 20146 B/op 134 allocs/op
|
||||
func BenchmarkIteratorTraversal(b *testing.B) { |
||||
|
||||
var storage = make(map[common.Hash]map[common.Hash][]byte) |
||||
|
||||
mkAccounts := func(num int) map[common.Hash][]byte { |
||||
accounts := make(map[common.Hash][]byte) |
||||
for i := 0; i < num; i++ { |
||||
h := common.Hash{} |
||||
binary.BigEndian.PutUint64(h[:], uint64(i+1)) |
||||
accounts[h] = randomAccount() |
||||
} |
||||
return accounts |
||||
} |
||||
parent := newDiffLayer(emptyLayer(), common.Hash{}, |
||||
mkAccounts(200), storage) |
||||
|
||||
child := parent.Update(common.Hash{}, |
||||
mkAccounts(200), storage) |
||||
|
||||
for i := 2; i < 100; i++ { |
||||
child = child.Update(common.Hash{}, |
||||
mkAccounts(200), storage) |
||||
|
||||
} |
||||
// We call this once before the benchmark, so the creation of
|
||||
// sorted accountlists are not included in the results.
|
||||
child.newBinaryAccountIterator() |
||||
b.Run("binary iterator", func(b *testing.B) { |
||||
for i := 0; i < b.N; i++ { |
||||
got := 0 |
||||
it := child.newBinaryAccountIterator() |
||||
for it.Next() { |
||||
got++ |
||||
} |
||||
if exp := 200; got != exp { |
||||
b.Errorf("iterator len wrong, expected %d, got %d", exp, got) |
||||
} |
||||
} |
||||
}) |
||||
b.Run("fast iterator", func(b *testing.B) { |
||||
for i := 0; i < b.N; i++ { |
||||
got := 0 |
||||
it := child.newFastAccountIterator() |
||||
for it.Next() { |
||||
got++ |
||||
} |
||||
if exp := 200; got != exp { |
||||
b.Errorf("iterator len wrong, expected %d, got %d", exp, got) |
||||
} |
||||
} |
||||
}) |
||||
} |
||||
|
||||
// BenchmarkIteratorLargeBaselayer is a pretty realistic benchmark, where
|
||||
// the baselayer is a lot larger than the upper layer.
|
||||
//
|
||||
// This is heavy on the binary iterator, which in most cases will have to
|
||||
// call recursively 100 times for the majority of the values
|
||||
//
|
||||
// BenchmarkIteratorLargeBaselayer/binary_iterator-6 585 2067377 ns/op 9520 B/op 199 allocs/op
|
||||
// BenchmarkIteratorLargeBaselayer/fast_iterator-6 13198 91043 ns/op 8601 B/op 118 allocs/op
|
||||
func BenchmarkIteratorLargeBaselayer(b *testing.B) { |
||||
var storage = make(map[common.Hash]map[common.Hash][]byte) |
||||
|
||||
mkAccounts := func(num int) map[common.Hash][]byte { |
||||
accounts := make(map[common.Hash][]byte) |
||||
for i := 0; i < num; i++ { |
||||
h := common.Hash{} |
||||
binary.BigEndian.PutUint64(h[:], uint64(i+1)) |
||||
accounts[h] = randomAccount() |
||||
} |
||||
return accounts |
||||
} |
||||
|
||||
parent := newDiffLayer(emptyLayer(), common.Hash{}, |
||||
mkAccounts(2000), storage) |
||||
|
||||
child := parent.Update(common.Hash{}, |
||||
mkAccounts(20), storage) |
||||
|
||||
for i := 2; i < 100; i++ { |
||||
child = child.Update(common.Hash{}, |
||||
mkAccounts(20), storage) |
||||
|
||||
} |
||||
// We call this once before the benchmark, so the creation of
|
||||
// sorted accountlists are not included in the results.
|
||||
child.newBinaryAccountIterator() |
||||
b.Run("binary iterator", func(b *testing.B) { |
||||
for i := 0; i < b.N; i++ { |
||||
got := 0 |
||||
it := child.newBinaryAccountIterator() |
||||
for it.Next() { |
||||
got++ |
||||
} |
||||
if exp := 2000; got != exp { |
||||
b.Errorf("iterator len wrong, expected %d, got %d", exp, got) |
||||
} |
||||
} |
||||
}) |
||||
b.Run("fast iterator", func(b *testing.B) { |
||||
for i := 0; i < b.N; i++ { |
||||
got := 0 |
||||
it := child.newFastAccountIterator() |
||||
for it.Next() { |
||||
got++ |
||||
} |
||||
if exp := 2000; got != exp { |
||||
b.Errorf("iterator len wrong, expected %d, got %d", exp, got) |
||||
} |
||||
} |
||||
}) |
||||
} |
||||
|
||||
// TestIteratorFlatting tests what happens when we
|
||||
// - have a live iterator on child C (parent C1 -> C2 .. CN)
|
||||
// - flattens C2 all the way into CN
|
||||
// - continues iterating
|
||||
// Right now, this "works" simply because the keys do not change -- the
|
||||
// iterator is not aware that a layer has become stale. This naive
|
||||
// solution probably won't work in the long run, however
|
||||
func TestIteratorFlattning(t *testing.T) { |
||||
var ( |
||||
storage = make(map[common.Hash]map[common.Hash][]byte) |
||||
) |
||||
mkAccounts := func(args ...string) map[common.Hash][]byte { |
||||
accounts := make(map[common.Hash][]byte) |
||||
for _, h := range args { |
||||
accounts[common.HexToHash(h)] = randomAccount() |
||||
} |
||||
return accounts |
||||
} |
||||
// entries in multiple layers should only become output once
|
||||
parent := newDiffLayer(emptyLayer(), common.Hash{}, |
||||
mkAccounts("0xaa", "0xee", "0xff", "0xf0"), storage) |
||||
|
||||
child := parent.Update(common.Hash{}, |
||||
mkAccounts("0xbb", "0xdd", "0xf0"), storage) |
||||
|
||||
child = child.Update(common.Hash{}, |
||||
mkAccounts("0xcc", "0xf0", "0xff"), storage) |
||||
|
||||
it := child.newFastAccountIterator() |
||||
child.parent.(*diffLayer).flatten() |
||||
// The parent should now be stale
|
||||
verifyIterator(t, 7, it) |
||||
} |
||||
|
||||
func TestIteratorSeek(t *testing.T) { |
||||
storage := make(map[common.Hash]map[common.Hash][]byte) |
||||
mkAccounts := func(args ...string) map[common.Hash][]byte { |
||||
accounts := make(map[common.Hash][]byte) |
||||
for _, h := range args { |
||||
accounts[common.HexToHash(h)] = randomAccount() |
||||
} |
||||
return accounts |
||||
} |
||||
parent := newDiffLayer(emptyLayer(), common.Hash{}, |
||||
mkAccounts("0xaa", "0xee", "0xff", "0xf0"), storage) |
||||
it := AccountIterator(parent.newAccountIterator()) |
||||
// expected: ee, f0, ff
|
||||
it.Seek(common.HexToHash("0xdd")) |
||||
verifyIterator(t, 3, it) |
||||
|
||||
it = parent.newAccountIterator() |
||||
// expected: ee, f0, ff
|
||||
it.Seek(common.HexToHash("0xaa")) |
||||
verifyIterator(t, 3, it) |
||||
|
||||
it = parent.newAccountIterator() |
||||
// expected: nothing
|
||||
it.Seek(common.HexToHash("0xff")) |
||||
verifyIterator(t, 0, it) |
||||
|
||||
child := parent.Update(common.Hash{}, |
||||
mkAccounts("0xbb", "0xdd", "0xf0"), storage) |
||||
|
||||
child = child.Update(common.Hash{}, |
||||
mkAccounts("0xcc", "0xf0", "0xff"), storage) |
||||
|
||||
it = child.newFastAccountIterator() |
||||
// expected: cc, dd, ee, f0, ff
|
||||
it.Seek(common.HexToHash("0xbb")) |
||||
verifyIterator(t, 5, it) |
||||
|
||||
it = child.newFastAccountIterator() |
||||
it.Seek(common.HexToHash("0xef")) |
||||
// exp: f0, ff
|
||||
verifyIterator(t, 2, it) |
||||
|
||||
it = child.newFastAccountIterator() |
||||
it.Seek(common.HexToHash("0xf0")) |
||||
verifyIterator(t, 1, it) |
||||
|
||||
it.Seek(common.HexToHash("0xff")) |
||||
verifyIterator(t, 0, it) |
||||
} |
||||
Loading…
Reference in new issue