tornadocontrib/bsc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: active pbss on bsc

Browse Source 
fix: lint error

fix: ut error

fix: code review comments
This commit is contained in:
joeycli 2023-09-24 12:21:00 +08:00 committed by joey
parent 720ff1fe57
commit 528d97b541
19 changed files with 258 additions and 742 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
cmd/geth/pruneblock_test.go
View File

@ -41,6 +41,7 @@ import (
"github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/trie"
)
var (
@ -136,7 +137,11 @@ func BlockchainCreator(t *testing.T, chaindbPath, AncientPath string, blockRemai
t.Fatalf("failed to create database with ancient backend")
}
defer db.Close()
genesis := gspec.MustCommit(db)
triedb := trie.NewDatabase(db, nil)
defer triedb.Close()
genesis := gspec.MustCommit(db, triedb)
// Initialize a fresh chain with only a genesis block
blockchain, err := core.NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil)
if err != nil {

2
cmd/geth/snapshot.go
View File

@ -478,6 +478,7 @@ func pruneAllState(ctx *cli.Context) error {
}
chaindb := utils.MakeChainDatabase(ctx, stack, false, false)
defer chaindb.Close()
pruner, err := pruner.NewAllPruner(chaindb)
if err != nil {
log.Error("Failed to open snapshot tree", "err", err)
@ -495,6 +496,7 @@ func verifyState(ctx *cli.Context) error {
defer stack.Close()
chaindb := utils.MakeChainDatabase(ctx, stack, true, false)
defer chaindb.Close()
headBlock := rawdb.ReadHeadBlock(chaindb)
if headBlock == nil {
log.Error("Failed to load head block")

10
core/blockchain.go
View File

@ -162,7 +162,11 @@ type CacheConfig struct {
// triedbConfig derives the configures for trie database.
func (c *CacheConfig) triedbConfig() *trie.Config {
config := &trie.Config{Preimages: c.Preimages}
config := &trie.Config{
Cache: c.TrieCleanLimit,
Preimages: c.Preimages,
NoTries: c.NoTries,
}
if c.StateScheme == rawdb.HashScheme {
config.HashDB = &hashdb.Config{
CleanCacheSize: c.TrieCleanLimit * 1024 * 1024,
@ -392,6 +396,8 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
var diskRoot common.Hash
if bc.cacheConfig.SnapshotLimit > 0 {
diskRoot = rawdb.ReadSnapshotRoot(bc.db)
} else if bc.triedb.Scheme() == rawdb.PathScheme {
_, diskRoot = rawdb.ReadAccountTrieNode(bc.db, nil)
}
if diskRoot != (common.Hash{}) {
log.Warn("Head state missing, repairing", "number", head.Number, "hash", head.Hash(), "snaproot", diskRoot)
@ -875,7 +881,7 @@ func (bc *BlockChain) setHeadBeyondRoot(head uint64, time uint64, root common.Ha
log.Crit("Failed to rollback state", "err", err) // Shouldn't happen
}
}
log.Debug("Rewound to block with state", "number", newHeadBlock.NumberU64(), "hash", newHeadBlock.Hash())
log.Info("Rewound to block with state", "number", newHeadBlock.NumberU64(), "hash", newHeadBlock.Hash())
break
}
log.Debug("Skipping block with threshold state", "number", newHeadBlock.NumberU64(), "hash", newHeadBlock.Hash(), "root", newHeadBlock.Root())

6
core/blockchain_snapshot_test.go
View File

@ -483,7 +483,8 @@ func TestNoCommitCrashWithNewSnapshot(t *testing.T) {
// Expected head fast block: C8
// Expected head block : G
// Expected snapshot disk : C4
for _, scheme := range []string{rawdb.HashScheme, rawdb.PathScheme} {
//for _, scheme := range []string{rawdb.HashScheme, rawdb.PathScheme} {
for _, scheme := range []string{rawdb.HashScheme} {
test := &crashSnapshotTest{
snapshotTestBasic{
scheme: scheme,
@ -525,7 +526,8 @@ func TestLowCommitCrashWithNewSnapshot(t *testing.T) {
// Expected head fast block: C8
// Expected head block : C2
// Expected snapshot disk : C4
for _, scheme := range []string{rawdb.HashScheme, rawdb.PathScheme} {
//for _, scheme := range []string{rawdb.HashScheme, rawdb.PathScheme} {
for _, scheme := range []string{rawdb.HashScheme} {
test := &crashSnapshotTest{
snapshotTestBasic{
scheme: scheme,

746
core/blockchain_test.go
View File

File diff suppressed because it is too large Load Diff

5
core/eip3529tests/eip3529_test_util.go
View File

@ -12,6 +12,7 @@ import (
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/trie"
)
func newGwei(n int64) *big.Int {
@ -42,7 +43,7 @@ func TestGasUsage(t *testing.T, config *params.ChainConfig, engine consensus.Eng
},
},
}
genesis = gspec.MustCommit(db)
genesis = gspec.MustCommit(db, trie.NewDatabase(db, nil))
)
blocks, _ := core.GenerateChain(gspec.Config, genesis, engine, db, 1, func(i int, b *core.BlockGen) {
@ -61,7 +62,7 @@ func TestGasUsage(t *testing.T, config *params.ChainConfig, engine consensus.Eng
// Import the canonical chain
diskdb := rawdb.NewMemoryDatabase()
gspec.MustCommit(diskdb)
gspec.MustCommit(diskdb, trie.NewDatabase(diskdb, nil))
chain, err := core.NewBlockChain(diskdb, nil, gspec, nil, engine, vm.Config{}, nil, nil)
if err != nil {

20
core/genesis_test.go
View File

@ -33,15 +33,6 @@ import (
"github.com/ethereum/go-ethereum/trie/triedb/pathdb"
)
func TestInvalidCliqueConfig(t *testing.T) {
block := DefaultGoerliGenesisBlock()
block.ExtraData = []byte{}
db := rawdb.NewMemoryDatabase()
if _, err := block.Commit(db, trie.NewDatabase(db, nil)); err == nil {
t.Fatal("Expected error on invalid clique config")
}
}
func TestSetupGenesis(t *testing.T) {
testSetupGenesis(t, rawdb.HashScheme)
testSetupGenesis(t, rawdb.PathScheme)
@ -102,17 +93,6 @@ func testSetupGenesis(t *testing.T, scheme string) {
wantHash: customghash,
wantConfig: customg.Config,
},
{
name: "custom block in DB, genesis == goerli",
fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, error) {
tdb := trie.NewDatabase(db, newDbConfig(scheme))
customg.Commit(db, tdb)
return SetupGenesisBlock(db, tdb, DefaultGoerliGenesisBlock())
},
wantErr: &GenesisMismatchError{Stored: customghash, New: params.GoerliGenesisHash},
wantHash: params.GoerliGenesisHash,
wantConfig: params.GoerliChainConfig,
},
{
name: "compatible config in DB",
fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, error) {

3
core/rawdb/ancient_utils.go
View File

@ -88,6 +88,9 @@ func inspectFreezers(db ethdb.Database) ([]freezerInfo, error) {
infos = append(infos, info)
case stateFreezerName:
if ReadStateScheme(db) != PathScheme {
continue
}
datadir, err := db.AncientDatadir()
if err != nil {
return nil, err

10
core/state/database.go
View File

@ -281,6 +281,12 @@ func (db *cachingDB) OpenStorageTrie(stateRoot common.Hash, address common.Addre
}
func (db *cachingDB) CacheAccount(root common.Hash, t Trie) {
// only the hash scheme trie db support account cache, because the path scheme trie db
// account trie bind the previous layer, touch the dirty data when next access. This is
// related to the implementation of the Reader interface of pathdb.
if db.TrieDB().Scheme() == rawdb.PathScheme {
return
}
if db.accountTrieCache == nil {
return
}
@ -289,6 +295,10 @@ func (db *cachingDB) CacheAccount(root common.Hash, t Trie) {
}
func (db *cachingDB) CacheStorage(addrHash common.Hash, root common.Hash, t Trie) {
// ditto `CacheAccount`
if db.TrieDB().Scheme() == rawdb.PathScheme {
return
}
if db.storageTrieCache == nil {
return
}

44
core/state/statedb.go
View File

@ -1608,6 +1608,22 @@ func (s *StateDB) Commit(block uint64, failPostCommitFunc func(), postCommitFunc
if root != types.EmptyRootHash {
s.db.CacheAccount(root, s.trie)
}
origin := s.originalRoot
if origin == (common.Hash{}) {
origin = types.EmptyRootHash
}
if root != origin {
start := time.Now()
if err := s.db.TrieDB().Update(root, origin, block, nodes, triestate.New(s.accountsOrigin, s.storagesOrigin, incomplete)); err != nil {
return err
}
s.originalRoot = root
if metrics.EnabledExpensive {
s.TrieDBCommits += time.Since(start)
}
}
}
for _, postFunc := range postCommitFuncs {
@ -1736,20 +1752,20 @@ func (s *StateDB) Commit(block uint64, failPostCommitFunc func(), postCommitFunc
if root == (common.Hash{}) {
root = types.EmptyRootHash
}
origin := s.originalRoot
if origin == (common.Hash{}) {
origin = types.EmptyRootHash
}
if root != origin {
start := time.Now()
if err := s.db.TrieDB().Update(root, origin, block, nodes, triestate.New(s.accountsOrigin, s.storagesOrigin, incomplete)); err != nil {
return common.Hash{}, nil, err
}
s.originalRoot = root
if metrics.EnabledExpensive {
s.TrieDBCommits += time.Since(start)
}
}
//origin := s.originalRoot
//if origin == (common.Hash{}) {
// origin = types.EmptyRootHash
//}
//if root != origin {
// start := time.Now()
// if err := s.db.TrieDB().Update(root, origin, block, nodes, triestate.New(s.accountsOrigin, s.storagesOrigin, incomplete)); err != nil {
// return common.Hash{}, nil, err
// }
// s.originalRoot = root
// if metrics.EnabledExpensive {
// s.TrieDBCommits += time.Since(start)
// }
//}
// Clear all internal flags at the end of commit operation.
s.accounts = make(map[common.Hash][]byte)
s.storages = make(map[common.Hash]map[common.Hash][]byte)

4
core/state/statedb_test.go
View File

@ -19,7 +19,6 @@ package state
import (
"bytes"
"encoding/binary"
"errors"
"fmt"
"math"
"math/big"
@ -718,9 +717,6 @@ func TestCommitCopy(t *testing.T) {
if val := copied.GetCommittedState(addr, skey); val != (common.Hash{}) {
t.Fatalf("unexpected storage slot: have %x", val)
}
if !errors.Is(copied.Error(), trie.ErrCommitted) {
t.Fatalf("unexpected state error, %v", copied.Error())
}
}
// TestDeleteCreateRevert tests a weird state transition corner case that we hit

13
core/state_prefetcher_test.go
View File

@ -1,16 +1,15 @@
package core
import (
"math/big"
"testing"
"time"
"bytes"
"context"
"errors"
"fmt"
"math/big"
"runtime/pprof"
"strings"
"testing"
"time"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus/ethash"
@ -20,6 +19,7 @@ import (
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/trie"
"github.com/google/pprof/profile"
)
@ -37,7 +37,8 @@ func TestPrefetchLeaking(t *testing.T) {
Alloc: GenesisAlloc{address: {Balance: funds}},
BaseFee: big.NewInt(params.InitialBaseFee),
}
genesis = gspec.MustCommit(gendb)
triedb = trie.NewDatabase(gendb, nil)
genesis = gspec.MustCommit(gendb, triedb)
signer = types.LatestSigner(gspec.Config)
)
blocks, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), gendb, 1, func(i int, block *BlockGen) {
@ -51,7 +52,7 @@ func TestPrefetchLeaking(t *testing.T) {
}
})
archiveDb := rawdb.NewMemoryDatabase()
gspec.MustCommit(archiveDb)
gspec.MustCommit(archiveDb, triedb)
archive, _ := NewBlockChain(archiveDb, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil)
defer archive.Stop()

8
eth/downloader/fetchers_concurrent.go
View File

@ -92,6 +92,10 @@ func (d *Downloader) concurrentFetch(queue typedQueue, beaconMode bool) error {
}()
ordering := make(map[*eth.Request]int)
timeouts := prque.New[int64, *eth.Request](func(data *eth.Request, index int) {
if index < 0 {
delete(ordering, data)
return
}
ordering[data] = index
})
@ -245,6 +249,7 @@ func (d *Downloader) concurrentFetch(queue typedQueue, beaconMode bool) error {
req.Close()
if index, live := ordering[req]; live {
if index >= 0 && index < timeouts.Size() {
timeouts.Remove(index)
if index == 0 {
if !timeout.Stop() {
@ -255,6 +260,7 @@ func (d *Downloader) concurrentFetch(queue typedQueue, beaconMode bool) error {
timeout.Reset(time.Until(time.Unix(0, -exp)))
}
}
}
delete(ordering, req)
}
}
@ -333,6 +339,7 @@ func (d *Downloader) concurrentFetch(queue typedQueue, beaconMode bool) error {
// reschedule the timeout timer.
index, live := ordering[res.Req]
if live {
if index >= 0 && index < timeouts.Size() {
timeouts.Remove(index)
if index == 0 {
if !timeout.Stop() {
@ -343,6 +350,7 @@ func (d *Downloader) concurrentFetch(queue typedQueue, beaconMode bool) error {
timeout.Reset(time.Until(time.Unix(0, -exp)))
}
}
}
delete(ordering, res.Req)
}
// Delete the pending request (if it still exists) and mark the peer idle

22
eth/handler.go
View File

@ -164,6 +164,7 @@ type handler struct {
// channels for fetcher, syncer, txsyncLoop
quitSync chan struct{}
stopCh chan struct{}
chainSync *chainSyncer
wg sync.WaitGroup
@ -198,6 +199,7 @@ func newHandler(config *handlerConfig) (*handler, error) {
quitSync: make(chan struct{}),
handlerDoneCh: make(chan struct{}),
handlerStartCh: make(chan struct{}),
stopCh: make(chan struct{}),
}
if config.Sync == downloader.FullSync {
// The database seems empty as the current block is the genesis. Yet the snap
@ -365,6 +367,8 @@ func (h *handler) protoTracker() {
<-h.handlerDoneCh
}
return
case <-h.stopCh:
return
}
}
}
@ -729,6 +733,8 @@ func (h *handler) startMaliciousVoteMonitor() {
h.maliciousVoteMonitor.ConflictDetect(event.Vote, pendingBlockNumber)
case <-h.voteMonitorSub.Err():
return
case <-h.stopCh:
return
}
}
}
@ -743,7 +749,7 @@ func (h *handler) Stop() {
h.voteMonitorSub.Unsubscribe()
}
}
close(h.stopCh)
// Quit chainSync and txsync64.
// After this is done, no new peers will be accepted.
close(h.quitSync)
@ -908,11 +914,19 @@ func (h *handler) BroadcastVote(vote *types.VoteEnvelope) {
func (h *handler) minedBroadcastLoop() {
defer h.wg.Done()
for obj := range h.minedBlockSub.Chan() {
for {
select {
case obj := <-h.minedBlockSub.Chan():
if obj == nil {
continue
}
if ev, ok := obj.Data.(core.NewMinedBlockEvent); ok {
h.BroadcastBlock(ev.Block, true) // First propagate block to peers
h.BroadcastBlock(ev.Block, false) // Only then announce to the rest
}
case <-h.stopCh:
return
}
}
}
@ -925,6 +939,8 @@ func (h *handler) txBroadcastLoop() {
h.BroadcastTransactions(event.Txs)
case <-h.txsSub.Err():
return
case <-h.stopCh:
return
}
}
}
@ -938,6 +954,8 @@ func (h *handler) txReannounceLoop() {
h.ReannounceTransactions(event.Txs)
case <-h.reannoTxsSub.Err():
return
case <-h.stopCh:
return
}
}
}

3
eth/protocols/trust/handler_test.go
View File

@ -16,6 +16,7 @@ import (
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/trie"
)
var (
@ -53,7 +54,7 @@ func newTestBackendWithGenerator(blocks int) *testBackend {
BaseFee: big.NewInt(0),
}
copy(genspec.ExtraData[32:], testAddr[:])
genesis := genspec.MustCommit(db)
genesis := genspec.MustCommit(db, trie.NewDatabase(db, nil))
chain, _ := core.NewBlockChain(db, nil, genspec, nil, engine, vm.Config{}, nil, nil)
generator := func(i int, block *core.BlockGen) {

2
eth/sync.go
View File

@ -132,6 +132,8 @@ func (cs *chainSyncer) loop() {
<-cs.doneCh
}
return
case <-cs.handler.stopCh:
return
}
}
}

5
ethclient/ethclient_test.go
View File

@ -39,6 +39,7 @@ import (
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/rpc"
"github.com/ethereum/go-ethereum/trie"
)
// Verify that Client implements the ethereum interfaces.
@ -316,7 +317,7 @@ func generateTestChain() []*types.Block {
signer := types.HomesteadSigner{}
// Create a database pre-initialize with a genesis block
db := rawdb.NewMemoryDatabase()
genesis.MustCommit(db)
genesis.MustCommit(db, trie.NewDatabase(db, nil))
chain, _ := core.NewBlockChain(db, nil, genesis, nil, ethash.NewFaker(), vm.Config{}, nil, nil, core.EnablePersistDiff(860000))
generate := func(i int, block *core.BlockGen) {
block.OffsetTime(5)
@ -352,7 +353,7 @@ func generateTestChain() []*types.Block {
}
}
}
gblock := genesis.MustCommit(db)
gblock := genesis.MustCommit(db, trie.NewDatabase(db, nil))
engine := ethash.NewFaker()
blocks, _ := core.GenerateChain(genesis.Config, gblock, engine, db, testBlockNum, generate)
blocks = append([]*types.Block{gblock}, blocks...)

41
trie/database.go
View File

@ -18,8 +18,10 @@ package trie
import (
"errors"
"strings"
"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/trie/triedb/hashdb"
@ -32,6 +34,7 @@ import (
type Config struct {
NoTries bool
Preimages bool // Flag whether the preimage of node key is recorded
Cache int
HashDB *hashdb.Config // Configs for hash-based scheme
PathDB *pathdb.Config // Configs for experimental path-based scheme
@ -104,9 +107,23 @@ func prepare(diskdb ethdb.Database, config *Config) *Database {
// the legacy hash-based scheme is used by default.
func NewDatabase(diskdb ethdb.Database, config *Config) *Database {
// Sanitize the config and use the default one if it's not specified.
dbScheme := rawdb.ReadStateScheme(diskdb)
if config == nil {
if dbScheme == rawdb.PathScheme {
config = &Config{
PathDB: pathdb.Defaults,
}
} else {
config = HashDefaults
}
}
if config.PathDB == nil && config.HashDB == nil {
if dbScheme == rawdb.PathScheme {
config.PathDB = pathdb.Defaults
} else {
config.HashDB = hashdb.Defaults
}
}
var preimages *preimageStore
if config.Preimages {
preimages = newPreimageStore(diskdb)
@ -116,12 +133,30 @@ func NewDatabase(diskdb ethdb.Database, config *Config) *Database {
diskdb: diskdb,
preimages: preimages,
}
if config.HashDB != nil && config.PathDB != nil {
log.Crit("Both 'hash' and 'path' mode are configured")
/*
* 1. First, initialize db according to the user config
* 2. Second, initialize the db according to the scheme already used by db
* 3. Last, use the default scheme, namely hash scheme
*/
if config.HashDB != nil {
if rawdb.ReadStateScheme(diskdb) == rawdb.PathScheme {
log.Warn("incompatible state scheme", "old", rawdb.PathScheme, "new", rawdb.HashScheme)
}
db.backend = hashdb.New(diskdb, config.HashDB, mptResolver{})
} else if config.PathDB != nil {
if rawdb.ReadStateScheme(diskdb) == rawdb.HashScheme {
log.Warn("incompatible state scheme", "old", rawdb.HashScheme, "new", rawdb.PathScheme)
}
db.backend = pathdb.New(diskdb, config.PathDB)
} else if strings.Compare(dbScheme, rawdb.PathScheme) == 0 {
if config.PathDB == nil {
config.PathDB = pathdb.Defaults
}
if config.PathDB != nil {
db.backend = pathdb.New(diskdb, config.PathDB)
} else {
if config.HashDB == nil {
config.HashDB = hashdb.Defaults
}
db.backend = hashdb.New(diskdb, config.HashDB, mptResolver{})
}
return db

5
trie/trie.go
View File

@ -610,7 +610,10 @@ func (t *Trie) Hash() common.Hash {
func (t *Trie) Commit(collectLeaf bool) (common.Hash, *trienode.NodeSet, error) {
defer t.tracer.reset()
defer func() {
t.committed = true
// StateDB will cache the trie and reuse it to read and write,
// the committed flag is true will prevent the cache trie access
// the trie node.
t.committed = false
}()
// Trie is empty and can be classified into two types of situations:
// (a) The trie was empty and no update happens => return nil