Struct PayloadExecutionCache 

pub struct PayloadExecutionCache { /* private fields */ }

A guarded, thread-safe cache of execution state that tracks the most recent block’s caches.

This is the cross-block cache used to accelerate sequential payload processing. When a new block arrives, its parent’s cached state can be reused to avoid redundant database lookups.

This process assumes that payloads are received sequentially.

Cache Safety

CRITICAL: Cache update operations require exclusive access. All concurrent cache users (such as prewarming tasks) must be terminated before calling PayloadExecutionCache::update_with_guard, otherwise the cache may be corrupted or cleared.

Implementations

impl PayloadExecutionCache

pub fn get_cache_for(&self, parent_hash: B256) -> Option<SavedCache>

Returns the cache for parent_hash if it’s available for use.

A cache is considered available when:

• It exists and matches the requested parent hash
• No other tasks are currently using it (checked via Arc reference count)

pub fn wait_for_availability(&self) -> Duration

Waits for the mutex protecting the stored Option<SavedCache> to be released.

This does not wait for other users to drop their ExecutionCache clones or for removed caches to finish dropping after unlocking. A subsequent Self::get_cache_for can still return None, causing its caller to allocate a new cache while those drops run.

Returns only the time spent waiting for the mutex, excluding post-unlock cleanup.

pub fn update_with_guard<F, R>(&self, update_fn: F) -> R

where F: FnOnce(&mut Option<SavedCache>) -> R,

Runs update_fn with mutable access to the stored Option<SavedCache> under the mutex. Returns the closure’s result after releasing the mutex, allowing removed caches to be dropped outside the lock.

Drop extra SavedCache or ExecutionCache clones of the stored cache before the closure returns: Self::get_cache_for requires that cache’s Arc strong reference count to be one.

CRITICAL SAFETY REQUIREMENT

Before calling this method, you MUST ensure there are no other active cache users. This includes:

• No running prewarming task instances that could write to the cache
• No concurrent transactions that might access the cached state
• All prewarming operations must be completed or cancelled

Violating this requirement can result in cache corruption, incorrect state data, and potential consensus failures.

Trait Implementations

impl Clone for PayloadExecutionCache

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PayloadExecutionCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PayloadExecutionCache

fn default() -> Self

Returns the “default value” for a type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 40 bytes