evmone: upgrade to version 0.13.0

cmd/dev/check_changes.cpp

@@ -117,7 +117,6 @@ int main(int argc, char* argv[]) {
         db::DataModel access_layer{txn};
 
         AnalysisCache analysis_cache{/*max_size=*/5'000};
-        ObjectPool<evmone::ExecutionState> state_pool;
         std::vector<Receipt> receipts;
         auto rule_set{protocol::rule_set_factory(*chain_config)};
         Block block;
@@ -133,7 +132,6 @@ int main(int argc, char* argv[]) {
 
             ExecutionProcessor processor{block, *rule_set, buffer, *chain_config};
             processor.evm().analysis_cache = &analysis_cache;
-            processor.evm().state_pool = &state_pool;
 
             if (const ValidationResult res = processor.execute_block(receipts); res != ValidationResult::kOk) {
                 log::Error() << "Failed execution for block " << block_num << " result " << magic_enum::enum_name<>(res);

cmd/dev/scan_txs.cpp

@@ -56,7 +56,6 @@ int main(int argc, char* argv[]) {
     // std::unique_ptr<lmdb::Transaction> txn{env->begin_ro_transaction()};
 
     AnalysisCache analysis_cache{/*max_size=*/5'000};
-    ObjectPool<evmone::ExecutionState> state_pool;
     std::vector<Receipt> receipts;
 
     try {
@@ -94,7 +93,6 @@ int main(int argc, char* argv[]) {
 
             ExecutionProcessor processor{block, *rule_set, buffer, *chain_config};
             processor.evm().analysis_cache = &analysis_cache;
-            processor.evm().state_pool = &state_pool;
 
             // Execute the block and retrieve the receipts
             if (const ValidationResult res = processor.execute_block(receipts); res != ValidationResult::kOk) {

cmd/test/ethereum.cpp

@@ -64,7 +64,9 @@ static const std::vector<fs::path> kFailingTests{};
 
 static constexpr size_t kColumnWidth{80};
 
-ObjectPool<evmone::ExecutionState> execution_state_pool{/*thread_safe=*/true};
+/// External EVMC VM.
+/// It is used in potential multiple test execution threads
+/// so usage may be broken if the VM is not thread-safe.
 evmc_vm* exo_evm{nullptr};
 
 enum class Status {
@@ -223,7 +225,6 @@ RunResults blockchain_test(const nlohmann::json& json_test) {
 
     InMemoryState state{read_genesis_allocation(json_test["pre"])};
     Blockchain blockchain{state, config_it->second, genesis_block};
-    blockchain.state_pool = &execution_state_pool;
     blockchain.exo_evm = exo_evm;
 
     for (const auto& json_block : json_test["blocks"]) {

silkworm/capi/silkworm.cpp

@@ -496,7 +496,6 @@ int silkworm_execute_blocks_ephemeral(SilkwormHandle handle, MDBX_txn* mdbx_txn,
         db::DataModel da_layer{txn};
 
         AnalysisCache analysis_cache{execution::block::BlockExecutor::kDefaultAnalysisCacheSize};
-        ObjectPool<evmone::ExecutionState> state_pool;
         execution::block::BlockExecutor block_executor{*chain_info, write_receipts, write_call_traces, write_change_sets};
         const auto now = std::chrono::steady_clock::now();
         ExecutionProgress execution_progress{.start_time = now, .next_log_time = now + 20s};
@@ -520,7 +519,7 @@ int silkworm_execute_blocks_ephemeral(SilkwormHandle handle, MDBX_txn* mdbx_txn,
                 const Block& block{prefetched_blocks.front()};
 
                 try {
-                    last_exec_result = block_executor.execute_single(block, state_buffer, analysis_cache, state_pool);
+                    last_exec_result = block_executor.execute_single(block, state_buffer, analysis_cache);
                     update_execution_progress(execution_progress, block, state_buffer, max_batch_size);
                 } catch (const db::Buffer::MemoryLimitError&) {
                     // infinite loop detection, buffer memory limit reached but no progress
@@ -620,7 +619,6 @@ int silkworm_execute_blocks_perpetual(SilkwormHandle handle, MDBX_env* mdbx_env,
         BlockNum batch_start_block_number{start_block};
         BlockNum last_block_number = 0;
         AnalysisCache analysis_cache{execution::block::BlockExecutor::kDefaultAnalysisCacheSize};
-        ObjectPool<evmone::ExecutionState> state_pool;
         execution::block::BlockExecutor block_executor{*chain_info, write_receipts, write_call_traces, write_change_sets};
         const auto now = std::chrono::steady_clock::now();
         ExecutionProgress execution_progress{.start_time = now, .next_log_time = now + 20s};
@@ -635,7 +633,7 @@ int silkworm_execute_blocks_perpetual(SilkwormHandle handle, MDBX_env* mdbx_env,
                 SILKWORM_ASSERT(block->header.number == block_number);
 
                 try {
-                    last_exec_result = block_executor.execute_single(*block, state_buffer, analysis_cache, state_pool);
+                    last_exec_result = block_executor.execute_single(*block, state_buffer, analysis_cache);
                     update_execution_progress(execution_progress, *block, state_buffer, max_batch_size);
                 } catch (const db::Buffer::MemoryLimitError&) {
                     // infinite loop detection, buffer memory limit reached but no progress

silkworm/core/execution/call_tracer.cpp

@@ -118,7 +118,7 @@ inline bool check_memory_gas(int64_t& gas_left, Memory& memory, const uint256& o
 template <Opcode Op>
 inline evmc_status_code check_preconditions(const intx::uint256* stack_top, int stack_height, int64_t gas,
                                             const evmone::ExecutionState& state) noexcept {
-    const auto& cost_table{get_baseline_cost_table(state.rev, state.analysis.baseline->eof_header.version)};
+    const auto& cost_table{get_baseline_cost_table(state.rev, state.analysis.baseline->eof_header().version)};
     return check_requirements<Op>(cost_table, gas, stack_top, stack_top - stack_height);
 }
 

silkworm/core/execution/evm.cpp

@@ -279,25 +279,6 @@ evmc_result EVM::execute(const evmc_message& message, ByteView code, const evmc:
     return execute_with_baseline_interpreter(rev, message, code, code_hash);
 }
 
-gsl::owner<evmone::ExecutionState*> EVM::acquire_state() const noexcept {
-    gsl::owner<evmone::ExecutionState*> state{nullptr};
-    if (state_pool) {
-        state = state_pool->acquire();
-    }
-    if (!state) {
-        state = new evmone::ExecutionState;
-    }
-    return state;
-}
-
-void EVM::release_state(gsl::owner<evmone::ExecutionState*> state) const noexcept {
-    if (state_pool) {
-        state_pool->add(state);
-    } else {
-        delete state;
-    }
-}
-
 evmc_result EVM::execute_with_baseline_interpreter(evmc_revision rev, const evmc_message& message, ByteView code,
                                                    const evmc::bytes32* code_hash) noexcept {
     std::shared_ptr<evmone::baseline::CodeAnalysis> analysis;
@@ -309,19 +290,15 @@ evmc_result EVM::execute_with_baseline_interpreter(evmc_revision rev, const evmc
         }
     }
     if (!analysis) {
-        analysis = std::make_shared<evmone::baseline::CodeAnalysis>(evmone::baseline::analyze(rev, code));
+        // EOF is disabled although evmone supports it. This will be needed as early as Prague, maybe later.
+        analysis = std::make_shared<evmone::baseline::CodeAnalysis>(evmone::baseline::analyze(code, /*eof_enabled=*/false));
         if (use_cache) {
             analysis_cache->put(*code_hash, analysis);
         }
     }
 
     EvmHost host{*this};
-    gsl::owner<evmone::ExecutionState*> state{acquire_state()};
-    state->reset(message, rev, EvmHost::get_interface(), host.to_context(), code, {});
-
-    evmc_result res{evmone::baseline::execute(*evm1_, message.gas, *state, *analysis)};
-
-    release_state(state);
+    evmc_result res{evmone::baseline::execute(*evm1_, EvmHost::get_interface(), host.to_context(), rev, message, *analysis)};
     return res;
 }
 

silkworm/core/execution/evm.hpp

@@ -115,8 +115,7 @@ class EVM {
     void remove_tracers() noexcept;
     [[nodiscard]] const EvmTracers& tracers() const noexcept { return tracers_; };
 
-    AnalysisCache* analysis_cache{nullptr};                   // provide one for better performance
-    ObjectPool<evmone::ExecutionState>* state_pool{nullptr};  // ditto
+    AnalysisCache* analysis_cache{nullptr};  // provide one for better performance
 
     evmc_vm* exo_evm{nullptr};  // it's possible to use an exogenous EVMC VM
 
@@ -138,9 +137,6 @@ class EVM {
     evmc_result execute_with_baseline_interpreter(evmc_revision rev, const evmc_message& message, ByteView code,
                                                   const evmc::bytes32* code_hash) noexcept;
 
-    gsl::owner<evmone::ExecutionState*> acquire_state() const noexcept;
-    void release_state(gsl::owner<evmone::ExecutionState*> state) const noexcept;
-
     const Block& block_;
     IntraBlockState& state_;
     const ChainConfig& config_;

silkworm/core/protocol/blockchain.cpp

@@ -90,7 +90,6 @@ ValidationResult Blockchain::insert_block(Block& block, bool check_state_root) {
 
 ValidationResult Blockchain::execute_block(const Block& block, bool check_state_root) {
     ExecutionProcessor processor{block, *rule_set_, state_, config_};
-    processor.evm().state_pool = state_pool;
     processor.evm().exo_evm = exo_evm;
 
     if (const ValidationResult res = processor.execute_block(receipts_); res != ValidationResult::kOk) {

silkworm/core/protocol/blockchain.hpp

@@ -48,8 +48,6 @@ class Blockchain {
 
     ValidationResult insert_block(Block& block, bool check_state_root);
 
-    ObjectPool<evmone::ExecutionState>* state_pool{nullptr};
-
     evmc_vm* exo_evm{nullptr};
 
   private:

silkworm/node/execution/block/block_executor.cpp

@@ -31,10 +31,9 @@ BlockExecutor::BlockExecutor(const ChainConfig* chain_config, bool write_receipt
       write_call_traces_{write_call_traces},
       write_change_sets_{write_change_sets} {}
 
-ValidationResult BlockExecutor::execute_single(const Block& block, db::Buffer& state_buffer, AnalysisCache& analysis_cache, ObjectPool<evmone::ExecutionState>& state_pool) {
+ValidationResult BlockExecutor::execute_single(const Block& block, db::Buffer& state_buffer, AnalysisCache& analysis_cache) {
     ExecutionProcessor processor{block, *protocol_rule_set_, state_buffer, *chain_config_};
     processor.evm().analysis_cache = &analysis_cache;
-    processor.evm().state_pool = &state_pool;
 
     CallTraces traces;
     CallTracer tracer{traces};

silkworm/node/execution/block/block_executor.hpp

@@ -28,7 +28,7 @@ class BlockExecutor {
 
     BlockExecutor(const ChainConfig* chain_config, bool write_receipts, bool write_call_traces, bool write_change_sets);
 
-    ValidationResult execute_single(const Block& block, db::Buffer& state_buffer, AnalysisCache& analysis_cache, ObjectPool<evmone::ExecutionState>& state_pool);
+    ValidationResult execute_single(const Block& block, db::Buffer& state_buffer, AnalysisCache& analysis_cache);
 
   private:
     const ChainConfig* chain_config_;
@@ -38,4 +38,4 @@ class BlockExecutor {
     bool write_change_sets_;
 };
 
-}  // namespace silkworm::execution::block
+}  // namespace silkworm::execution::block

silkworm/node/stagedsync/stages/stage_execution.cpp

@@ -94,13 +94,12 @@ Stage::Result Execution::forward(db::RWTxn& txn) {
 
         static constexpr size_t kCacheSize{5'000};
         AnalysisCache analysis_cache{kCacheSize};
-        ObjectPool<evmone::ExecutionState> state_pool;
 
         prefetched_blocks_.clear();
 
         while (block_num_ <= max_block_num) {
             throw_if_stopping();
-            const auto execution_result{execute_batch(txn, max_block_num, analysis_cache, state_pool,
+            const auto execution_result{execute_batch(txn, max_block_num, analysis_cache,
                                                       prune_history, prune_receipts, prune_call_traces)};
 
             // If we return with success we must persist data. Though counterintuitive, we must also persist on
@@ -201,8 +200,8 @@ void Execution::prefetch_blocks(db::RWTxn& txn, const BlockNum from, const Block
 }
 
 Stage::Result Execution::execute_batch(db::RWTxn& txn, BlockNum max_block_num, AnalysisCache& analysis_cache,
-                                       ObjectPool<evmone::ExecutionState>& state_pool, BlockNum prune_history_threshold,
-                                       BlockNum prune_receipts_threshold, BlockNum prune_call_traces_threshold) {
+                                       BlockNum prune_history_threshold, BlockNum prune_receipts_threshold,
+                                       BlockNum prune_call_traces_threshold) {
     Result ret{Result::kSuccess};
     using namespace std::chrono_literals;
     auto log_time{std::chrono::steady_clock::now()};
@@ -240,7 +239,7 @@ Stage::Result Execution::execute_batch(db::RWTxn& txn, BlockNum max_block_num, A
 
             execution::block::BlockExecutor block_executor{&chain_config_, write_receipts, write_traces, kWriteChangeSets};
             try {
-                if (const ValidationResult res = block_executor.execute_single(block, buffer, analysis_cache, state_pool); res != ValidationResult::kOk) {
+                if (const ValidationResult res = block_executor.execute_single(block, buffer, analysis_cache); res != ValidationResult::kOk) {
                     // Flush work done so far not to lose progress up to the previous valid block and to correctly trigger unwind
                     // This requires to commit in Execution::forward also for kInvalidBlock: unwind will remove last invalid block updates
                     if (write_receipts) {

silkworm/node/stagedsync/stages/stage_execution.hpp

@@ -66,8 +66,8 @@ class Execution final : public Stage {
     //! \brief Executes a batch of blocks
     //! \remarks A batch completes when either max block is reached or buffer dimensions overflow
     Stage::Result execute_batch(db::RWTxn& txn, BlockNum max_block_num, AnalysisCache& analysis_cache,
-                                ObjectPool<evmone::ExecutionState>& state_pool, BlockNum prune_history_threshold,
-                                BlockNum prune_receipts_threshold, BlockNum prune_call_traces_threshold);
+                                BlockNum prune_history_threshold, BlockNum prune_receipts_threshold,
+                                BlockNum prune_call_traces_threshold);
 
     //! \brief For given changeset cursor/bucket it reverts the changes on states buckets
     static void unwind_state_from_changeset(db::ROCursor& source_changeset, db::RWCursorDupSort& plain_state_table,

silkworm/rpc/core/evm_executor.cpp

@@ -233,7 +233,6 @@ ExecutionResult EVMExecutor::call(
     auto& svc = use_service<AnalysisCacheService>(workers_);
 
     evm.analysis_cache = svc.get_analysis_cache();
-    evm.state_pool = svc.get_object_pool();
     evm.beneficiary = rule_set_->get_beneficiary(block.header);
     evm.transfer = rule_set_->transfer_func();
     evm.bailout = bailout;

silkworm/rpc/core/evm_executor.hpp

@@ -78,11 +78,9 @@ class AnalysisCacheService : public ServiceBase<AnalysisCacheService> {
         : ServiceBase<AnalysisCacheService>(owner) {}
 
     void shutdown() override {}
-    ObjectPool<evmone::ExecutionState>* get_object_pool() { return &state_pool_; }
     AnalysisCache* get_analysis_cache() { return &analysis_cache_; }
 
   private:
-    ObjectPool<evmone::ExecutionState> state_pool_{true};
     AnalysisCache analysis_cache_{kCacheSize, true};
 };