Prefetch access lists in parallel

category/execution/ethereum/execute_block.cpp

@@ -344,6 +344,72 @@ Result<std::vector<Receipt>> execute_block(
 
     execute_block_header<traits>(chain, block_state, block.header);
 
+    auto const access_list_begin = std::chrono::steady_clock::now();
+    {
+        size_t count = 0;
+        for (auto const &tx : block.transactions) {
+            count += tx.access_list.size();
+        }
+        std::shared_ptr<boost::fibers::promise<void>[]> promises{
+            new boost::fibers::promise<void>[count]};
+        size_t i = 0;
+        for (auto const &tx : block.transactions) {
+            for (auto const &ae : tx.access_list) {
+                MONAD_ASSERT(i < count);
+                priority_pool.submit(
+                    i, [promises, i, addr = ae.a, &block_state]() {
+                        block_state.read_account(addr);
+                        promises[static_cast<std::ptrdiff_t>(i)].set_value();
+                    });
+                ++i;
+            }
+        }
+        MONAD_ASSERT(i == count);
+        block_metrics.set_access_list_addrs(count);
+        for (size_t j = 0; j < count; ++j) {
+            promises[static_cast<std::ptrdiff_t>(j)].get_future().wait();
+        }
+    }
+    {
+        size_t count = 0;
+        for (auto const &tx : block.transactions) {
+            for (auto const &ae : tx.access_list) {
+                count += ae.keys.size();
+            }
+        }
+        std::shared_ptr<boost::fibers::promise<void>[]> promises{
+            new boost::fibers::promise<void>[count]};
+        size_t i = 0;
+        for (auto const &tx : block.transactions) {
+            for (auto const &ae : tx.access_list) {
+                Address const addr = ae.a;
+                auto const account = block_state.read_account(addr);
+                Incarnation const incarnation = account.has_value()
+                                                    ? account->incarnation
+                                                    : Incarnation{0, 0};
+                for (auto const &key : ae.keys) {
+                    MONAD_ASSERT(i < count);
+                    priority_pool.submit(
+                        i,
+                        [promises, i, addr, incarnation, key, &block_state]() {
+                            block_state.read_storage(addr, incarnation, key);
+                            promises[static_cast<std::ptrdiff_t>(i)]
+                                .set_value();
+                        });
+                    ++i;
+                }
+            }
+        }
+        MONAD_ASSERT(i == count);
+        block_metrics.set_access_list_keys(count);
+        for (size_t j = 0; j < count; ++j) {
+            promises[static_cast<std::ptrdiff_t>(j)].get_future().wait();
+        }
+    }
+    block_metrics.set_access_list_time(
+        std::chrono::duration_cast<std::chrono::microseconds>(
+            std::chrono::steady_clock::now() - access_list_begin));
+
     BOOST_OUTCOME_TRY(
         auto const retvals,
         execute_block_transactions<traits>(

category/execution/ethereum/metrics/block_metrics.hpp

@@ -25,6 +25,9 @@ class BlockMetrics
 {
     uint32_t n_retries_{0};
     std::chrono::microseconds tx_exec_time_{1};
+    std::chrono::microseconds access_list_time_{1};
+    size_t n_access_list_addrs_{0};
+    size_t n_access_list_keys_{0};
 
 public:
     void inc_retries()
@@ -42,10 +45,40 @@ class BlockMetrics
         tx_exec_time_ = exec_time;
     }
 
+    void set_access_list_time(std::chrono::microseconds const access_list_time)
+    {
+        access_list_time_ = access_list_time;
+    }
+
+    void set_access_list_addrs(size_t const count)
+    {
+        n_access_list_addrs_ = count;
+    }
+
+    void set_access_list_keys(size_t const count)
+    {
+        n_access_list_keys_ = count;
+    }
+
     std::chrono::microseconds tx_exec_time() const
     {
         return tx_exec_time_;
     }
+
+    std::chrono::microseconds access_list_time() const
+    {
+        return access_list_time_;
+    }
+
+    size_t access_list_addrs() const
+    {
+        return n_access_list_addrs_;
+    }
+
+    size_t access_list_keys() const
+    {
+        return n_access_list_keys_;
+    }
 };
 
 MONAD_NAMESPACE_END

cmd/monad/runloop_ethereum.cpp

@@ -188,6 +188,7 @@ Result<void> process_ethereum_block(
     LOG_INFO(
         "__exec_block,bl={:8},ts={}"
         ",tx={:5},rt={:4},rtp={:5.2f}%"
+        ",ala={:3},alk={:4},alt={:>7}"
         ",sr={:>7},txe={:>8},cmt={:>8},tot={:>8},tpse={:5},tps={:5}"
         ",gas={:9},gpse={:4},gps={:3}{}{}{}",
         block.header.number,
@@ -198,6 +199,9 @@ Result<void> process_ethereum_block(
         block_metrics.num_retries(),
         100.0 * (double)block_metrics.num_retries() /
             std::max(1.0, (double)block.transactions.size()),
+        block_metrics.access_list_addrs(),
+        block_metrics.access_list_keys(),
+        block_metrics.access_list_time(),
         sender_recovery_time,
         block_metrics.tx_exec_time(),
         commit_time,

cmd/monad/runloop_monad.cpp

@@ -334,6 +334,7 @@ Result<BlockExecOutput> propose_block(
     LOG_INFO(
         "__exec_block,bl={:8},id={},ts={}"
         ",tx={:5},rt={:4},rtp={:5.2f}%"
+        ",ala={:3},alk={:4},alt={:>7}"
         ",sr={:>7},txe={:>8},cmt={:>8},tot={:>8},tpse={:5},tps={:5}"
         ",gas={:9},gpse={:4},gps={:3}{}{}{}",
         block.header.number,
@@ -345,6 +346,9 @@ Result<BlockExecOutput> propose_block(
         block_metrics.num_retries(),
         100.0 * (double)block_metrics.num_retries() /
             std::max(1.0, (double)block.transactions.size()),
+        block_metrics.access_list_addrs(),
+        block_metrics.access_list_keys(),
+        block_metrics.access_list_time(),
         sender_recovery_time,
         block_metrics.tx_exec_time(),
         commit_time,