From c116e5f2f65c533215475a3568245de38aeda762 Mon Sep 17 00:00:00 2001 From: flywukong <2229306838@qq.com> Date: Tue, 1 Mar 2022 15:19:59 +0800 Subject: [PATCH 1/3] add metrics of I/O cost functions --- core/state/statedb.go | 73 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 66 insertions(+), 7 deletions(-) diff --git a/core/state/statedb.go b/core/state/statedb.go index 1aecdbe59e..d69b0d7258 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -61,6 +61,11 @@ var ( l1StorageMeter = metrics.NewRegisteredMeter("state/cache/storage/total", nil) minerL1StorageMeter = metrics.NewRegisteredMeter("state/minercache/storage/total", nil) + getStatetSyncIOCost = metrics.NewRegisteredTimer("state/getcache/sync/delay", nil) + getStatetMinerIOCost = metrics.NewRegisteredTimer("state/getcache/miner/delay", nil) + getStatetSyncIOCounter = metrics.NewRegisteredCounter("state/getcache/sync/counter", nil) + getStatetMinerIOCounter = metrics.NewRegisteredCounter("state/getcache/miner/counter", nil) + totalSyncIOCost = metrics.NewRegisteredTimer("state/cache/sync/delay", nil) totalMinerIOCost = metrics.NewRegisteredTimer("state/cache/miner/delay", nil) totalSyncIOCounter = metrics.NewRegisteredCounter("state/cache/sync/counter", nil) @@ -348,6 +353,8 @@ func (s *StateDB) Empty(addr common.Address) bool { // GetBalance retrieves the balance from the given address or 0 if object not found func (s *StateDB) GetBalance(addr common.Address) *big.Int { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.getStateObject(addr) if stateObject != nil { return stateObject.Balance() @@ -356,11 +363,12 @@ func (s *StateDB) GetBalance(addr common.Address) *big.Int { } func (s *StateDB) GetNonce(addr common.Address) uint64 { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.getStateObject(addr) if stateObject != nil { return stateObject.Nonce() } - return 0 } @@ -375,6 +383,8 @@ func (s *StateDB) BlockHash() common.Hash { } func (s *StateDB) GetCode(addr common.Address) []byte { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.getStateObject(addr) if stateObject != nil { return stateObject.Code(s.db) @@ -383,6 +393,8 @@ func (s *StateDB) GetCode(addr common.Address) []byte { } func (s *StateDB) GetCodeSize(addr common.Address) int { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.getStateObject(addr) if stateObject != nil { return stateObject.CodeSize(s.db) @@ -391,6 +403,8 @@ func (s *StateDB) GetCodeSize(addr common.Address) int { } func (s *StateDB) GetCodeHash(addr common.Address) common.Hash { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.getStateObject(addr) if stateObject == nil { return common.Hash{} @@ -398,35 +412,60 @@ func (s *StateDB) GetCodeHash(addr common.Address) common.Hash { return common.BytesToHash(stateObject.CodeHash()) } +func (s *StateDB) markMetrics(start time.Time, reachStorage bool) { + goid := cachemetrics.Goid() + isSyncMainProcess := cachemetrics.IsSyncMainRoutineID(goid) + isMinerMainProcess := cachemetrics.IsMinerMainRoutineID(goid) + // record metrics of syncing main process + if isSyncMainProcess { + totalSyncIOCounter.Inc(time.Since(start).Nanoseconds()) + l1AccountMeter.Mark(1) + if reachStorage { + l1StorageMeter.Mark(1) + } + } + // record metrics of mining main process + if isMinerMainProcess { + totalMinerIOCounter.Inc(time.Since(start).Nanoseconds()) + minerL1AccountMeter.Mark(1) + if reachStorage { + l1StorageMeter.Mark(1) + } + } + +} + // GetState retrieves a value from the given account's storage trie. func (s *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash { start := time.Now() goid := cachemetrics.Goid() - isSyncMainProcess := cachemetrics.IsSyncMainRoutineID(goid) isMinerMainProcess := cachemetrics.IsMinerMainRoutineID(goid) defer func() { // record metrics of syncing main process if isSyncMainProcess { syncGetDelay := time.Since(start) - totalSyncIOCost.Update(syncGetDelay) - totalSyncIOCounter.Inc(syncGetDelay.Nanoseconds()) + totalSyncIOCounter.Inc(time.Since(start).Nanoseconds()) + getStatetSyncIOCost.Update(syncGetDelay) + getStatetSyncIOCounter.Inc(syncGetDelay.Nanoseconds()) l1AccountMeter.Mark(1) } // record metrics of mining main process if isMinerMainProcess { minerIOCost := time.Since(start) - totalMinerIOCost.Update(minerIOCost) - totalMinerIOCounter.Inc(minerIOCost.Nanoseconds()) + totalMinerIOCounter.Inc(time.Since(start).Nanoseconds()) + getStatetMinerIOCost.Update(minerIOCost) + getStatetMinerIOCounter.Inc(minerIOCost.Nanoseconds()) minerL1AccountMeter.Mark(1) } }() + stateObject := s.getStateObject(addr) if stateObject != nil { if isSyncMainProcess { l1StorageMeter.Mark(1) } - if isMinerMainProcess { + if isSyncMainProcess { minerL1StorageMeter.Mark(1) } return stateObject.GetState(s.db, hash) @@ -473,9 +512,13 @@ func (s *StateDB) GetStorageProofByHash(a common.Address, key common.Hash) ([][] // GetCommittedState retrieves a value from the given account's committed storage trie. func (s *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash { + start := time.Now() + needStorage := false + defer s.markMetrics(start, needStorage) stateObject := s.getStateObject(addr) hit := false if stateObject != nil { + needStorage = true return stateObject.GetCommittedState(s.db, hash, &hit) } return common.Hash{} @@ -512,6 +555,8 @@ func (s *StateDB) HasSuicided(addr common.Address) bool { // AddBalance adds amount to the account associated with addr. func (s *StateDB) AddBalance(addr common.Address, amount *big.Int) { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.AddBalance(amount) @@ -520,6 +565,8 @@ func (s *StateDB) AddBalance(addr common.Address, amount *big.Int) { // SubBalance subtracts amount from the account associated with addr. func (s *StateDB) SubBalance(addr common.Address, amount *big.Int) { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.SubBalance(amount) @@ -527,6 +574,8 @@ func (s *StateDB) SubBalance(addr common.Address, amount *big.Int) { } func (s *StateDB) SetBalance(addr common.Address, amount *big.Int) { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.SetBalance(amount) @@ -534,6 +583,8 @@ func (s *StateDB) SetBalance(addr common.Address, amount *big.Int) { } func (s *StateDB) SetNonce(addr common.Address, nonce uint64) { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.SetNonce(nonce) @@ -541,6 +592,8 @@ func (s *StateDB) SetNonce(addr common.Address, nonce uint64) { } func (s *StateDB) SetCode(addr common.Address, code []byte) { + start := time.Now() + defer s.markMetrics(start, false) stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { stateObject.SetCode(crypto.Keccak256Hash(code), code) @@ -548,8 +601,12 @@ func (s *StateDB) SetCode(addr common.Address, code []byte) { } func (s *StateDB) SetState(addr common.Address, key, value common.Hash) { + start := time.Now() + markStorage := false + defer s.markMetrics(start, markStorage) stateObject := s.GetOrNewStateObject(addr) if stateObject != nil { + markStorage = true stateObject.SetState(s.db, key, value) } } @@ -866,6 +923,8 @@ func (s *StateDB) createObject(addr common.Address) (newobj, prev *StateObject) // // Carrying over the balance ensures that Ether doesn't disappear. func (s *StateDB) CreateAccount(addr common.Address) { + start := time.Now() + defer s.markMetrics(start, false) newObj, prev := s.createObject(addr) if prev != nil { newObj.setBalance(prev.data.Balance) From 44d25afdf74df915d2e2a39e162180e783aba84a Mon Sep 17 00:00:00 2001 From: flywukong <2229306838@qq.com> Date: Tue, 1 Mar 2022 16:06:19 +0800 Subject: [PATCH 2/3] fix a error condition --- core/state/statedb.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/state/statedb.go b/core/state/statedb.go index d69b0d7258..ee6b648379 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -465,7 +465,7 @@ func (s *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash { if isSyncMainProcess { l1StorageMeter.Mark(1) } - if isSyncMainProcess { + if isMinerMainProcess { minerL1StorageMeter.Mark(1) } return stateObject.GetState(s.db, hash) From 5381bc9379814c5f76e80206e33a40b2f370ee39 Mon Sep 17 00:00:00 2001 From: flywukong <2229306838@qq.com> Date: Tue, 1 Mar 2022 18:35:34 +0800 Subject: [PATCH 3/3] fix disk time metrics --- core/state/snapshot/disklayer.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/core/state/snapshot/disklayer.go b/core/state/snapshot/disklayer.go index 569af1354f..50a56de62a 100644 --- a/core/state/snapshot/disklayer.go +++ b/core/state/snapshot/disklayer.go @@ -116,7 +116,7 @@ func (dl *diskLayer) AccountRLP(hash common.Hash) ([]byte, error) { hitInL3 := false hitInDisk := false - startGetInDisk := time.Now() + var startGetInDisk time.Time defer func() { // if mainProcess if isSyncMainProcess { @@ -131,7 +131,7 @@ func (dl *diskLayer) AccountRLP(hash common.Hash) ([]byte, error) { syncL3AccountMissMeter.Mark(1) cachemetrics.RecordCacheDepth("DISK_L4_ACCOUNT") cachemetrics.RecordCacheMetrics("DISK_L4_ACCOUNT", startGetInDisk) - cachemetrics.RecordTotalCosts("DISK_L4_ACCOUNT", start) + cachemetrics.RecordTotalCosts("DISK_L4_ACCOUNT", startGetInDisk) } } if isMinerMainProcess { @@ -147,8 +147,8 @@ func (dl *diskLayer) AccountRLP(hash common.Hash) ([]byte, error) { // layer 3 miss minerL3AccountMissMeter.Mark(1) cachemetrics.RecordMinerCacheDepth("MINER_L4_ACCOUNT") - cachemetrics.RecordMinerCacheMetrics("MINER_L4_ACCOUNT", start) - cachemetrics.RecordMinerTotalCosts("MINER_L4_ACCOUNT", start) + cachemetrics.RecordMinerCacheMetrics("MINER_L4_ACCOUNT", startGetInDisk) + cachemetrics.RecordMinerTotalCosts("MINER_L4_ACCOUNT", startGetInDisk) } } }() @@ -204,7 +204,7 @@ func (dl *diskLayer) Storage(accountHash, storageHash common.Hash) ([]byte, erro syncL3StorageMissMeter.Mark(1) cachemetrics.RecordCacheDepth("DISK_L4_STORAGE") cachemetrics.RecordCacheMetrics("DISK_L4_STORAGE", startGetInDisk) - cachemetrics.RecordTotalCosts("DISK_L4_STORAGE", start) + cachemetrics.RecordTotalCosts("DISK_L4_STORAGE", startGetInDisk) } } if isMinerMainProcess { @@ -221,7 +221,7 @@ func (dl *diskLayer) Storage(accountHash, storageHash common.Hash) ([]byte, erro minerL3StorageMissMeter.Mark(1) cachemetrics.RecordMinerCacheDepth("MINER_L4_STORAGE") cachemetrics.RecordMinerCacheMetrics("MINER_L4_STORAGE", startGetInDisk) - cachemetrics.RecordMinerTotalCosts("MINER_L4_STORAGE", start) + cachemetrics.RecordMinerTotalCosts("MINER_L4_STORAGE", startGetInDisk) } } }()