Struct BasicBlockNode

pub struct BasicBlockNode { /* private fields */ }

Block for a linear sequence of operations (i.e., no branching or loops).

Executes its operations in order. Fails if any of the operations fails.

A basic block is composed of operation batches, operation batches are composed of operation groups, operation groups encode the VM’s operations and immediate values. These values are created according to these rules:

• A basic block contains one or more batches.
• A batch contains exactly 8 groups.
• A group contains exactly 9 operations or 1 immediate value.
• NOOPs are used to fill a group or batch when necessary.
• An immediate value follows the operation that requires it, using the next available group in the batch. If there are no batches available in the group, then both the operation and its immediate are moved to the next batch.

Example: 8 pushes result in two operation batches:

• First batch: First group with 7 push opcodes and 2 zero-paddings packed together, followed by 7 groups with their respective immediate values.
• Second batch: First group with the last push opcode and 8 zero-paddings packed together, followed by one immediate and 6 padding groups.

The hash of a basic block is:

hash(batches, domain=BASIC_BLOCK_DOMAIN)

Where batches is the concatenation of each batch in the basic block, and each batch is 8 field elements (512 bits).

Implementations

impl BasicBlockNode

Constants

pub const DOMAIN: BaseElement = ZERO

The domain of the basic block node (used for control block hashing).

impl BasicBlockNode

Constructors

pub fn new( operations: Vec<Operation>, decorators: Option<Vec<(usize, DecoratorId)>>, ) -> Result<BasicBlockNode, MastForestError>

Returns a new BasicBlockNode instantiated with the specified operations and decorators.

Returns an error if:

• operations vector is empty.

pub fn new_unsafe( operations: Vec<Operation>, decorators: Vec<(usize, DecoratorId)>, digest: RpoDigest, ) -> BasicBlockNode

Returns a new BasicBlockNode from values that are assumed to be correct. Should only be used when the source of the inputs is trusted (e.g. deserialization).

impl BasicBlockNode

Public accessors

pub fn digest(&self) -> RpoDigest

Returns a commitment to this basic block.

pub fn op_batches(&self) -> &[OpBatch]

Returns a reference to the operation batches in this basic block.

pub fn num_op_batches(&self) -> usize

Returns the number of operation batches in this basic block.

pub fn num_op_groups(&self) -> usize

Returns the total number of operation groups in this basic block.

Then number of operation groups is computed as follows:

• For all batches but the last one we set the number of groups to 8, regardless of the actual number of groups in the batch. The reason for this is that when operation batches are concatenated together each batch contributes 8 elements to the hash.
• For the last batch, we take the number of actual groups and round it up to the next power of two. The reason for rounding is that the VM always executes a number of operation groups which is a power of two.

pub fn num_operations(&self) -> u32

Returns the number of operations in this basic block.

pub fn decorators(&self) -> &Vec<(usize, DecoratorId)>

Returns a list of decorators in this basic block node.

Each decorator is accompanied by the operation index specifying the operation prior to which the decorator should be executed.

pub fn decorator_iter(&self) -> DecoratorIterator<'_>

Returns a DecoratorIterator which allows us to iterate through the decorator list of this basic block node while executing operation batches of this basic block node.

pub fn operations(&self) -> impl Iterator<Item = &Operation>

Returns an iterator over the operations in the order in which they appear in the program.

pub fn num_operations_and_decorators(&self) -> u32

Returns the total number of operations and decorators in this basic block.

pub fn iter(&self) -> impl Iterator<Item = OperationOrDecorator<'_>>

Returns an iterator over all operations and decorator, in the order in which they appear in the program.

impl BasicBlockNode

Mutators

pub fn prepend_decorators(&mut self, decorator_ids: &[DecoratorId])

Sets the provided list of decorators to be executed before all existing decorators.

pub fn append_decorators(&mut self, decorator_ids: &[DecoratorId])

Sets the provided list of decorators to be executed after all existing decorators.

pub fn set_decorators(&mut self, decorator_list: Vec<(usize, DecoratorId)>)

Used to initialize decorators for the BasicBlockNode. Replaces the existing decorators with the given [‘DecoratorList’].

Trait Implementations

impl Clone for BasicBlockNode

fn clone(&self) -> BasicBlockNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BasicBlockNode

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

Formats the value using the given formatter.

impl MastNodeExt for BasicBlockNode

fn decorators(&self) -> impl Iterator<Item = (usize, DecoratorId)>

The list of decorators tied to this node, along with their associated index.

fn get_assembly_op<'m>( &self, mast_forest: &'m MastForest, target_op_idx: Option<usize>, ) -> Option<&'m AssemblyOp>

Returns the AssemblyOp associated with this node and operation (if provided), if any.

impl PartialEq for BasicBlockNode

fn eq(&self, other: &BasicBlockNode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for BasicBlockNode

impl StructuralPartialEq for BasicBlockNode