Struct RandomXVmCache

pub struct RandomXVmCache {
    pub seeds: VecDeque<(usize, [u8; 32])>,
    pub vms: HashMap<usize, Arc<RandomXVm>>,
    pub cached_vm: Option<([u8; 32], Arc<RandomXVm>)>,
}

The randomX VMs cache, keeps the VM needed to calculate the current block’s proof-of-work hash (if a VM is needed) and a couple more around this VM.

Fields

seeds: VecDeque<(usize, [u8; 32])>

The top RX_SEEDS_CACHED RX seeds.

vms: HashMap<usize, Arc<RandomXVm>>

The VMs for seeds (if after hf 12, otherwise this will be empty).

cached_vm: Option<([u8; 32], Arc<RandomXVm>)>

A single cached VM that was given to us from a part of Cuprate.

Implementations

impl RandomXVmCache

pub async fn init_from_chain_height<D: Database + Clone>( chain_height: usize, hf: &HardFork, database: D, ) -> Result<Self, ContextCacheError>

pub fn add_vm(&mut self, vm: ([u8; 32], Arc<RandomXVm>))

Add a randomX VM to the cache, with the seed it was created with.

pub async fn get_alt_vm<D: Database>( &self, height: usize, chain: Chain, database: D, ) -> Result<Arc<RandomXVm>, ContextCacheError>

Creates a RX VM for an alt chain, looking at the main chain RX VMs to see if we can use one of them first.

pub async fn get_vms(&mut self) -> HashMap<usize, Arc<RandomXVm>>

Get the main-chain RandomX VMs.

pub fn pop_blocks_main_chain(&mut self, new_height: usize)

Removes all the RandomX VMs above the new_height.

pub fn new_block(&mut self, height: usize, hash: &[u8; 32])

Add a new block to the VM cache.

hash is the block hash not the blocks proof-of-work hash.

Trait Implementations

impl Clone for RandomXVmCache

fn clone(&self) -> RandomXVmCache

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RandomXVmCache

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

Formats the value using the given formatter.

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