journal: clear no allocation

Author: duyquang6

crates/pevm/src/chain.rs

@@ -52,7 +52,7 @@ pub trait PevmChain: Debug {
     // TODO: Support more tx conversions
     type Envelope: Debug + From<Signed<TxLegacy>>;
 
-    /// The EVM type
+    /// The EVM type for sequential execution
     type Evm<DB: Database>: EvmTr<
             Context: ContextTr<
                 Db = DB,
@@ -76,6 +76,31 @@ pub trait PevmChain: Debug {
             Error = EVMError<DB::Error, Self::EvmErrorType>,
         >;
 
+    /// The EVM type for PEVM parallel execution — uses `Journal<DB, true>` to eliminate
+    /// dead cross-transaction warm-tracking in the Occupied account/storage paths.
+    type PevmEvm<DB: Database>: EvmTr<
+            Context: ContextTr<
+                Db = DB,
+                Tx = Self::EvmTx,
+                Journal = crate::journal::Journal<DB, true>,
+                Local: LocalContextTr,
+            > + ContextSetters,
+            Frame: FrameTr<FrameInit = FrameInit, FrameResult = FrameResult>,
+            Precompiles: PrecompileProvider<
+                <Self::PevmEvm<DB> as EvmTr>::Context,
+                Output = InterpreterResult,
+            >,
+            Instructions: InstructionProvider<
+                Context = <Self::PevmEvm<DB> as EvmTr>::Context,
+                InterpreterTypes = EthInterpreter,
+            >,
+        > + ExecuteEvm<
+            Tx = Self::EvmTx,
+            ExecutionResult = ExecutionResult<Self::EvmHaltReason>,
+            State = EvmState,
+            Error = EVMError<DB::Error, Self::EvmErrorType>,
+        >;
+
     /// The EVM Spec type
     type EvmSpecId: Into<SpecId> + Copy + Send + Sync + Default;
 
@@ -123,6 +148,14 @@ pub trait PevmChain: Debug {
         db: DB,
     ) -> Self::Evm<DB>;
 
+    /// Get `Self::PevmEvm`
+    fn build_pevm_evm<DB: Database>(
+        &self,
+        spec_id: Self::EvmSpecId,
+        block_env: BlockEnv,
+        db: DB,
+    ) -> Self::PevmEvm<DB>;
+
     /// Get `Self::EvmTx`
     fn get_tx_env(
         &self,
@@ -135,7 +168,7 @@ pub trait PevmChain: Debug {
     /// Whether this transaction has a nonce. Return false for types that have no nonce
     /// (e.g. OP deposits) so pevm's sender-nonce ordering check is skipped. Implementations
     /// may also adjust EVM cfg as a side effect (e.g. setting `disable_nonce_check`).
-    fn has_nonce<DB: Database>(&self, _: &mut Self::Evm<DB>, _: &Self::EvmTx) -> bool {
+    fn has_nonce<DB: Database>(&self, _: &mut Self::PevmEvm<DB>, _: &Self::EvmTx) -> bool {
         true
     }
 

crates/pevm/src/chain/ethereum.rs

@@ -59,12 +59,46 @@ fn get_ethereum_gas_price(tx: &TxEnvelope) -> Result<u128, EthereumTransactionPa
     }
 }
 
+impl PevmEthereum {
+    fn build_evm_inner<DB: Database, const IS_PEVM: bool>(
+        &self,
+        spec_id: SpecId,
+        block_env: BlockEnv,
+        db: DB,
+    ) -> MainnetEvm<Context<BlockEnv, TxEnv, CfgEnv, DB, crate::journal::Journal<DB, IS_PEVM>, ()>>
+    {
+        let mut cfg = CfgEnv::new_with_spec(spec_id).with_chain_id(self.id);
+        if spec_id >= SpecId::PRAGUE {
+            cfg = cfg.with_max_blobs_per_tx(MAX_BLOB_NUMBER_PER_BLOCK_PRAGUE);
+        } else if spec_id >= SpecId::CANCUN {
+            cfg = cfg.with_max_blobs_per_tx(MAX_BLOB_NUMBER_PER_BLOCK_CANCUN);
+        }
+        let journal_cfg = JournalCfg {
+            spec: spec_id,
+            eip7708_disabled: cfg.amsterdam_eip7708_disabled,
+            eip7708_delayed_burn_disabled: cfg.amsterdam_eip7708_delayed_burn_disabled,
+        };
+        Context {
+            block: block_env,
+            tx: TxEnv::default(),
+            cfg,
+            journaled_state: crate::journal::Journal::<DB, IS_PEVM>::new(db, journal_cfg),
+            chain: (),
+            local: LocalContext::default(),
+            error: Ok(()),
+        }
+        .build_mainnet()
+    }
+}
+
 impl PevmChain for PevmEthereum {
     type Network = alloy_provider::network::Ethereum;
     type Transaction = alloy_rpc_types_eth::Transaction;
     type Envelope = TxEnvelope;
     type Evm<DB: Database> =
         MainnetEvm<Context<BlockEnv, TxEnv, CfgEnv, DB, crate::journal::Journal<DB>, ()>>;
+    type PevmEvm<DB: Database> =
+        MainnetEvm<Context<BlockEnv, TxEnv, CfgEnv, DB, crate::journal::Journal<DB, true>, ()>>;
     type EvmSpecId = SpecId;
     type EvmTx = TxEnv;
     type EvmHaltReason = HaltReason;
@@ -122,27 +156,16 @@ impl PevmChain for PevmEthereum {
         block_env: BlockEnv,
         db: DB,
     ) -> Self::Evm<DB> {
-        let mut cfg = CfgEnv::new_with_spec(spec_id).with_chain_id(self.id);
-        if spec_id >= SpecId::PRAGUE {
-            cfg = cfg.with_max_blobs_per_tx(MAX_BLOB_NUMBER_PER_BLOCK_PRAGUE);
-        } else if spec_id >= SpecId::CANCUN {
-            cfg = cfg.with_max_blobs_per_tx(MAX_BLOB_NUMBER_PER_BLOCK_CANCUN);
-        }
-        let journal_cfg = JournalCfg {
-            spec: spec_id,
-            eip7708_disabled: cfg.amsterdam_eip7708_disabled,
-            eip7708_delayed_burn_disabled: cfg.amsterdam_eip7708_delayed_burn_disabled,
-        };
-        Context {
-            block: block_env,
-            tx: TxEnv::default(),
-            cfg,
-            journaled_state: crate::journal::Journal::new(db, journal_cfg),
-            chain: (),
-            local: LocalContext::default(),
-            error: Ok(()),
-        }
-        .build_mainnet()
+        self.build_evm_inner::<DB, false>(spec_id, block_env, db)
+    }
+
+    fn build_pevm_evm<DB: Database>(
+        &self,
+        spec_id: Self::EvmSpecId,
+        block_env: BlockEnv,
+        db: DB,
+    ) -> Self::PevmEvm<DB> {
+        self.build_evm_inner::<DB, true>(spec_id, block_env, db)
     }
 
     /// Get the REVM tx envs of an Alloy block.

crates/pevm/src/chain/rise.rs

@@ -61,6 +61,42 @@ fn get_gas_price(tx: &OpTxEnvelope) -> Result<u128, RiseTransactionParsingError>
     }
 }
 
+impl PevmRise {
+    fn build_evm_inner<DB: Database, const IS_PEVM: bool>(
+        &self,
+        spec_id: OpSpecId,
+        block_env: BlockEnv,
+        db: DB,
+    ) -> OpEvm<
+        Context<
+            BlockEnv,
+            OpTransaction<TxEnv>,
+            CfgEnv<OpSpecId>,
+            DB,
+            crate::journal::Journal<DB, IS_PEVM>,
+            L1BlockInfo,
+        >,
+        (),
+    > {
+        let cfg = CfgEnv::new_with_spec(spec_id).with_chain_id(RISE_CHAIN_ID);
+        let journal_cfg = JournalCfg {
+            spec: spec_id.into(),
+            eip7708_disabled: cfg.amsterdam_eip7708_disabled,
+            eip7708_delayed_burn_disabled: cfg.amsterdam_eip7708_delayed_burn_disabled,
+        };
+        Context {
+            block: block_env,
+            tx: OpTransaction::default(),
+            cfg,
+            journaled_state: crate::journal::Journal::<DB, IS_PEVM>::new(db, journal_cfg),
+            chain: L1BlockInfo::default(),
+            local: LocalContext::default(),
+            error: Ok(()),
+        }
+        .build_op()
+    }
+}
+
 impl PevmChain for PevmRise {
     type Network = op_alloy_network::Optimism;
     type Transaction = op_alloy_rpc_types::Transaction;
@@ -76,6 +112,17 @@ impl PevmChain for PevmRise {
         >,
         (),
     >;
+    type PevmEvm<DB: Database> = OpEvm<
+        Context<
+            BlockEnv,
+            op_revm::OpTransaction<TxEnv>,
+            CfgEnv<op_revm::OpSpecId>,
+            DB,
+            crate::journal::Journal<DB, true>,
+            op_revm::L1BlockInfo,
+        >,
+        (),
+    >;
     type EvmSpecId = OpSpecId;
     type EvmTx = OpTransaction<TxEnv>;
     type EvmHaltReason = OpHaltReason;
@@ -106,22 +153,16 @@ impl PevmChain for PevmRise {
         block_env: BlockEnv,
         db: DB,
     ) -> Self::Evm<DB> {
-        let cfg = CfgEnv::new_with_spec(spec_id).with_chain_id(RISE_CHAIN_ID);
-        let journal_cfg = JournalCfg {
-            spec: spec_id.into(),
-            eip7708_disabled: cfg.amsterdam_eip7708_disabled,
-            eip7708_delayed_burn_disabled: cfg.amsterdam_eip7708_delayed_burn_disabled,
-        };
-        Context {
-            block: block_env,
-            tx: OpTransaction::default(),
-            cfg,
-            journaled_state: crate::journal::Journal::new(db, journal_cfg),
-            chain: L1BlockInfo::default(),
-            local: LocalContext::default(),
-            error: Ok(()),
-        }
-        .build_op()
+        self.build_evm_inner::<DB, false>(spec_id, block_env, db)
+    }
+
+    fn build_pevm_evm<DB: Database>(
+        &self,
+        spec_id: Self::EvmSpecId,
+        block_env: BlockEnv,
+        db: DB,
+    ) -> Self::PevmEvm<DB> {
+        self.build_evm_inner::<DB, true>(spec_id, block_env, db)
     }
 
     fn build_mv_memory(&self, block_env: &BlockEnv, txs: &[OpTransaction<TxEnv>]) -> MvMemory {
@@ -293,7 +334,7 @@ impl PevmChain for PevmRise {
         &tx.base
     }
 
-    fn has_nonce<DB: Database>(&self, evm: &mut Self::Evm<DB>, tx: &Self::EvmTx) -> bool {
+    fn has_nonce<DB: Database>(&self, evm: &mut Self::PevmEvm<DB>, tx: &Self::EvmTx) -> bool {
         let is_deposit = tx.is_deposit();
         evm.ctx()
             .modify_cfg(|cfg| cfg.disable_nonce_check = is_deposit);

crates/pevm/src/journal.rs

@@ -462,7 +462,7 @@ impl<'a, DB: Database> JournaledAccountTr for JournaledAccount<'a, DB> {
 /// EIP-7708 (Amsterdam) is omitted — neither Ethereum (CANCUN) nor RISE (JOVIAN=Prague) needs it.
 #[allow(missing_docs)]
 #[derive(Debug)]
-pub struct Journal<DB: Database> {
+pub struct Journal<DB: Database, const IS_PEVM: bool = false> {
     pub database: DB,
     pub state: EvmState,
     /// EIP-1153 transient storage, cleared after every transaction.
@@ -474,11 +474,9 @@ pub struct Journal<DB: Database> {
     pub transaction_id: usize,
     pub cfg: JournalCfg,
     pub warm_addresses: WarmAddresses,
-    /// True when running inside pevm's parallel execution path.
-    pub is_pevm: bool,
 }
 
-impl<DB: Database> Journal<DB> {
+impl<DB: Database, const IS_PEVM: bool> Journal<DB, IS_PEVM> {
     pub(crate) fn new(database: DB, cfg: JournalCfg) -> Self {
         Self {
             database,
@@ -490,7 +488,6 @@ impl<DB: Database> Journal<DB> {
             transaction_id: 0,
             cfg,
             warm_addresses: WarmAddresses::new(),
-            is_pevm: false,
         }
     }
 
@@ -621,7 +618,7 @@ impl<DB: Database> Journal<DB> {
     }
 }
 
-impl<DB: Database> JournalTr for Journal<DB> {
+impl<DB: Database, const IS_PEVM: bool> JournalTr for Journal<DB, IS_PEVM> {
     type Database = DB;
     type State = EvmState;
     type JournaledAccount<'a>
@@ -679,7 +676,20 @@ impl<DB: Database> JournalTr for Journal<DB> {
     }
 
     fn clear(&mut self) {
-        self.finalize();
+        if IS_PEVM {
+            // State is either already empty (taken by finalize on success) or leftover from
+            // a failed tx. Either way, clear in-place to retain heap allocations for reuse.
+            // Pre-Spurious-Dragon fixup in finalize() is irrelevant — state is being discarded.
+            self.state.clear();
+            self.warm_addresses.clear_coinbase_and_access_list();
+            self.logs.clear();
+            self.transient_storage.clear();
+            self.journal.clear();
+            self.depth = 0;
+            self.transaction_id = 0;
+        } else {
+            self.finalize();
+        }
     }
 
     fn depth(&self) -> usize {

crates/pevm/src/vm.rs

@@ -477,7 +477,7 @@ pub(crate) struct Vm<'a, S: Storage, C: PevmChain> {
     mv_memory: &'a MvMemory,
     beneficiary_location_hash: MemoryLocationHash,
     // Dedicated EVM for the worker, reset before each transaction exectution.
-    evm: C::Evm<VmDb<'a, S>>,
+    evm: C::PevmEvm<VmDb<'a, S>>,
 }
 
 impl<'a, S: Storage, C: PevmChain> Vm<'a, S, C> {
@@ -516,11 +516,7 @@ impl<'a, S: Storage, C: PevmChain> Vm<'a, S, C> {
             beneficiary_location_hash: hash_deterministic(MemoryLocation::Basic(
                 block_env.beneficiary,
             )),
-            evm: {
-                let mut evm = chain.build_evm(spec_id, block_env.clone(), db);
-                evm.ctx_mut().journal_mut().is_pevm = true;
-                evm
-            },
+            evm: chain.build_pevm_evm(spec_id, block_env.clone(), db),
         }
     }
 
@@ -779,7 +775,7 @@ impl<C, DB> Default for NoBeneficiaryHandler<C, DB> {
 }
 
 impl<C: PevmChain, DB: Database> Handler for NoBeneficiaryHandler<C, DB> {
-    type Evm = C::Evm<DB>;
+    type Evm = C::PevmEvm<DB>;
     type Error = EVMError<DB::Error, InvalidTransaction>;
     type HaltReason = C::EvmHaltReason;