2019-08-06 05:40:28 -05:00
|
|
|
// 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 implements a journalled, dynamic state dump.
|
|
|
|
package snapshot
|
|
|
|
|
|
|
|
import (
|
2019-11-26 01:48:29 -06:00
|
|
|
"bytes"
|
2019-08-06 05:40:28 -05:00
|
|
|
"errors"
|
|
|
|
"fmt"
|
|
|
|
"sync"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
|
|
"github.com/ethereum/go-ethereum/log"
|
|
|
|
"github.com/ethereum/go-ethereum/metrics"
|
2019-11-26 01:48:29 -06:00
|
|
|
"github.com/ethereum/go-ethereum/trie"
|
2019-08-06 05:40:28 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
2019-11-26 01:48:29 -06:00
|
|
|
snapshotCleanAccountHitMeter = metrics.NewRegisteredMeter("state/snapshot/clean/account/hit", nil)
|
|
|
|
snapshotCleanAccountMissMeter = metrics.NewRegisteredMeter("state/snapshot/clean/account/miss", nil)
|
2019-12-03 02:00:26 -06:00
|
|
|
snapshotCleanAccountInexMeter = metrics.NewRegisteredMeter("state/snapshot/clean/account/inex", nil)
|
2019-11-26 01:48:29 -06:00
|
|
|
snapshotCleanAccountReadMeter = metrics.NewRegisteredMeter("state/snapshot/clean/account/read", nil)
|
|
|
|
snapshotCleanAccountWriteMeter = metrics.NewRegisteredMeter("state/snapshot/clean/account/write", nil)
|
|
|
|
|
|
|
|
snapshotCleanStorageHitMeter = metrics.NewRegisteredMeter("state/snapshot/clean/storage/hit", nil)
|
|
|
|
snapshotCleanStorageMissMeter = metrics.NewRegisteredMeter("state/snapshot/clean/storage/miss", nil)
|
2019-12-03 02:00:26 -06:00
|
|
|
snapshotCleanStorageInexMeter = metrics.NewRegisteredMeter("state/snapshot/clean/storage/inex", nil)
|
2019-11-26 01:48:29 -06:00
|
|
|
snapshotCleanStorageReadMeter = metrics.NewRegisteredMeter("state/snapshot/clean/storage/read", nil)
|
|
|
|
snapshotCleanStorageWriteMeter = metrics.NewRegisteredMeter("state/snapshot/clean/storage/write", nil)
|
|
|
|
|
|
|
|
snapshotDirtyAccountHitMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/account/hit", nil)
|
|
|
|
snapshotDirtyAccountMissMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/account/miss", nil)
|
2019-12-03 02:00:26 -06:00
|
|
|
snapshotDirtyAccountInexMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/account/inex", nil)
|
2019-11-26 01:48:29 -06:00
|
|
|
snapshotDirtyAccountReadMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/account/read", nil)
|
|
|
|
snapshotDirtyAccountWriteMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/account/write", nil)
|
|
|
|
|
|
|
|
snapshotDirtyStorageHitMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/hit", nil)
|
|
|
|
snapshotDirtyStorageMissMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/miss", nil)
|
2019-12-03 02:00:26 -06:00
|
|
|
snapshotDirtyStorageInexMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/inex", nil)
|
2019-11-26 01:48:29 -06:00
|
|
|
snapshotDirtyStorageReadMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/read", nil)
|
|
|
|
snapshotDirtyStorageWriteMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/write", nil)
|
|
|
|
|
2019-12-03 02:00:26 -06:00
|
|
|
snapshotDirtyAccountHitDepthHist = metrics.NewRegisteredHistogram("state/snapshot/dirty/account/hit/depth", nil, metrics.NewExpDecaySample(1028, 0.015))
|
|
|
|
snapshotDirtyStorageHitDepthHist = metrics.NewRegisteredHistogram("state/snapshot/dirty/storage/hit/depth", nil, metrics.NewExpDecaySample(1028, 0.015))
|
|
|
|
|
2019-11-26 01:48:29 -06:00
|
|
|
snapshotFlushAccountItemMeter = metrics.NewRegisteredMeter("state/snapshot/flush/account/item", nil)
|
|
|
|
snapshotFlushAccountSizeMeter = metrics.NewRegisteredMeter("state/snapshot/flush/account/size", nil)
|
|
|
|
snapshotFlushStorageItemMeter = metrics.NewRegisteredMeter("state/snapshot/flush/storage/item", nil)
|
|
|
|
snapshotFlushStorageSizeMeter = metrics.NewRegisteredMeter("state/snapshot/flush/storage/size", nil)
|
|
|
|
|
|
|
|
snapshotBloomIndexTimer = metrics.NewRegisteredResettingTimer("state/snapshot/bloom/index", nil)
|
|
|
|
snapshotBloomErrorGauge = metrics.NewRegisteredGaugeFloat64("state/snapshot/bloom/error", nil)
|
|
|
|
|
|
|
|
snapshotBloomAccountTrueHitMeter = metrics.NewRegisteredMeter("state/snapshot/bloom/account/truehit", nil)
|
|
|
|
snapshotBloomAccountFalseHitMeter = metrics.NewRegisteredMeter("state/snapshot/bloom/account/falsehit", nil)
|
|
|
|
snapshotBloomAccountMissMeter = metrics.NewRegisteredMeter("state/snapshot/bloom/account/miss", nil)
|
|
|
|
|
|
|
|
snapshotBloomStorageTrueHitMeter = metrics.NewRegisteredMeter("state/snapshot/bloom/storage/truehit", nil)
|
|
|
|
snapshotBloomStorageFalseHitMeter = metrics.NewRegisteredMeter("state/snapshot/bloom/storage/falsehit", nil)
|
|
|
|
snapshotBloomStorageMissMeter = metrics.NewRegisteredMeter("state/snapshot/bloom/storage/miss", nil)
|
2019-10-04 08:24:01 -05:00
|
|
|
|
|
|
|
// ErrSnapshotStale is returned from data accessors if the underlying snapshot
|
|
|
|
// layer had been invalidated due to the chain progressing forward far enough
|
|
|
|
// to not maintain the layer's original state.
|
|
|
|
ErrSnapshotStale = errors.New("snapshot stale")
|
2019-11-22 05:23:49 -06:00
|
|
|
|
2019-11-26 01:48:29 -06:00
|
|
|
// ErrNotCoveredYet is returned from data accessors if the underlying snapshot
|
|
|
|
// is being generated currently and the requested data item is not yet in the
|
|
|
|
// range of accounts covered.
|
|
|
|
ErrNotCoveredYet = errors.New("not covered yet")
|
|
|
|
|
2019-11-22 05:23:49 -06:00
|
|
|
// errSnapshotCycle is returned if a snapshot is attempted to be inserted
|
|
|
|
// that forms a cycle in the snapshot tree.
|
|
|
|
errSnapshotCycle = errors.New("snapshot cycle")
|
2019-08-06 05:40:28 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
// Snapshot represents the functionality supported by a snapshot storage layer.
|
|
|
|
type Snapshot interface {
|
2019-11-22 05:23:49 -06:00
|
|
|
// Root returns the root hash for which this snapshot was made.
|
|
|
|
Root() common.Hash
|
2019-08-06 05:40:28 -05:00
|
|
|
|
|
|
|
// Account directly retrieves the account associated with a particular hash in
|
|
|
|
// the snapshot slim data format.
|
2019-10-04 08:24:01 -05:00
|
|
|
Account(hash common.Hash) (*Account, error)
|
2019-08-06 05:40:28 -05:00
|
|
|
|
|
|
|
// AccountRLP directly retrieves the account RLP associated with a particular
|
|
|
|
// hash in the snapshot slim data format.
|
2019-10-04 08:24:01 -05:00
|
|
|
AccountRLP(hash common.Hash) ([]byte, error)
|
2019-08-06 05:40:28 -05:00
|
|
|
|
|
|
|
// Storage directly retrieves the storage data associated with a particular hash,
|
|
|
|
// within a particular account.
|
2019-10-04 08:24:01 -05:00
|
|
|
Storage(accountHash, storageHash common.Hash) ([]byte, error)
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// snapshot is the internal version of the snapshot data layer that supports some
|
|
|
|
// additional methods compared to the public API.
|
|
|
|
type snapshot interface {
|
|
|
|
Snapshot
|
|
|
|
|
|
|
|
// Update creates a new layer on top of the existing snapshot diff tree with
|
|
|
|
// the specified data items. Note, the maps are retained by the method to avoid
|
|
|
|
// copying everything.
|
|
|
|
Update(blockRoot common.Hash, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) *diffLayer
|
|
|
|
|
2019-12-02 05:27:20 -06:00
|
|
|
// Journal commits an entire diff hierarchy to disk into a single journal entry.
|
2019-08-06 05:40:28 -05:00
|
|
|
// This is meant to be used during shutdown to persist the snapshot without
|
|
|
|
// flattening everything down (bad for reorgs).
|
2019-12-02 05:27:20 -06:00
|
|
|
Journal(buffer *bytes.Buffer) (common.Hash, error)
|
2019-11-22 05:23:49 -06:00
|
|
|
|
|
|
|
// Stale return whether this layer has become stale (was flattened across) or
|
|
|
|
// if it's still live.
|
|
|
|
Stale() bool
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// SnapshotTree is an Ethereum state snapshot tree. It consists of one persistent
|
2019-10-04 08:24:01 -05:00
|
|
|
// base layer backed by a key-value store, on top of which arbitrarily many in-
|
2019-08-06 05:40:28 -05:00
|
|
|
// memory diff layers are topped. The memory diffs can form a tree with branching,
|
|
|
|
// but the disk layer is singleton and common to all. If a reorg goes deeper than
|
|
|
|
// the disk layer, everything needs to be deleted.
|
|
|
|
//
|
|
|
|
// The goal of a state snapshot is twofold: to allow direct access to account and
|
|
|
|
// storage data to avoid expensive multi-level trie lookups; and to allow sorted,
|
|
|
|
// cheap iteration of the account/storage tries for sync aid.
|
2019-11-22 05:23:49 -06:00
|
|
|
type Tree struct {
|
2019-11-26 01:48:29 -06:00
|
|
|
diskdb ethdb.KeyValueStore // Persistent database to store the snapshot
|
|
|
|
triedb *trie.Database // In-memory cache to access the trie through
|
|
|
|
cache int // Megabytes permitted to use for read caches
|
|
|
|
layers map[common.Hash]snapshot // Collection of all known layers
|
2019-08-06 05:40:28 -05:00
|
|
|
lock sync.RWMutex
|
|
|
|
}
|
|
|
|
|
|
|
|
// New attempts to load an already existing snapshot from a persistent key-value
|
|
|
|
// store (with a number of memory layers from a journal), ensuring that the head
|
|
|
|
// of the snapshot matches the expected one.
|
|
|
|
//
|
|
|
|
// If the snapshot is missing or inconsistent, the entirety is deleted and will
|
2019-11-26 01:48:29 -06:00
|
|
|
// be reconstructed from scratch based on the tries in the key-value store, on a
|
|
|
|
// background thread.
|
2019-12-02 05:27:20 -06:00
|
|
|
func New(diskdb ethdb.KeyValueStore, triedb *trie.Database, cache int, root common.Hash) *Tree {
|
2019-11-26 01:48:29 -06:00
|
|
|
// Create a new, empty snapshot tree
|
2019-11-22 05:23:49 -06:00
|
|
|
snap := &Tree{
|
2019-11-26 01:48:29 -06:00
|
|
|
diskdb: diskdb,
|
|
|
|
triedb: triedb,
|
|
|
|
cache: cache,
|
2019-08-06 05:40:28 -05:00
|
|
|
layers: make(map[common.Hash]snapshot),
|
|
|
|
}
|
2019-11-26 01:48:29 -06:00
|
|
|
// Attempt to load a previously persisted snapshot and rebuild one if failed
|
2019-12-02 05:27:20 -06:00
|
|
|
head, err := loadSnapshot(diskdb, triedb, cache, root)
|
2019-11-26 01:48:29 -06:00
|
|
|
if err != nil {
|
|
|
|
log.Warn("Failed to load snapshot, regenerating", "err", err)
|
|
|
|
snap.Rebuild(root)
|
|
|
|
return snap
|
|
|
|
}
|
|
|
|
// Existing snapshot loaded, seed all the layers
|
2019-08-06 05:40:28 -05:00
|
|
|
for head != nil {
|
2019-11-22 05:23:49 -06:00
|
|
|
snap.layers[head.Root()] = head
|
2019-08-06 05:40:28 -05:00
|
|
|
|
|
|
|
switch self := head.(type) {
|
|
|
|
case *diffLayer:
|
|
|
|
head = self.parent
|
|
|
|
case *diskLayer:
|
|
|
|
head = nil
|
|
|
|
default:
|
|
|
|
panic(fmt.Sprintf("unknown data layer: %T", self))
|
|
|
|
}
|
|
|
|
}
|
2019-11-26 01:48:29 -06:00
|
|
|
return snap
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Snapshot retrieves a snapshot belonging to the given block root, or nil if no
|
|
|
|
// snapshot is maintained for that block.
|
2019-11-22 05:23:49 -06:00
|
|
|
func (t *Tree) Snapshot(blockRoot common.Hash) Snapshot {
|
|
|
|
t.lock.RLock()
|
|
|
|
defer t.lock.RUnlock()
|
2019-08-06 05:40:28 -05:00
|
|
|
|
2019-11-22 05:23:49 -06:00
|
|
|
return t.layers[blockRoot]
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Update adds a new snapshot into the tree, if that can be linked to an existing
|
|
|
|
// old parent. It is disallowed to insert a disk layer (the origin of all).
|
2019-11-22 05:23:49 -06:00
|
|
|
func (t *Tree) Update(blockRoot common.Hash, parentRoot common.Hash, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) error {
|
|
|
|
// Reject noop updates to avoid self-loops in the snapshot tree. This is a
|
|
|
|
// special case that can only happen for Clique networks where empty blocks
|
|
|
|
// don't modify the state (0 block subsidy).
|
|
|
|
//
|
|
|
|
// Although we could silently ignore this internally, it should be the caller's
|
|
|
|
// responsibility to avoid even attempting to insert such a snapshot.
|
|
|
|
if blockRoot == parentRoot {
|
|
|
|
return errSnapshotCycle
|
|
|
|
}
|
2019-08-06 05:40:28 -05:00
|
|
|
// Generate a new snapshot on top of the parent
|
2019-11-22 05:23:49 -06:00
|
|
|
parent := t.Snapshot(parentRoot).(snapshot)
|
2019-08-06 05:40:28 -05:00
|
|
|
if parent == nil {
|
|
|
|
return fmt.Errorf("parent [%#x] snapshot missing", parentRoot)
|
|
|
|
}
|
|
|
|
snap := parent.Update(blockRoot, accounts, storage)
|
|
|
|
|
|
|
|
// Save the new snapshot for later
|
2019-11-22 05:23:49 -06:00
|
|
|
t.lock.Lock()
|
|
|
|
defer t.lock.Unlock()
|
2019-08-06 05:40:28 -05:00
|
|
|
|
2019-11-22 05:23:49 -06:00
|
|
|
t.layers[snap.root] = snap
|
2019-08-06 05:40:28 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Cap traverses downwards the snapshot tree from a head block hash until the
|
|
|
|
// number of allowed layers are crossed. All layers beyond the permitted number
|
|
|
|
// are flattened downwards.
|
2019-11-26 01:48:29 -06:00
|
|
|
func (t *Tree) Cap(root common.Hash, layers int) error {
|
2019-08-06 05:40:28 -05:00
|
|
|
// Retrieve the head snapshot to cap from
|
2019-11-22 05:23:49 -06:00
|
|
|
snap := t.Snapshot(root)
|
|
|
|
if snap == nil {
|
|
|
|
return fmt.Errorf("snapshot [%#x] missing", root)
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
2019-10-17 10:30:31 -05:00
|
|
|
diff, ok := snap.(*diffLayer)
|
|
|
|
if !ok {
|
2019-11-22 05:23:49 -06:00
|
|
|
return fmt.Errorf("snapshot [%#x] is disk layer", root)
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
2019-08-06 05:40:28 -05:00
|
|
|
// Run the internal capping and discard all stale layers
|
2019-11-22 05:23:49 -06:00
|
|
|
t.lock.Lock()
|
|
|
|
defer t.lock.Unlock()
|
2019-08-06 05:40:28 -05:00
|
|
|
|
2019-10-17 10:30:31 -05:00
|
|
|
// Flattening the bottom-most diff layer requires special casing since there's
|
|
|
|
// no child to rewire to the grandparent. In that case we can fake a temporary
|
|
|
|
// child for the capping and then remove it.
|
2019-11-26 01:48:29 -06:00
|
|
|
var persisted *diskLayer
|
|
|
|
|
2019-10-17 10:30:31 -05:00
|
|
|
switch layers {
|
|
|
|
case 0:
|
|
|
|
// If full commit was requested, flatten the diffs and merge onto disk
|
|
|
|
diff.lock.RLock()
|
|
|
|
base := diffToDisk(diff.flatten().(*diffLayer))
|
|
|
|
diff.lock.RUnlock()
|
|
|
|
|
2019-11-22 05:23:49 -06:00
|
|
|
// Replace the entire snapshot tree with the flat base
|
|
|
|
t.layers = map[common.Hash]snapshot{base.root: base}
|
|
|
|
return nil
|
2019-10-17 10:30:31 -05:00
|
|
|
|
|
|
|
case 1:
|
|
|
|
// If full flattening was requested, flatten the diffs but only merge if the
|
|
|
|
// memory limit was reached
|
|
|
|
var (
|
|
|
|
bottom *diffLayer
|
|
|
|
base *diskLayer
|
|
|
|
)
|
|
|
|
diff.lock.RLock()
|
|
|
|
bottom = diff.flatten().(*diffLayer)
|
2019-11-26 01:48:29 -06:00
|
|
|
if bottom.memory >= aggregatorMemoryLimit {
|
2019-10-17 10:30:31 -05:00
|
|
|
base = diffToDisk(bottom)
|
|
|
|
}
|
|
|
|
diff.lock.RUnlock()
|
|
|
|
|
2019-11-22 05:23:49 -06:00
|
|
|
// If all diff layers were removed, replace the entire snapshot tree
|
2019-10-17 10:30:31 -05:00
|
|
|
if base != nil {
|
2019-11-22 05:23:49 -06:00
|
|
|
t.layers = map[common.Hash]snapshot{base.root: base}
|
|
|
|
return nil
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
2019-11-22 05:23:49 -06:00
|
|
|
// Merge the new aggregated layer into the snapshot tree, clean stales below
|
|
|
|
t.layers[bottom.root] = bottom
|
2019-10-17 10:30:31 -05:00
|
|
|
|
|
|
|
default:
|
2019-11-22 05:23:49 -06:00
|
|
|
// Many layers requested to be retained, cap normally
|
2019-11-26 01:48:29 -06:00
|
|
|
persisted = t.cap(diff, layers)
|
2019-11-22 05:23:49 -06:00
|
|
|
}
|
|
|
|
// Remove any layer that is stale or links into a stale layer
|
|
|
|
children := make(map[common.Hash][]common.Hash)
|
|
|
|
for root, snap := range t.layers {
|
|
|
|
if diff, ok := snap.(*diffLayer); ok {
|
|
|
|
parent := diff.parent.Root()
|
|
|
|
children[parent] = append(children[parent], root)
|
|
|
|
}
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
2019-11-22 05:23:49 -06:00
|
|
|
var remove func(root common.Hash)
|
|
|
|
remove = func(root common.Hash) {
|
|
|
|
delete(t.layers, root)
|
|
|
|
for _, child := range children[root] {
|
|
|
|
remove(child)
|
|
|
|
}
|
|
|
|
delete(children, root)
|
|
|
|
}
|
|
|
|
for root, snap := range t.layers {
|
|
|
|
if snap.Stale() {
|
|
|
|
remove(root)
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
|
|
|
}
|
2019-11-26 01:48:29 -06:00
|
|
|
// If the disk layer was modified, regenerate all the cummulative blooms
|
|
|
|
if persisted != nil {
|
|
|
|
var rebloom func(root common.Hash)
|
|
|
|
rebloom = func(root common.Hash) {
|
|
|
|
if diff, ok := t.layers[root].(*diffLayer); ok {
|
|
|
|
diff.rebloom(persisted)
|
|
|
|
}
|
|
|
|
for _, child := range children[root] {
|
|
|
|
rebloom(child)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rebloom(persisted.root)
|
|
|
|
}
|
2019-08-06 05:40:28 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-10-17 10:30:31 -05:00
|
|
|
// cap traverses downwards the diff tree until the number of allowed layers are
|
2019-11-22 05:23:49 -06:00
|
|
|
// crossed. All diffs beyond the permitted number are flattened downwards. If the
|
|
|
|
// layer limit is reached, memory cap is also enforced (but not before).
|
2019-11-26 01:48:29 -06:00
|
|
|
//
|
|
|
|
// The method returns the new disk layer if diffs were persistend into it.
|
|
|
|
func (t *Tree) cap(diff *diffLayer, layers int) *diskLayer {
|
2019-10-17 10:30:31 -05:00
|
|
|
// Dive until we run out of layers or reach the persistent database
|
2019-10-23 08:19:02 -05:00
|
|
|
for ; layers > 2; layers-- {
|
|
|
|
// If we still have diff layers below, continue down
|
2019-10-17 10:30:31 -05:00
|
|
|
if parent, ok := diff.parent.(*diffLayer); ok {
|
2019-10-23 08:19:02 -05:00
|
|
|
diff = parent
|
|
|
|
} else {
|
2019-11-22 05:23:49 -06:00
|
|
|
// Diff stack too shallow, return without modifications
|
2019-11-26 01:48:29 -06:00
|
|
|
return nil
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// We're out of layers, flatten anything below, stopping if it's the disk or if
|
|
|
|
// the memory limit is not yet exceeded.
|
|
|
|
switch parent := diff.parent.(type) {
|
|
|
|
case *diskLayer:
|
2019-11-26 01:48:29 -06:00
|
|
|
return nil
|
2019-10-17 10:30:31 -05:00
|
|
|
|
|
|
|
case *diffLayer:
|
|
|
|
// Flatten the parent into the grandparent. The flattening internally obtains a
|
|
|
|
// write lock on grandparent.
|
|
|
|
flattened := parent.flatten().(*diffLayer)
|
2019-11-22 05:23:49 -06:00
|
|
|
t.layers[flattened.root] = flattened
|
2019-10-17 10:30:31 -05:00
|
|
|
|
|
|
|
diff.lock.Lock()
|
|
|
|
defer diff.lock.Unlock()
|
|
|
|
|
|
|
|
diff.parent = flattened
|
2019-11-26 01:48:29 -06:00
|
|
|
if flattened.memory < aggregatorMemoryLimit {
|
|
|
|
// Accumulator layer is smaller than the limit, so we can abort, unless
|
|
|
|
// there's a snapshot being generated currently. In that case, the trie
|
|
|
|
// will move fron underneath the generator so we **must** merge all the
|
|
|
|
// partial data down into the snapshot and restart the generation.
|
|
|
|
if flattened.parent.(*diskLayer).genAbort == nil {
|
|
|
|
return nil
|
|
|
|
}
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
|
|
|
default:
|
|
|
|
panic(fmt.Sprintf("unknown data layer: %T", parent))
|
|
|
|
}
|
|
|
|
// If the bottom-most layer is larger than our memory cap, persist to disk
|
|
|
|
bottom := diff.parent.(*diffLayer)
|
|
|
|
|
|
|
|
bottom.lock.RLock()
|
|
|
|
base := diffToDisk(bottom)
|
|
|
|
bottom.lock.RUnlock()
|
|
|
|
|
2019-11-22 05:23:49 -06:00
|
|
|
t.layers[base.root] = base
|
2019-10-17 10:30:31 -05:00
|
|
|
diff.parent = base
|
2019-11-26 01:48:29 -06:00
|
|
|
return base
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// diffToDisk merges a bottom-most diff into the persistent disk layer underneath
|
|
|
|
// it. The method will panic if called onto a non-bottom-most diff layer.
|
|
|
|
func diffToDisk(bottom *diffLayer) *diskLayer {
|
|
|
|
var (
|
|
|
|
base = bottom.parent.(*diskLayer)
|
2019-11-26 01:48:29 -06:00
|
|
|
batch = base.diskdb.NewBatch()
|
|
|
|
stats *generatorStats
|
2019-10-17 10:30:31 -05:00
|
|
|
)
|
2019-11-26 01:48:29 -06:00
|
|
|
// If the disk layer is running a snapshot generator, abort it
|
|
|
|
if base.genAbort != nil {
|
|
|
|
abort := make(chan *generatorStats)
|
|
|
|
base.genAbort <- abort
|
|
|
|
stats = <-abort
|
|
|
|
}
|
2019-10-17 10:30:31 -05:00
|
|
|
// Start by temporarily deleting the current snapshot block marker. This
|
|
|
|
// ensures that in the case of a crash, the entire snapshot is invalidated.
|
2019-11-22 05:23:49 -06:00
|
|
|
rawdb.DeleteSnapshotRoot(batch)
|
2019-10-17 10:30:31 -05:00
|
|
|
|
|
|
|
// Mark the original base as stale as we're going to create a new wrapper
|
|
|
|
base.lock.Lock()
|
|
|
|
if base.stale {
|
|
|
|
panic("parent disk layer is stale") // we've committed into the same base from two children, boo
|
|
|
|
}
|
|
|
|
base.stale = true
|
|
|
|
base.lock.Unlock()
|
|
|
|
|
|
|
|
// Push all the accounts into the database
|
|
|
|
for hash, data := range bottom.accountData {
|
2019-11-26 01:48:29 -06:00
|
|
|
// Skip any account not covered yet by the snapshot
|
|
|
|
if base.genMarker != nil && bytes.Compare(hash[:], base.genMarker) > 0 {
|
|
|
|
continue
|
|
|
|
}
|
2019-10-17 10:30:31 -05:00
|
|
|
if len(data) > 0 {
|
|
|
|
// Account was updated, push to disk
|
|
|
|
rawdb.WriteAccountSnapshot(batch, hash, data)
|
2019-11-25 08:30:29 -06:00
|
|
|
base.cache.Set(hash[:], data)
|
2019-12-02 05:27:20 -06:00
|
|
|
snapshotCleanAccountWriteMeter.Mark(int64(len(data)))
|
2019-10-17 10:30:31 -05:00
|
|
|
|
|
|
|
if batch.ValueSize() > ethdb.IdealBatchSize {
|
|
|
|
if err := batch.Write(); err != nil {
|
|
|
|
log.Crit("Failed to write account snapshot", "err", err)
|
|
|
|
}
|
|
|
|
batch.Reset()
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Account was deleted, remove all storage slots too
|
|
|
|
rawdb.DeleteAccountSnapshot(batch, hash)
|
2019-11-25 08:30:29 -06:00
|
|
|
base.cache.Set(hash[:], nil)
|
2019-10-17 10:30:31 -05:00
|
|
|
|
2019-11-26 01:48:29 -06:00
|
|
|
it := rawdb.IterateStorageSnapshots(base.diskdb, hash)
|
2019-10-17 10:30:31 -05:00
|
|
|
for it.Next() {
|
|
|
|
if key := it.Key(); len(key) == 65 { // TODO(karalabe): Yuck, we should move this into the iterator
|
|
|
|
batch.Delete(key)
|
2019-11-25 08:30:29 -06:00
|
|
|
base.cache.Del(key[1:])
|
2019-11-26 01:48:29 -06:00
|
|
|
|
|
|
|
snapshotFlushStorageItemMeter.Mark(1)
|
|
|
|
snapshotFlushStorageSizeMeter.Mark(int64(len(data)))
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
it.Release()
|
|
|
|
}
|
2019-11-26 01:48:29 -06:00
|
|
|
snapshotFlushAccountItemMeter.Mark(1)
|
|
|
|
snapshotFlushAccountSizeMeter.Mark(int64(len(data)))
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
|
|
|
// Push all the storage slots into the database
|
|
|
|
for accountHash, storage := range bottom.storageData {
|
2019-11-26 01:48:29 -06:00
|
|
|
// Skip any account not covered yet by the snapshot
|
|
|
|
if base.genMarker != nil && bytes.Compare(accountHash[:], base.genMarker) > 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// Generation might be mid-account, track that case too
|
|
|
|
midAccount := base.genMarker != nil && bytes.Equal(accountHash[:], base.genMarker[:common.HashLength])
|
|
|
|
|
2019-10-17 10:30:31 -05:00
|
|
|
for storageHash, data := range storage {
|
2019-11-26 01:48:29 -06:00
|
|
|
// Skip any slot not covered yet by the snapshot
|
|
|
|
if midAccount && bytes.Compare(storageHash[:], base.genMarker[common.HashLength:]) > 0 {
|
|
|
|
continue
|
|
|
|
}
|
2019-10-17 10:30:31 -05:00
|
|
|
if len(data) > 0 {
|
|
|
|
rawdb.WriteStorageSnapshot(batch, accountHash, storageHash, data)
|
2019-11-25 08:30:29 -06:00
|
|
|
base.cache.Set(append(accountHash[:], storageHash[:]...), data)
|
2019-12-02 05:27:20 -06:00
|
|
|
snapshotCleanStorageWriteMeter.Mark(int64(len(data)))
|
2019-10-17 10:30:31 -05:00
|
|
|
} else {
|
|
|
|
rawdb.DeleteStorageSnapshot(batch, accountHash, storageHash)
|
2019-11-25 08:30:29 -06:00
|
|
|
base.cache.Set(append(accountHash[:], storageHash[:]...), nil)
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
2019-11-26 01:48:29 -06:00
|
|
|
snapshotFlushStorageItemMeter.Mark(1)
|
|
|
|
snapshotFlushStorageSizeMeter.Mark(int64(len(data)))
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
|
|
|
if batch.ValueSize() > ethdb.IdealBatchSize {
|
|
|
|
if err := batch.Write(); err != nil {
|
|
|
|
log.Crit("Failed to write storage snapshot", "err", err)
|
|
|
|
}
|
|
|
|
batch.Reset()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Update the snapshot block marker and write any remainder data
|
2019-11-22 05:23:49 -06:00
|
|
|
rawdb.WriteSnapshotRoot(batch, bottom.root)
|
2019-10-17 10:30:31 -05:00
|
|
|
if err := batch.Write(); err != nil {
|
|
|
|
log.Crit("Failed to write leftover snapshot", "err", err)
|
|
|
|
}
|
2019-11-26 01:48:29 -06:00
|
|
|
res := &diskLayer{
|
|
|
|
root: bottom.root,
|
|
|
|
cache: base.cache,
|
|
|
|
diskdb: base.diskdb,
|
|
|
|
triedb: base.triedb,
|
|
|
|
genMarker: base.genMarker,
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
2019-11-26 01:48:29 -06:00
|
|
|
// If snapshot generation hasn't finished yet, port over all the starts and
|
|
|
|
// continue where the previous round left off.
|
|
|
|
//
|
|
|
|
// Note, the `base.genAbort` comparison is not used normally, it's checked
|
|
|
|
// to allow the tests to play with the marker without triggering this path.
|
|
|
|
if base.genMarker != nil && base.genAbort != nil {
|
|
|
|
res.genMarker = base.genMarker
|
|
|
|
res.genAbort = make(chan chan *generatorStats)
|
|
|
|
go res.generate(stats)
|
|
|
|
}
|
|
|
|
return res
|
2019-10-17 10:30:31 -05:00
|
|
|
}
|
|
|
|
|
2019-12-02 05:27:20 -06:00
|
|
|
// Journal commits an entire diff hierarchy to disk into a single journal entry.
|
2019-08-06 05:40:28 -05:00
|
|
|
// This is meant to be used during shutdown to persist the snapshot without
|
|
|
|
// flattening everything down (bad for reorgs).
|
2019-11-26 01:48:29 -06:00
|
|
|
//
|
|
|
|
// The method returns the root hash of the base layer that needs to be persisted
|
|
|
|
// to disk as a trie too to allow continuing any pending generation op.
|
2019-12-02 05:27:20 -06:00
|
|
|
func (t *Tree) Journal(root common.Hash) (common.Hash, error) {
|
2019-11-22 05:23:49 -06:00
|
|
|
// Retrieve the head snapshot to journal from var snap snapshot
|
2019-11-26 01:48:29 -06:00
|
|
|
snap := t.Snapshot(root)
|
2019-11-22 05:23:49 -06:00
|
|
|
if snap == nil {
|
2019-11-26 01:48:29 -06:00
|
|
|
return common.Hash{}, fmt.Errorf("snapshot [%#x] missing", root)
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
|
|
|
// Run the journaling
|
2019-11-22 05:23:49 -06:00
|
|
|
t.lock.Lock()
|
|
|
|
defer t.lock.Unlock()
|
2019-08-06 05:40:28 -05:00
|
|
|
|
2019-12-02 05:27:20 -06:00
|
|
|
journal := new(bytes.Buffer)
|
|
|
|
base, err := snap.(snapshot).Journal(journal)
|
2019-11-26 01:48:29 -06:00
|
|
|
if err != nil {
|
|
|
|
return common.Hash{}, err
|
|
|
|
}
|
2019-12-02 05:27:20 -06:00
|
|
|
// Store the journal into the database and return
|
|
|
|
rawdb.WriteSnapshotJournal(t.diskdb, journal.Bytes())
|
|
|
|
return base, nil
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
|
|
|
|
2019-11-26 01:48:29 -06:00
|
|
|
// Rebuild wipes all available snapshot data from the persistent database and
|
|
|
|
// discard all caches and diff layers. Afterwards, it starts a new snapshot
|
|
|
|
// generator with the given root hash.
|
|
|
|
func (t *Tree) Rebuild(root common.Hash) {
|
|
|
|
t.lock.Lock()
|
|
|
|
defer t.lock.Unlock()
|
|
|
|
|
|
|
|
// Track whether there's a wipe currently running and keep it alive if so
|
|
|
|
var wiper chan struct{}
|
|
|
|
|
|
|
|
// Iterate over and mark all layers stale
|
|
|
|
for _, layer := range t.layers {
|
|
|
|
switch layer := layer.(type) {
|
|
|
|
case *diskLayer:
|
|
|
|
// If the base layer is generating, abort it and save
|
|
|
|
if layer.genAbort != nil {
|
|
|
|
abort := make(chan *generatorStats)
|
|
|
|
layer.genAbort <- abort
|
|
|
|
|
|
|
|
if stats := <-abort; stats != nil {
|
|
|
|
wiper = stats.wiping
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Layer should be inactive now, mark it as stale
|
|
|
|
layer.lock.Lock()
|
|
|
|
layer.stale = true
|
|
|
|
layer.lock.Unlock()
|
|
|
|
|
|
|
|
case *diffLayer:
|
|
|
|
// If the layer is a simple diff, simply mark as stale
|
|
|
|
layer.lock.Lock()
|
|
|
|
layer.stale = true
|
|
|
|
layer.lock.Unlock()
|
|
|
|
|
|
|
|
default:
|
|
|
|
panic(fmt.Sprintf("unknown layer type: %T", layer))
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
|
|
|
}
|
2019-11-26 01:48:29 -06:00
|
|
|
// Start generating a new snapshot from scratch on a backgroung thread. The
|
|
|
|
// generator will run a wiper first if there's not one running right now.
|
|
|
|
log.Info("Rebuilding state snapshot")
|
|
|
|
t.layers = map[common.Hash]snapshot{
|
|
|
|
root: generateSnapshot(t.diskdb, t.triedb, t.cache, root, wiper),
|
2019-08-06 05:40:28 -05:00
|
|
|
}
|
|
|
|
}
|