Merge pull request #2705 from will-2012/perf-pbssbsc

perf: add db metrics

core/block_validator.go

@@ -25,6 +25,7 @@ import (
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie"
 )
@@ -40,6 +41,12 @@ func EnableRemoteVerifyManager(remoteValidator *remoteVerifyManager) BlockValida
 	}
 }
 
+var (
+	validateBloomTimer   = metrics.NewRegisteredTimer("validate/bloom/time", nil)
+	validateReceiptTimer = metrics.NewRegisteredTimer("validate/receipt/time", nil)
+	validateRootTimer    = metrics.NewRegisteredTimer("validate/root/time", nil)
+)
+
 // BlockValidator is responsible for validating block headers, uncles and
 // processed state.
 //
@@ -184,6 +191,10 @@ func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateD
 	// For valid blocks this should always validate to true.
 	validateFuns := []func() error{
 		func() error {
+			defer func(start time.Time) {
+				validateBloomTimer.UpdateSince(start)
+			}(time.Now())
+
 			rbloom := types.CreateBloom(receipts)
 			if rbloom != header.Bloom {
 				return fmt.Errorf("invalid bloom (remote: %x  local: %x)", header.Bloom, rbloom)
@@ -191,6 +202,9 @@ func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateD
 			return nil
 		},
 		func() error {
+			defer func(start time.Time) {
+				validateReceiptTimer.UpdateSince(start)
+			}(time.Now())
 			receiptSha := types.DeriveSha(receipts, trie.NewStackTrie(nil))
 			if receiptSha != header.ReceiptHash {
 				return fmt.Errorf("invalid receipt root hash (remote: %x local: %x)", header.ReceiptHash, receiptSha)
@@ -209,6 +223,9 @@ func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateD
 		})
 	} else {
 		validateFuns = append(validateFuns, func() error {
+			defer func(start time.Time) {
+				validateRootTimer.UpdateSince(start)
+			}(time.Now())
 			if root := statedb.IntermediateRoot(v.config.IsEIP158(header.Number)); header.Root != root {
 				return fmt.Errorf("invalid merkle root (remote: %x local: %x) dberr: %w", header.Root, root, statedb.Error())
 			}

core/blockchain.go

@@ -74,6 +74,7 @@ var (
 	blockInsertMgaspsGauge = metrics.NewRegisteredGauge("chain/insert/mgasps", nil)
 
 	chainInfoGauge = metrics.NewRegisteredGaugeInfo("chain/info", nil)
+	mGasPsGauge    = metrics.NewRegisteredGauge("chain/process/gas", nil)
 
 	accountReadTimer   = metrics.NewRegisteredTimer("chain/account/reads", nil)
 	accountHashTimer   = metrics.NewRegisteredTimer("chain/account/hashes", nil)
@@ -95,6 +96,9 @@ var (
 	blockValidationTimer      = metrics.NewRegisteredTimer("chain/validation", nil)
 	blockExecutionTimer       = metrics.NewRegisteredTimer("chain/execution", nil)
 	blockWriteTimer           = metrics.NewRegisteredTimer("chain/write", nil)
+	blockValidationTotalTimer = metrics.NewRegisteredTimer("chain/total/validation", nil)
+	blockExecutionTotalTimer  = metrics.NewRegisteredTimer("chain/total/execution", nil)
+	blockWriteTotalTimer      = metrics.NewRegisteredTimer("chain/total/write", nil)
 
 	blockReorgMeter     = metrics.NewRegisteredMeter("chain/reorg/executes", nil)
 	blockReorgAddMeter  = metrics.NewRegisteredMeter("chain/reorg/add", nil)
@@ -2268,6 +2272,8 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)
 			statedb.StopPrefetcher()
 			return it.index, err
 		}
+		blockExecutionTotalTimer.UpdateSince(pstart)
+
 		ptime := time.Since(pstart)
 
 		// Validate the state using the default validator
@@ -2278,6 +2284,8 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)
 			statedb.StopPrefetcher()
 			return it.index, err
 		}
+		blockValidationTotalTimer.UpdateSince(vstart)
+
 		vtime := time.Since(vstart)
 		proctime := time.Since(start) // processing + validation
 
@@ -2311,6 +2319,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)
 		if err != nil {
 			return it.index, err
 		}
+		blockWriteTotalTimer.UpdateSince(wstart)
 
 		bc.cacheReceipts(block.Hash(), receipts, block)
 

core/blockchain_insert.go

@@ -64,6 +64,7 @@ func (st *insertStats) report(chain []*types.Block, index int, snapDiffItems, sn
 			"blocks", st.processed, "txs", txs, "blobs", blobs, "mgas", float64(st.usedGas) / 1000000,
 			"elapsed", common.PrettyDuration(elapsed), "mgasps", mgasps,
 		}
+		mGasPsGauge.Update(int64(mgasps))
 		blockInsertMgaspsGauge.Update(int64(mgasps))
 		if timestamp := time.Unix(int64(end.Time()), 0); time.Since(timestamp) > time.Minute {
 			context = append(context, []interface{}{"age", common.PrettyAge(timestamp)}...)

core/state/metrics.go

@@ -34,4 +34,7 @@ var (
 	slotDeletionCount    = metrics.NewRegisteredMeter("state/delete/storage/slot", nil)
 	slotDeletionSize     = metrics.NewRegisteredMeter("state/delete/storage/size", nil)
 	slotDeletionSkip     = metrics.NewRegisteredGauge("state/delete/storage/skip", nil)
+
+	accountIntermediateRootTimer = metrics.NewRegisteredTimer("state/account/intermediate/root/time", nil)
+	storageIntermediateRootTimer = metrics.NewRegisteredTimer("state/storage/intermediate/root/time", nil)
 )

core/state/snapshot/difflayer.go

@@ -286,6 +286,13 @@ func (dl *diffLayer) Stale() bool {
 // Account directly retrieves the account associated with a particular hash in
 // the snapshot slim data format.
 func (dl *diffLayer) Account(hash common.Hash) (*types.SlimAccount, error) {
+	defer func(start time.Time) {
+		snapGetTimer.UpdateSince(start)
+		snapGetQPS.Mark(1)
+		snapGetAccountTimer.UpdateSince(start)
+		snapGetAccountQPS.Mark(1)
+	}(time.Now())
+
 	data, err := dl.AccountRLP(hash)
 	if err != nil {
 		return nil, err
@@ -394,6 +401,13 @@ func (dl *diffLayer) accountRLP(hash common.Hash, depth int) ([]byte, error) {
 //
 // Note the returned slot is not a copy, please don't modify it.
 func (dl *diffLayer) Storage(accountHash, storageHash common.Hash) ([]byte, error) {
+	defer func(start time.Time) {
+		snapGetTimer.UpdateSince(start)
+		snapGetQPS.Mark(1)
+		snapGetStorageTimer.UpdateSince(start)
+		snapGetStorageQPS.Mark(1)
+	}(time.Now())
+
 	// Check the bloom filter first whether there's even a point in reaching into
 	// all the maps in all the layers below
 	dl.lock.RLock()

core/state/snapshot/disklayer.go

@@ -19,6 +19,7 @@ package snapshot
 import (
 	"bytes"
 	"sync"
+	"time"
 
 	"github.com/VictoriaMetrics/fastcache"
 	"github.com/ethereum/go-ethereum/common"
@@ -136,7 +137,12 @@ func (dl *diskLayer) AccountRLP(hash common.Hash) ([]byte, error) {
 		return blob, nil
 	}
 	// Cache doesn't contain account, pull from disk and cache for later
+	// TODO:
+	snapNodeQPS.Mark(1)
+	startLoadSnapNode := time.Now()
 	blob := rawdb.ReadAccountSnapshot(dl.diskdb, hash)
+	snapNodeTime.Mark(time.Since(startLoadSnapNode).Nanoseconds())
+
 	dl.cache.Set(hash[:], blob)
 
 	snapshotCleanAccountMissMeter.Mark(1)
@@ -176,7 +182,11 @@ func (dl *diskLayer) Storage(accountHash, storageHash common.Hash) ([]byte, erro
 		return blob, nil
 	}
 	// Cache doesn't contain storage slot, pull from disk and cache for later
+	// TODO:
+	snapNodeQPS.Mark(1)
+	startLoadSnapNode := time.Now()
 	blob := rawdb.ReadStorageSnapshot(dl.diskdb, accountHash, storageHash)
+	snapNodeTime.Mark(time.Since(startLoadSnapNode).Nanoseconds())
 	dl.cache.Set(key, blob)
 
 	snapshotCleanStorageMissMeter.Mark(1)

core/state/snapshot/metrics.go

@@ -50,4 +50,15 @@ var (
 	snapStorageWriteCounter = metrics.NewRegisteredCounter("state/snapshot/generation/duration/storage/write", nil)
 	// snapStorageCleanCounter measures time spent on deleting storages
 	snapStorageCleanCounter = metrics.NewRegisteredCounter("state/snapshot/generation/duration/storage/clean", nil)
+
+	snapNodeQPS  = metrics.NewRegisteredMeter("pbss/snap/node/qps", nil)
+	snapNodeTime = metrics.NewRegisteredMeter("pbss/snap/node/time", nil)
+
+	snapGetTimer = metrics.NewRegisteredTimer("snap/get/time", nil)
+	snapGetQPS   = metrics.NewRegisteredMeter("snap/get/qps", nil)
+
+	snapGetAccountTimer = metrics.NewRegisteredTimer("snap/account/get/time", nil)
+	snapGetAccountQPS   = metrics.NewRegisteredMeter("snap/account/get/qps", nil)
+	snapGetStorageTimer = metrics.NewRegisteredTimer("snap/storage/get/time", nil)
+	snapGetStorageQPS   = metrics.NewRegisteredMeter("snap/storage/get/qps", nil)
 )

core/state/state_object.go

@@ -223,6 +223,14 @@ func (s *stateObject) GetCommittedState(key common.Hash) common.Hash {
 		return common.Hash{}
 	}
 	// If no live objects are available, attempt to use snapshots
+
+	defer func(start time.Time) {
+		stateDBGetTimer.UpdateSince(start)
+		stateDBGetQPS.Mark(1)
+		stateDBGetStorageTimer.UpdateSince(start)
+		stateDBGetStorageQPS.Mark(1)
+	}(time.Now())
+
 	var (
 		enc   []byte
 		err   error

core/state/statedb.go

@@ -54,6 +54,16 @@ type revision struct {
 	journalIndex int
 }
 
+var (
+	stateDBGetTimer = metrics.NewRegisteredTimer("statedb/get/time", nil)
+	stateDBGetQPS   = metrics.NewRegisteredMeter("statedb/get/qps", nil)
+
+	stateDBGetAccountTimer = metrics.NewRegisteredTimer("statedb/account/get/time", nil)
+	stateDBGetAccountQPS   = metrics.NewRegisteredMeter("statedb/account/get/qps", nil)
+	stateDBGetStorageTimer = metrics.NewRegisteredTimer("statedb/storage/get/time", nil)
+	stateDBGetStorageQPS   = metrics.NewRegisteredMeter("statedb/storage/get/qps", nil)
+)
+
 // StateDB structs within the ethereum protocol are used to store anything
 // within the merkle trie. StateDBs take care of caching and storing
 // nested states. It's the general query interface to retrieve:
@@ -166,7 +176,7 @@ func NewWithSharedPool(root common.Hash, db Database, snaps *snapshot.Tree) (*St
 	if err != nil {
 		return nil, err
 	}
-	statedb.storagePool = NewStoragePool()
+	//statedb.storagePool = NewStoragePool()
 	return statedb, nil
 }
 
@@ -716,6 +726,14 @@ func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
 	if obj := s.stateObjects[addr]; obj != nil {
 		return obj
 	}
+
+	defer func(start time.Time) {
+		stateDBGetTimer.UpdateSince(start)
+		stateDBGetQPS.Mark(1)
+		stateDBGetAccountTimer.UpdateSince(start)
+		stateDBGetAccountQPS.Mark(1)
+	}(time.Now())
+
 	// If no live objects are available, attempt to use snapshots
 	var data *types.StateAccount
 	if s.snap != nil {
@@ -1147,6 +1165,10 @@ func (s *StateDB) populateSnapStorage(obj *stateObject) bool {
 }
 
 func (s *StateDB) AccountsIntermediateRoot() {
+	defer func(start time.Time) {
+		storageIntermediateRootTimer.UpdateSince(start)
+	}(time.Now())
+
 	tasks := make(chan func())
 	finishCh := make(chan struct{})
 	defer close(finishCh)
@@ -1191,6 +1213,9 @@ func (s *StateDB) AccountsIntermediateRoot() {
 }
 
 func (s *StateDB) StateIntermediateRoot() common.Hash {
+	defer func(start time.Time) {
+		accountIntermediateRootTimer.UpdateSince(start)
+	}(time.Now())
 	// If there was a trie prefetcher operating, it gets aborted and irrevocably
 	// modified after we start retrieving tries. Remove it from the statedb after
 	// this round of use.

trie/secure_trie.go

@@ -17,13 +17,48 @@
 package trie
 
 import (
+	"time"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/trie/trienode"
 	"github.com/ethereum/go-ethereum/triedb/database"
 )
 
+var (
+	StateTreeOpenQPS  = metrics.NewRegisteredMeter("state/tree/open/qps", nil)
+	StateTreeOpenTime = metrics.NewRegisteredTimer("state/tree/open/time", nil)
+
+	StateTreeGetQPS         = metrics.NewRegisteredMeter("state/tree/get/qps", nil)
+	StateTreeGetTime        = metrics.NewRegisteredTimer("state/tree/get/time", nil)
+	StateAccountTreeGetQPS  = metrics.NewRegisteredMeter("state/tree/account/get/qps", nil)
+	StateAccountTreeGetTime = metrics.NewRegisteredTimer("state/tree/account/get/time", nil)
+	StateStorageTreeGetQPS  = metrics.NewRegisteredMeter("state/tree/storage/get/qps", nil)
+	StateStorageTreeGetTime = metrics.NewRegisteredTimer("state/tree/storage/get/time", nil)
+
+	StateTreePutQPS         = metrics.NewRegisteredMeter("state/tree/put/qps", nil)
+	StateTreePutTime        = metrics.NewRegisteredTimer("state/tree/put/time", nil)
+	StateAccountTreePutQPS  = metrics.NewRegisteredMeter("state/tree/account/put/qps", nil)
+	StateAccountTreePutTime = metrics.NewRegisteredTimer("state/tree/account/put/time", nil)
+	StateStorageTreePutQPS  = metrics.NewRegisteredMeter("state/tree/storage/put/qps", nil)
+	StateStorageTreePutTime = metrics.NewRegisteredTimer("state/tree/storage/put/time", nil)
+
+	StateTreeDelQPS         = metrics.NewRegisteredMeter("state/tree/del/qps", nil)
+	StateTreeDelTime        = metrics.NewRegisteredTimer("state/tree/del/time", nil)
+	StateAccountTreeDelQPS  = metrics.NewRegisteredMeter("state/tree/account/del/qps", nil)
+	StateAccountTreeDelTime = metrics.NewRegisteredTimer("state/tree/account/del/time", nil)
+	StateStorageTreeDelQPS  = metrics.NewRegisteredMeter("state/tree/storage/del/qps", nil)
+	StateStorageTreeDelTime = metrics.NewRegisteredTimer("state/tree/storage/del/time", nil)
+
+	StateTreeCommitQPS  = metrics.NewRegisteredMeter("state/tree/commit/qps", nil)
+	StateTreeCommitTime = metrics.NewRegisteredTimer("state/tree/commit/time", nil)
+
+	StateTreeCalcQPS  = metrics.NewRegisteredMeter("state/tree/calc/qps", nil)
+	StateTreeCalcTime = metrics.NewRegisteredTimer("state/tree/calc/time", nil)
+)
+
 // SecureTrie is the old name of StateTrie.
 // Deprecated: use StateTrie.
 type SecureTrie = StateTrie
@@ -63,6 +98,11 @@ type StateTrie struct {
 // trie is initially empty. Otherwise, New will panic if db is nil
 // and returns MissingNodeError if the root node cannot be found.
 func NewStateTrie(id *ID, db database.Database) (*StateTrie, error) {
+	defer func(start time.Time) {
+		StateTreeOpenQPS.Mark(1)
+		StateTreeOpenTime.UpdateSince(start)
+	}(time.Now())
+
 	if db == nil {
 		panic("trie.NewStateTrie called without a database")
 	}
@@ -87,6 +127,12 @@ func (t *StateTrie) MustGet(key []byte) []byte {
 // If the specified storage slot is not in the trie, nil will be returned.
 // If a trie node is not found in the database, a MissingNodeError is returned.
 func (t *StateTrie) GetStorage(_ common.Address, key []byte) ([]byte, error) {
+	defer func(start time.Time) {
+		StateTreeGetQPS.Mark(1)
+		StateTreeGetTime.UpdateSince(start)
+		StateStorageTreeGetQPS.Mark(1)
+		StateStorageTreeGetTime.UpdateSince(start)
+	}(time.Now())
 	enc, err := t.trie.Get(t.hashKey(key))
 	if err != nil || len(enc) == 0 {
 		return nil, err
@@ -99,6 +145,12 @@ func (t *StateTrie) GetStorage(_ common.Address, key []byte) ([]byte, error) {
 // If the specified account is not in the trie, nil will be returned.
 // If a trie node is not found in the database, a MissingNodeError is returned.
 func (t *StateTrie) GetAccount(address common.Address) (*types.StateAccount, error) {
+	defer func(start time.Time) {
+		StateTreeGetQPS.Mark(1)
+		StateTreeGetTime.UpdateSince(start)
+		StateAccountTreeGetQPS.Mark(1)
+		StateAccountTreeGetTime.UpdateSince(start)
+	}(time.Now())
 	res, err := t.trie.Get(t.hashKey(address.Bytes()))
 	if res == nil || err != nil {
 		return nil, err
@@ -153,6 +205,12 @@ func (t *StateTrie) MustUpdate(key, value []byte) {
 //
 // If a node is not found in the database, a MissingNodeError is returned.
 func (t *StateTrie) UpdateStorage(_ common.Address, key, value []byte) error {
+	defer func(start time.Time) {
+		StateTreePutQPS.Mark(1)
+		StateTreePutTime.UpdateSince(start)
+		StateStorageTreePutQPS.Mark(1)
+		StateStorageTreePutTime.UpdateSince(start)
+	}(time.Now())
 	hk := t.hashKey(key)
 	v, _ := rlp.EncodeToBytes(value)
 	err := t.trie.Update(hk, v)
@@ -165,6 +223,12 @@ func (t *StateTrie) UpdateStorage(_ common.Address, key, value []byte) error {
 
 // UpdateAccount will abstract the write of an account to the secure trie.
 func (t *StateTrie) UpdateAccount(address common.Address, acc *types.StateAccount) error {
+	defer func(start time.Time) {
+		StateTreePutQPS.Mark(1)
+		StateTreePutTime.UpdateSince(start)
+		StateAccountTreePutQPS.Mark(1)
+		StateAccountTreePutTime.UpdateSince(start)
+	}(time.Now())
 	hk := t.hashKey(address.Bytes())
 	data, err := rlp.EncodeToBytes(acc)
 	if err != nil {
@@ -193,6 +257,12 @@ func (t *StateTrie) MustDelete(key []byte) {
 // If the specified trie node is not in the trie, nothing will be changed.
 // If a node is not found in the database, a MissingNodeError is returned.
 func (t *StateTrie) DeleteStorage(_ common.Address, key []byte) error {
+	defer func(start time.Time) {
+		StateTreeDelQPS.Mark(1)
+		StateTreeDelTime.UpdateSince(start)
+		StateStorageTreeDelQPS.Mark(1)
+		StateStorageTreeDelTime.UpdateSince(start)
+	}(time.Now())
 	hk := t.hashKey(key)
 	delete(t.getSecKeyCache(), string(hk))
 	return t.trie.Delete(hk)
@@ -200,6 +270,12 @@ func (t *StateTrie) DeleteStorage(_ common.Address, key []byte) error {
 
 // DeleteAccount abstracts an account deletion from the trie.
 func (t *StateTrie) DeleteAccount(address common.Address) error {
+	defer func(start time.Time) {
+		StateTreeDelQPS.Mark(1)
+		StateTreeDelTime.UpdateSince(start)
+		StateAccountTreeDelQPS.Mark(1)
+		StateAccountTreeDelTime.UpdateSince(start)
+	}(time.Now())
 	hk := t.hashKey(address.Bytes())
 	delete(t.getSecKeyCache(), string(hk))
 	return t.trie.Delete(hk)
@@ -222,6 +298,10 @@ func (t *StateTrie) GetKey(shaKey []byte) []byte {
 // Once the trie is committed, it's not usable anymore. A new trie must
 // be created with new root and updated trie database for following usage
 func (t *StateTrie) Commit(collectLeaf bool) (common.Hash, *trienode.NodeSet, error) {
+	defer func(start time.Time) {
+		StateTreeCommitQPS.Mark(1)
+		StateTreeCommitTime.UpdateSince(start)
+	}(time.Now())
 	// Write all the pre-images to the actual disk database
 	if len(t.getSecKeyCache()) > 0 {
 		preimages := make(map[common.Hash][]byte)
@@ -238,6 +318,10 @@ func (t *StateTrie) Commit(collectLeaf bool) (common.Hash, *trienode.NodeSet, er
 // Hash returns the root hash of StateTrie. It does not write to the
 // database and can be used even if the trie doesn't have one.
 func (t *StateTrie) Hash() common.Hash {
+	defer func(start time.Time) {
+		StateTreeCalcQPS.Mark(1)
+		StateTreeCalcTime.UpdateSince(start)
+	}(time.Now())
 	return t.trie.Hash()
 }
 

triedb/pathdb/database.go

@@ -246,6 +246,10 @@ func (db *Database) Reader(root common.Hash) (layer, error) {
 // The passed in maps(nodes, states) will be retained to avoid copying everything.
 // Therefore, these maps must not be changed afterwards.
 func (db *Database) Update(root common.Hash, parentRoot common.Hash, block uint64, nodes *trienode.MergedNodeSet, states *triestate.Set) error {
+	defer func(start time.Time) {
+		PbssUpdateDiffQPS.Mark(1)
+		PbssUpdateDiffTime.UpdateSince(start)
+	}(time.Now())
 	// Hold the lock to prevent concurrent mutations.
 	db.lock.Lock()
 	defer db.lock.Unlock()

triedb/pathdb/disklayer.go

@@ -20,6 +20,7 @@ import (
 	"errors"
 	"fmt"
 	"sync"
+	"time"
 
 	"github.com/VictoriaMetrics/fastcache"
 	"github.com/ethereum/go-ethereum/common"
@@ -197,11 +198,15 @@ func (dl *diskLayer) Node(owner common.Hash, path []byte, hash common.Hash) ([]b
 		nBlob []byte
 		nHash common.Hash
 	)
+	// TODO:
+	trieNodeQPS.Mark(1)
+	startLoadTrieNode := time.Now()
 	if owner == (common.Hash{}) {
 		nBlob, nHash = rawdb.ReadAccountTrieNode(dl.db.diskdb, path)
 	} else {
 		nBlob, nHash = rawdb.ReadStorageTrieNode(dl.db.diskdb, owner, path)
 	}
+	trieNodeTime.Mark(time.Since(startLoadTrieNode).Nanoseconds())
 	if nHash != hash {
 		diskFalseMeter.Mark(1)
 		log.Error("Unexpected trie node in disk", "owner", owner, "path", path, "expect", hash, "got", nHash)

triedb/pathdb/metrics.go

@@ -53,4 +53,10 @@ var (
 	diffHashCacheMissMeter     = metrics.NewRegisteredMeter("pathdb/difflayer/hashcache/miss", nil)
 	diffHashCacheSlowPathMeter = metrics.NewRegisteredMeter("pathdb/difflayer/hashcache/slowpath", nil)
 	diffHashCacheLengthGauge   = metrics.NewRegisteredGauge("pathdb/difflayer/hashcache/size", nil)
+
+	PbssUpdateDiffQPS  = metrics.NewRegisteredMeter("pbss/difflayer/update/qps", nil)
+	PbssUpdateDiffTime = metrics.NewRegisteredTimer("pbss/difflayer/update/time", nil)
+
+	trieNodeQPS  = metrics.NewRegisteredMeter("pbss/trie/node/qps", nil)
+	trieNodeTime = metrics.NewRegisteredMeter("pbss/trie/node/time", nil)
 )