Add more metrics for account/storage touched/changed

Author: Akatsukis

category/execution/ethereum/execute_block.cpp

@@ -178,7 +178,8 @@ std::vector<std::vector<std::optional<Address>>> recover_authorities(
 
 template <Traits traits>
 void execute_block_header(
-    Chain const &chain, BlockState &block_state, BlockHeader const &header)
+    Chain const &chain, BlockState &block_state, BlockHeader const &header,
+    BlockMetrics &block_metrics)
 {
     State state{block_state, Incarnation{header.number, 0}};
 
@@ -204,7 +205,7 @@ void execute_block_header(
     }
 
     MONAD_ASSERT(block_state.can_merge(state));
-    block_state.merge(state);
+    block_state.merge(state, block_metrics);
     record_account_access_events(MONAD_ACCT_ACCESS_BLOCK_PROLOGUE, state);
 }
 
@@ -341,7 +342,8 @@ Result<std::vector<Receipt>> execute_block(
     MONAD_ASSERT(senders.size() == call_tracers.size());
     MONAD_ASSERT(senders.size() == state_tracers.size());
 
-    execute_block_header<traits>(chain, block_state, block.header);
+    execute_block_header<traits>(
+        chain, block_state, block.header, block_metrics);
 
     BOOST_OUTCOME_TRY(
         auto const retvals,
@@ -373,7 +375,7 @@ Result<std::vector<Receipt>> execute_block(
     }
 
     MONAD_ASSERT(block_state.can_merge(state));
-    block_state.merge(state);
+    block_state.merge(state, block_metrics);
     record_account_access_events(MONAD_ACCT_ACCESS_BLOCK_EPILOGUE, state);
 
     return retvals;

category/execution/ethereum/execute_block.hpp

@@ -41,7 +41,8 @@ struct Block;
 struct Chain;
 
 template <Traits traits>
-void execute_block_header(Chain const &, BlockState &, BlockHeader const &);
+void execute_block_header(
+    Chain const &, BlockState &, BlockHeader const &, BlockMetrics &);
 
 template <Traits traits>
 Result<std::vector<Receipt>> execute_block_transactions(

category/execution/ethereum/execute_transaction.cpp

@@ -417,7 +417,7 @@ Result<Receipt> ExecuteTransaction<traits>::operator()()
             auto const receipt = execute_final(state, result.value());
             call_tracer_.on_finish(receipt.gas_used);
             trace::run_tracer<traits>(state_tracer_, state);
-            block_state_.merge(state);
+            block_state_.merge(state, block_metrics_);
             record_txn_output_events(
                 static_cast<uint32_t>(this->i_),
                 receipt,
@@ -443,7 +443,7 @@ Result<Receipt> ExecuteTransaction<traits>::operator()()
         auto const receipt = execute_final(state, result.value());
         call_tracer_.on_finish(receipt.gas_used);
         trace::run_tracer<traits>(state_tracer_, state);
-        block_state_.merge(state);
+        block_state_.merge(state, block_metrics_);
         record_txn_output_events(
             static_cast<uint32_t>(this->i_),
             receipt,

category/execution/ethereum/metrics/block_metrics.hpp

@@ -24,6 +24,10 @@ MONAD_NAMESPACE_BEGIN
 class BlockMetrics
 {
     uint32_t n_retries_{0};
+    uint32_t account_touched_{0};
+    uint32_t account_changed_{0};
+    uint32_t storage_touched_{0};
+    uint32_t storage_changed_{0};
     std::chrono::microseconds tx_exec_time_{1};
 
 public:
@@ -37,6 +41,26 @@ class BlockMetrics
         return n_retries_;
     }
 
+    uint32_t num_account_touched() const
+    {
+        return account_touched_;
+    }
+
+    uint32_t num_account_changed() const
+    {
+        return account_changed_;
+    }
+
+    uint32_t num_storage_touched() const
+    {
+        return storage_touched_;
+    }
+
+    uint32_t num_storage_changed() const
+    {
+        return storage_changed_;
+    }
+
     void set_tx_exec_time(std::chrono::microseconds const exec_time)
     {
         tx_exec_time_ = exec_time;
@@ -46,6 +70,26 @@ class BlockMetrics
     {
         return tx_exec_time_;
     }
+
+    void add_account_touched(uint32_t const value)
+    {
+        account_touched_ += value;
+    }
+
+    void add_account_changed(uint32_t const value)
+    {
+        account_changed_ += value;
+    }
+
+    void add_storage_touched(uint32_t const value)
+    {
+        storage_touched_ += value;
+    }
+
+    void add_storage_changed(uint32_t const value)
+    {
+        storage_changed_ += value;
+    }
 };
 
 MONAD_NAMESPACE_END

category/execution/ethereum/state2/block_state.cpp

@@ -236,6 +236,65 @@ void BlockState::merge(State const &state)
     }
 }
 
+void BlockState::merge(State const &state, BlockMetrics &block_metrics)
+{
+    ankerl::unordered_dense::segmented_set<bytes32_t> code_hashes;
+
+    auto const &current = state.current();
+    for (auto const &[address, stack] : current) {
+        MONAD_ASSERT(stack.size() == 1);
+        MONAD_ASSERT(stack.version() == 0);
+        auto const &account_state = stack.recent();
+        auto const &account = account_state.account_;
+        if (account.has_value()) {
+            code_hashes.insert(account.value().code_hash);
+        }
+    }
+
+    auto const &code = state.code();
+    for (auto const &code_hash : code_hashes) {
+        auto const it = code.find(code_hash);
+        if (it == code.end()) {
+            continue;
+        }
+        code_.emplace(code_hash, it->second->intercode()); // TODO try_emplace
+    }
+
+    MONAD_ASSERT(state_);
+    for (auto const &[address, stack] : current) {
+        auto const &account_state = stack.recent();
+        auto const &account = account_state.account_;
+        auto const &storage = account_state.storage_;
+        StateDeltas::accessor it{};
+        MONAD_ASSERT(state_->find(it, address));
+        it->second.account.second = account;
+        if (account.has_value()) {
+            block_metrics.add_account_touched(1);
+            if (it->second.account.first != account) {
+                block_metrics.add_account_changed(1);
+            }
+            for (auto const &[key, value] : storage) {
+                StorageDeltas::accessor it2{};
+                block_metrics.add_storage_touched(1);
+                if (it->second.storage.find(it2, key)) {
+                    it2->second.second = value;
+                    if (it2->second.first != value) {
+                        block_metrics.add_storage_changed(1);
+                    }
+                }
+                else {
+                    it->second.storage.emplace(
+                        key, std::make_pair(bytes32_t{}, value));
+                    block_metrics.add_storage_changed(1);
+                }
+            }
+        }
+        else {
+            it->second.storage.clear();
+        }
+    }
+}
+
 void BlockState::commit(
     bytes32_t const &block_id, BlockHeader const &header,
     std::vector<Receipt> const &receipts,

category/execution/ethereum/state2/block_state.hpp

@@ -21,6 +21,7 @@
 #include <category/execution/ethereum/core/receipt.hpp>
 #include <category/execution/ethereum/core/transaction.hpp>
 #include <category/execution/ethereum/db/db.hpp>
+#include <category/execution/ethereum/metrics/block_metrics.hpp>
 #include <category/execution/ethereum/state2/state_deltas.hpp>
 #include <category/execution/ethereum/trace/call_tracer.hpp>
 #include <category/execution/ethereum/types/incarnation.hpp>
@@ -58,6 +59,8 @@ class BlockState final
 
     void merge(State const &);
 
+    void merge(State const &, BlockMetrics &);
+
     void commit(
         bytes32_t const &block_id, BlockHeader const &,
         std::vector<Receipt> const & = {},

category/rpc/monad_executor.cpp

@@ -427,8 +427,8 @@ namespace
                 chain_context.authorities.data(), transactions_size};
 
         // Execute block header
-        execute_block_header<traits>(chain, block_state, header);
         BlockMetrics metrics{};
+        execute_block_header<traits>(chain, block_state, header, metrics);
 
         // Prepare state tracers and auxiliary noop call tracers.
         std::vector<std::unique_ptr<trace::StateTracer>> state_tracers{};

cmd/monad/runloop_ethereum.cpp

@@ -85,7 +85,7 @@ Result<void> process_ethereum_block(
     fiber::PriorityPool &priority_pool, Block &block, bytes32_t const &block_id,
     bytes32_t const &parent_block_id, bool const enable_tracing)
 {
-    [[maybe_unused]] auto const block_start = std::chrono::system_clock::now();
+    [[maybe_unused]] auto const block_start = std::chrono::steady_clock::now();
     auto const block_begin = std::chrono::steady_clock::now();
 
     // Block input validation
@@ -189,7 +189,8 @@ Result<void> process_ethereum_block(
         "__exec_block,bl={:8},ts={}"
         ",tx={:5},rt={:4},rtp={:5.2f}%"
         ",sr={:>7},txe={:>8},cmt={:>8},tot={:>8},tpse={:5},tps={:5}"
-        ",gas={:9},gpse={:4},gps={:3}{}{}{}",
+        ",gas={:9},gpse={:4},gps={:3},at={},am={},st={},sm={}"
+        "{}{}{}",
         block.header.number,
         std::chrono::duration_cast<std::chrono::milliseconds>(
             block_start.time_since_epoch())
@@ -210,6 +211,10 @@ Result<void> process_ethereum_block(
         output_header.gas_used /
             (uint64_t)std::max(1L, block_metrics.tx_exec_time().count()),
         output_header.gas_used / (uint64_t)std::max(1L, block_time.count()),
+        block_metrics.num_account_touched(),
+        block_metrics.num_account_changed(),
+        block_metrics.num_storage_touched(),
+        block_metrics.num_storage_changed(),
         db.print_stats(),
         vm.print_and_reset_block_counts(),
         vm.print_compiler_stats());

cmd/monad/runloop_monad.cpp

@@ -155,7 +155,7 @@ Result<BlockExecOutput> propose_block(
     vm::VM &vm, fiber::PriorityPool &priority_pool, bool const is_first_block,
     bool const enable_tracing, BlockCache &block_cache)
 {
-    [[maybe_unused]] auto const block_start = std::chrono::system_clock::now();
+    [[maybe_unused]] auto const block_start = std::chrono::steady_clock::now();
     auto const block_begin = std::chrono::steady_clock::now();
     auto const &block_hash_buffer =
         block_hash_chain.find_chain(consensus_header.parent_id());