Struct LoadedPrograms

pub struct LoadedPrograms<FG: ForkGraph> {
    pub latest_root_slot: Slot,
    pub latest_root_epoch: Epoch,
    pub environments: ProgramRuntimeEnvironments,
    pub upcoming_environments: Option<ProgramRuntimeEnvironments>,
    pub programs_to_recompile: Vec<(Pubkey, Arc<LoadedProgram>)>,
    pub stats: Stats,
    pub fork_graph: Option<Arc<RwLock<FG>>>,
    pub loading_task_waiter: Arc<LoadingTaskWaiter>,
    /* private fields */
}

Fields

latest_root_slot: Slot

The slot of the last rerooting

latest_root_epoch: Epoch

The epoch of the last rerooting

environments: ProgramRuntimeEnvironments

Environments of the current epoch

upcoming_environments: Option<ProgramRuntimeEnvironments>

Anticipated replacement for environments at the next epoch

This is None during most of an epoch, and only Some around the boundaries (at the end and beginning of an epoch). More precisely, it starts with the recompilation phase a few hundred slots before the epoch boundary, and it ends with the first rerooting after the epoch boundary.

programs_to_recompile: Vec<(Pubkey, Arc<LoadedProgram>)>

List of loaded programs which should be recompiled before the next epoch (but don’t have to).

stats: Stats

fork_graph: Option<Arc<RwLock<FG>>>

loading_task_waiter: Arc<LoadingTaskWaiter>

Implementations

impl<FG: ForkGraph> LoadedPrograms<FG>

pub fn new(root_slot: Slot, root_epoch: Epoch) -> Self

pub fn set_fork_graph(&mut self, fork_graph: Arc<RwLock<FG>>)

pub fn get_environments_for_epoch( &self, epoch: Epoch, ) -> &ProgramRuntimeEnvironments

Returns the current environments depending on the given epoch

pub fn get_upcoming_environments_for_epoch( &self, epoch: Epoch, ) -> Option<ProgramRuntimeEnvironments>

Returns the upcoming environments depending on the given epoch

pub fn assign_program(&mut self, key: Pubkey, entry: Arc<LoadedProgram>) -> bool

Insert a single entry. It’s typically called during transaction loading, when the cache doesn’t contain the entry corresponding to program key.

pub fn prune_by_deployment_slot(&mut self, slot: Slot)

pub fn prune(&mut self, new_root_slot: Slot, new_root_epoch: Epoch)

Before rerooting the blockstore this removes all superfluous entries

pub fn extract( &mut self, search_for: &mut Vec<(Pubkey, (LoadedProgramMatchCriteria, u64))>, loaded_programs_for_tx_batch: &mut LoadedProgramsForTxBatch, is_first_round: bool, ) -> Option<(Pubkey, u64)>

Extracts a subset of the programs relevant to a transaction batch and returns which program accounts the accounts DB needs to load.

pub fn finish_cooperative_loading_task( &mut self, slot: Slot, key: Pubkey, loaded_program: Arc<LoadedProgram>, ) -> bool

Called by Bank::replenish_program_cache() for each program that is done loading.

pub fn merge(&mut self, tx_batch_cache: &LoadedProgramsForTxBatch)

pub fn get_flattened_entries( &self, include_program_runtime_v1: bool, include_program_runtime_v2: bool, ) -> Vec<(Pubkey, Arc<LoadedProgram>)>

Returns the list of loaded programs which are verified and compiled.

pub fn sort_and_unload(&mut self, shrink_to: PercentageInteger)

Unloads programs which were used infrequently

pub fn evict_using_2s_random_selection( &mut self, shrink_to: PercentageInteger, now: Slot, )

Evicts programs using 2’s random selection, choosing the least used program out of the two entries. The eviction is performed enough number of times to reduce the cache usage to the given percentage.

pub fn remove_programs(&mut self, keys: impl Iterator<Item = Pubkey>)

Removes all the entries at the given keys, if they exist

pub fn get_slot_versions_for_tests(&self, key: &Pubkey) -> &[Arc<LoadedProgram>]

Returns the slot_versions of the second level for the given program id.

pub fn unload_all_programs(&mut self)

Trait Implementations

impl<FG: ForkGraph> AbiExample for LoadedPrograms<FG>

fn example() -> Self

impl<FG: ForkGraph> Debug for LoadedPrograms<FG>

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

Formats the value using the given formatter.