core,trie: rework the witness stats

Author: rjl493456442

core/blockchain.go

@@ -112,13 +112,6 @@ var (
 	errChainStopped         = errors.New("blockchain is stopped")
 	errInvalidOldChain      = errors.New("invalid old chain")
 	errInvalidNewChain      = errors.New("invalid new chain")
-
-	accountAccessDepthAvg = metrics.NewRegisteredGauge("trie/access/account/avg", nil)
-	accountAccessDepthMin = metrics.NewRegisteredGauge("trie/access/account/min", nil)
-	accountAccessDepthMax = metrics.NewRegisteredGauge("trie/access/account/max", nil)
-	storageAccessDepthAvg = metrics.NewRegisteredGauge("trie/access/storage/avg", nil)
-	storageAccessDepthMin = metrics.NewRegisteredGauge("trie/access/storage/min", nil)
-	storageAccessDepthMax = metrics.NewRegisteredGauge("trie/access/storage/max", nil)
 )
 
 var (
@@ -2018,7 +2011,10 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 	// If we are past Byzantium, enable prefetching to pull in trie node paths
 	// while processing transactions. Before Byzantium the prefetcher is mostly
 	// useless due to the intermediate root hashing after each transaction.
-	var witness *stateless.Witness
+	var (
+		witness      *stateless.Witness
+		witnessStats *stateless.WitnessStats
+	)
 	if bc.chainConfig.IsByzantium(block.Number()) {
 		// Generate witnesses either if we're self-testing, or if it's the
 		// only block being inserted. A bit crude, but witnesses are huge,
@@ -2028,8 +2024,11 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 			if err != nil {
 				return nil, err
 			}
+			if bc.cfg.VmConfig.EnableWitnessStats {
+				witnessStats = stateless.NewWitnessStats()
+			}
 		}
-		statedb.StartPrefetcher("chain", witness)
+		statedb.StartPrefetcher("chain", witness, witnessStats)
 		defer statedb.StopPrefetcher()
 	}
 
@@ -2126,25 +2125,9 @@ func (bc *BlockChain) processBlock(parentRoot common.Hash, block *types.Block, s
 	if err != nil {
 		return nil, err
 	}
-
-	// If witness was generated, update metrics regarding the access paths.
-	if witness != nil {
-		a := witness.AccountDepthMetrics
-		if a.Count > 0 {
-			accountAccessDepthAvg.Update(int64(a.Sum) / int64(a.Count))
-			if a.Min != -1 {
-				accountAccessDepthMin.Update(int64(a.Min))
-			}
-			accountAccessDepthMax.Update(int64(a.Max))
-		}
-		s := witness.StateDepthMetrics
-		if s.Count > 0 {
-			storageAccessDepthAvg.Update(int64(s.Sum) / int64(s.Count))
-			if s.Min != -1 {
-				storageAccessDepthMin.Update(int64(s.Min))
-			}
-			storageAccessDepthMax.Update(int64(s.Max))
-		}
+	// Report the collected witness statistics
+	if witnessStats != nil {
+		witnessStats.ReportMetrics()
 	}
 
 	// Update the metrics touched during block commit

core/state/database.go

@@ -124,10 +124,6 @@ type Trie interface {
 	// The returned map could be nil if the witness is empty.
 	Witness() map[string][]byte
 
-	// Owner returns the owner of the trie, allowing us to distinguish between
-	// storage and account tries.
-	Owner() common.Hash
-
 	// NodeIterator returns an iterator that returns nodes of the trie. Iteration
 	// starts at the key after the given start key. And error will be returned
 	// if fails to create node iterator.

core/state/statedb.go

@@ -136,7 +136,8 @@ type StateDB struct {
 	journal *journal
 
 	// State witness if cross validation is needed
-	witness *stateless.Witness
+	witness      *stateless.Witness
+	witnessStats *stateless.WitnessStats
 
 	// Measurements gathered during execution for debugging purposes
 	AccountReads    time.Duration
@@ -191,12 +192,13 @@ func NewWithReader(root common.Hash, db Database, reader Reader) (*StateDB, erro
 // StartPrefetcher initializes a new trie prefetcher to pull in nodes from the
 // state trie concurrently while the state is mutated so that when we reach the
 // commit phase, most of the needed data is already hot.
-func (s *StateDB) StartPrefetcher(namespace string, witness *stateless.Witness) {
+func (s *StateDB) StartPrefetcher(namespace string, witness *stateless.Witness, witnessStats *stateless.WitnessStats) {
 	// Terminate any previously running prefetcher
 	s.StopPrefetcher()
 
 	// Enable witness collection if requested
 	s.witness = witness
+	s.witnessStats = witnessStats
 
 	// With the switch to the Proof-of-Stake consensus algorithm, block production
 	// rewards are now handled at the consensus layer. Consequently, a block may
@@ -841,7 +843,7 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 				// If witness building is enabled and the state object has a trie,
 				// gather the witnesses for its specific storage trie
 				if s.witness != nil && obj.trie != nil {
-					s.witness.AddState(obj.trie.Witness(), obj.trie.Owner())
+					s.witness.AddState(obj.trie.Witness())
 				}
 			}
 			return nil
@@ -858,9 +860,17 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 				continue
 			}
 			if trie := obj.getPrefetchedTrie(); trie != nil {
-				s.witness.AddState(trie.Witness(), trie.Owner())
+				witness := trie.Witness()
+				s.witness.AddState(witness)
+				if s.witnessStats != nil {
+					s.witnessStats.Add(witness, obj.addrHash)
+				}
 			} else if obj.trie != nil {
-				s.witness.AddState(obj.trie.Witness(), obj.trie.Owner())
+				witness := obj.trie.Witness()
+				s.witness.AddState(witness)
+				if s.witnessStats != nil {
+					s.witnessStats.Add(witness, obj.addrHash)
+				}
 			}
 		}
 		// Pull in only-read and non-destructed trie witnesses
@@ -874,9 +884,17 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 				continue
 			}
 			if trie := obj.getPrefetchedTrie(); trie != nil {
-				s.witness.AddState(trie.Witness(), trie.Owner())
+				witness := trie.Witness()
+				s.witness.AddState(witness)
+				if s.witnessStats != nil {
+					s.witnessStats.Add(witness, obj.addrHash)
+				}
 			} else if obj.trie != nil {
-				s.witness.AddState(obj.trie.Witness(), trie.Owner())
+				witness := trie.Witness()
+				s.witness.AddState(witness)
+				if s.witnessStats != nil {
+					s.witnessStats.Add(witness, obj.addrHash)
+				}
 			}
 		}
 	}
@@ -942,7 +960,11 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 
 	// If witness building is enabled, gather the account trie witness
 	if s.witness != nil {
-		s.witness.AddState(s.trie.Witness(), s.trie.Owner())
+		witness := s.trie.Witness()
+		s.witness.AddState(witness)
+		if s.witnessStats != nil {
+			s.witnessStats.Add(witness, common.Hash{})
+		}
 	}
 	return hash
 }
@@ -1295,17 +1317,6 @@ func (s *StateDB) commitAndFlush(block uint64, deleteEmptyObjects bool, noStorag
 	if err != nil {
 		return nil, err
 	}
-
-	// This iterates through nodeset and tracks path depths for tracking
-	// state and account trie modifications.
-	if s.witness != nil && ret != nil && !ret.empty() {
-		for owner, set := range ret.nodes.Sets {
-			for path := range set.Origins {
-				s.witness.AddStateModify(len(path), owner)
-			}
-		}
-	}
-
 	// Commit dirty contract code if any exists
 	if db := s.db.TrieDB().Disk(); db != nil && len(ret.codes) > 0 {
 		batch := db.NewBatch()

core/stateless/stats.go

@@ -0,0 +1,108 @@
+// Copyright 2025 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 stateless
+
+import (
+	"maps"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/metrics"
+)
+
+var (
+	accountTrieDepthAvg = metrics.NewRegisteredGauge("witness/trie/account/depth/avg", nil)
+	accountTrieDepthMin = metrics.NewRegisteredGauge("witness/trie/account/depth/min", nil)
+	accountTrieDepthMax = metrics.NewRegisteredGauge("witness/trie/account/depth/max", nil)
+
+	storageTrieDepthAvg = metrics.NewRegisteredGauge("witness/trie/storage/depth/avg", nil)
+	storageTrieDepthMin = metrics.NewRegisteredGauge("witness/trie/storage/depth/min", nil)
+	storageTrieDepthMax = metrics.NewRegisteredGauge("witness/trie/storage/depth/max", nil)
+)
+
+// depthStats tracks min/avg/max statistics for trie access depths.
+type depthStats struct {
+	totalDepth int64
+	samples    int64
+	minDepth   int64
+	maxDepth   int64
+}
+
+// newDepthStats creates a new depthStats with default values.
+func newDepthStats() *depthStats {
+	return &depthStats{minDepth: -1}
+}
+
+// Add records a new depth sample.
+func (d *depthStats) Add(n int64) {
+	if n < 0 {
+		return
+	}
+	d.totalDepth += n
+	d.samples++
+
+	if d.minDepth == -1 || n < d.minDepth {
+		d.minDepth = n
+	}
+	if n > d.maxDepth {
+		d.maxDepth = n
+	}
+}
+
+// report uploads the collected statistics into the provided gauges.
+func (d *depthStats) report(maxGauge, minGauge, avgGauge *metrics.Gauge) {
+	if d.samples == 0 {
+		return
+	}
+	maxGauge.Update(d.maxDepth)
+	minGauge.Update(d.minDepth)
+	avgGauge.Update(d.totalDepth / d.samples)
+}
+
+// WitnessStats aggregates statistics for account and storage trie accesses.
+type WitnessStats struct {
+	accountTrie *depthStats
+	storageTrie *depthStats
+}
+
+// NewWitnessStats creates a new WitnessStats collector.
+func NewWitnessStats() *WitnessStats {
+	return &WitnessStats{
+		accountTrie: newDepthStats(),
+		storageTrie: newDepthStats(),
+	}
+}
+
+// Add records trie access depths from the given node paths.
+// If `owner` is the zero hash, accesses are attributed to the account trie;
+// otherwise, they are attributed to the storage trie of that account.
+func (s *WitnessStats) Add(nodes map[string][]byte, owner common.Hash) {
+	if owner == (common.Hash{}) {
+		for path := range maps.Keys(nodes) {
+			s.accountTrie.Add(int64(len(path)))
+		}
+	} else {
+		for path := range maps.Keys(nodes) {
+			s.storageTrie.Add(int64(len(path)))
+		}
+	}
+}
+
+// ReportMetrics reports the collected statistics to the global metrics registry.
+func (s *WitnessStats) ReportMetrics() {
+	s.accountTrie.report(accountTrieDepthMax, accountTrieDepthMin, accountTrieDepthAvg)
+	s.storageTrie.report(storageTrieDepthMax, storageTrieDepthMin, storageTrieDepthAvg)
+}