Struct massa_execution_worker::slot_sequencer::SlotSequencer

pub struct SlotSequencer {
    config: ExecutionConfig,
    sequence: VecDeque<SlotInfo>,
    latest_consensus_final_slots: Vec<Slot>,
    latest_execution_final_slot: Slot,
    latest_executed_final_slot: Slot,
    latest_executed_candidate_slot: Slot,
}

Structure allowing execution slot sequence management.

The SlotSequencer::update method is called to notify the sequencer about blocks becoming CSS-final, about changes in the blockclique, or simply about slot ticks. The sequencer then internally sequences the slots, and prepares a queue of slots that are ready to be executed by Execution. SlotSequencer::is_task_available allows checking if a slot is ready to be executed. SlotSequencer::run_task_with allows running the next slot in the queue, if any. Note that SCE-final slots are executed in priority over candidate slots. SlotSequencer::get_next_slot_deadline allows getting the time at which the next slot will happen (this is useful to sequence slots as they happen even if there is no block there).

Fields

config: ExecutionConfig

Config

sequence: VecDeque<SlotInfo>

Continuous sequence of slots containing all the slots relevant for Execution and their current states (see SlotInfo). Oldest slot is at front.

latest_consensus_final_slots: Vec<Slot>

latest CSS-final slots (one per thread)

latest_execution_final_slot: Slot

latest SCE-final slot

latest_executed_final_slot: Slot

final slot execution cursor

latest_executed_candidate_slot: Slot

candidate slot execution cursor

Implementations

impl SlotSequencer

pub fn new(config: ExecutionConfig, final_cursor: Slot) -> Self

Create a new slot sequencer. Note that this will create a SlotSequencer with an empty internal sequence which makes it unusable until SlotSequencer::update is called a first time to feed the CSS-final blocks.

Arguments

• final_cursor: latest executed SCE-final slot. This is useful on bootstrap in particular in order to avoid re-executing previously executed slots.

fn init( &mut self, initial_consensus_final_blocks: HashMap<Slot, BlockId>, initial_blockclique: HashMap<Slot, BlockId>, blocks_metadata: PreHashMap<BlockId, ExecutionBlockMetadata>, )

Internal method that inits the sequencer. This method is called on the first call to SlotSequencer::update. It allows feeding the initial sequence of CSS-final blocks to the sequencer.

Arguments

initial_consensus_final_blocks: the list of CSS-final blocks (must not be empty) initial_blockclique: initial blockclique, usually empty except on major bootstrap latency blocks_metadata: Metadata for all the blocks referenced in initial_consensus_final_blocks and initial_blockclique

fn get_time_cursor(&self) -> Slot

Internal function allowing to get the latest slot we should execute at the current time. This is useful to fill the sequencer with slots as they happen, even if there are no blocks there.

Note that this time cursor is shifted by self.config.cursor_delay to avoid computing speculative slots that are too recent, and therefore subject to frequent re-writes.

pub fn update( &mut self, new_consensus_final_blocks: HashMap<Slot, BlockId>, new_blockclique: Option<HashMap<Slot, BlockId>>, new_blocks_metadata: PreHashMap<BlockId, ExecutionBlockMetadata>, )

Notify the sequencer of incoming changes: CSS-finalized blocks and changes in the blockclique. This function is also called on time slots to ensure new slots are taken into account even if they don’t contain a block.

Arguments

• new_consensus_final_blocks: new CSS-finalized blocks
• new_blockclique: new blockclique (if changed since the last call to this method, otherwise None)
• new_blocks_metadata: metadata for blocks that have not been seen previously by the sequencer

fn sequence_build_step( slot: Slot, prev_item: Option<SlotInfo>, new_consensus_final: bool, new_consensus_final_block: Option<BlockId>, blockclique_updated: bool, new_blockclique_block: Option<BlockId>, new_blocks_metadata: &mut PreHashMap<BlockId, ExecutionBlockMetadata>, in_execution_finality: bool, ) -> (SlotInfo, bool)

Internal method called by Self::update to construct one slot of the new slot sequence by using info about newly CSS-finalized blocks, the new blockclique (if any) and the previous state of that slot.

Arguments

• slot: the slot being constructed
• prev_item: the corresponding slot status from the old sequence, if any
• new_consensus_final: whether this slot was CSS-finalized
• new_consensus_final_block: newly CSS-finalized block at that slot, if any
• blockclique_updated: whether a new blockclique was provided when Self::update was called
• new_blockclique_block: block at that slot within the new blockclique, if any
• new_blocks_metadata: block metadata for execution
• in_execution_finality: whether the previous slot was SCE-final

Returns

A pair (SlotInfo, truncate_history: bool) where truncate_history indicates that this slot changes the content of an existing candidate slot

fn get_slot_index(&self, slot: &Slot) -> Option<usize>

Get the index of a slot in the sequence, if present, otherwise None

fn get_slot(&self, slot: &Slot) -> Option<&SlotInfo>

Gets an immutable reference to a SlotInfo, if any, otherwise None

pub fn is_task_available(&self) -> bool

Returns true if there is a queued slot that needs to be executed now.

fn cleanup_sequence(&mut self)

Clean the slot sequence by removing slots that are not useful anymore. The removed slots the ones that are strictly before the earliest executed CSS-final slot. This function is called on Self::init to cleanup bootstrap artifacts, and when a task is processed with Self::run_task_with.

pub fn run_task_with<F, T>(&mut self, callback: F) -> Option<T>

where F: Fn(bool, &Slot, Option<&(BlockId, ExecutionBlockMetadata)>) -> T,

If a slot is ready for execution, this method will mark it as executed and call the provided callback function on it for execution. SCE-final slots are executed in priority over candidate slots.

Arguments

• callback: callback function that executes the slot
  • Callback arguments:
    • a boolean indicating whether or not the slot is SCE-final
    • a reference to the slot
    • a reference to the block at that slot and its storage, if any (otherwise None)
  • Callback return value: an arbitrary T

Returns

An option that is None if there was no task to be executed, or Some(T) where T is the value returned by the callback function otherwise.

pub fn get_next_slot_deadline(&self) -> MassaTime

Gets the instant of the slot just after the latest slot in the sequence. Note that config.cursor_delay is taken into account.