Struct InMemoryBlockStates

pub struct InMemoryBlockStates {
    states: B256HashMap<StateDb>,
    on_disk_states: B256HashMap<StateDb>,
    in_memory_limit: usize,
    min_in_memory_limit: usize,
    max_on_disk_limit: usize,
    oldest_on_disk: VecDeque<B256>,
    present: VecDeque<B256>,
    disk_cache: DiskStateCache,
}

Represents the complete state of single block

Fields

states: B256HashMap<StateDb>

The states at a certain block

on_disk_states: B256HashMap<StateDb>

states which data is moved to disk

in_memory_limit: usize

How many states to store at most

min_in_memory_limit: usize

minimum amount of states we keep in memory

max_on_disk_limit: usize

maximum amount of states we keep on disk

Limiting the states will prevent disk blow up, especially in interval mining mode

oldest_on_disk: VecDeque<B256>

the oldest states written to disk

present: VecDeque<B256>

all states present, used to enforce in_memory_limit

disk_cache: DiskStateCache

Stores old states on disk

Implementations

impl InMemoryBlockStates

pub fn new(in_memory_limit: usize, on_disk_limit: usize) -> Self

Creates a new instance with limited slots

pub fn memory_only(self) -> Self

Configures no disk caching

pub fn disk_path(self, path: PathBuf) -> Self

Configures the path on disk where the states will cached.

pub fn update_interval_mine_block_time(&mut self, block_time: Duration)

This modifies the limit what to keep stored in memory.

This will ensure the new limit adjusts based on the block time. The lowest blocktime is 1s which should increase the limit slightly

fn is_memory_only(&self) -> bool

Returns true if only memory caching is supported.

pub fn insert(&mut self, hash: B256, state: StateDb)

Inserts a new (hash -> state) pair

When the configured limit for the number of states that can be stored in memory is reached, the oldest state is removed.

Since we keep a snapshot of the entire state as history, the size of the state will increase with the transactions processed. To counter this, we gradually decrease the cache limit with the number of states/blocks until we reached the min_limit.

When a state that was previously written to disk is requested, it is simply read from disk.

fn enforce_limits(&mut self)

Enforces configured limits

pub fn get(&mut self, hash: &B256) -> Option<&StateDb>

Returns the state for the given hash if present

pub fn set_cache_limit(&mut self, limit: usize)

Sets the maximum number of stats we keep in memory

pub fn clear(&mut self)

Clears all entries

pub fn serialized_states(&mut self) -> SerializableHistoricalStates

Serialize all states to a list of serializable historical states

pub fn load_states(&mut self, states: SerializableHistoricalStates)

Load states from serialized data

Trait Implementations

impl Debug for InMemoryBlockStates

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

Formats the value using the given formatter.

impl Default for InMemoryBlockStates

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: 216 bytes