Struct BasicBlock 

pub struct BasicBlock<'p> { /* private fields */ }

Implementations

impl<'p> BasicBlock<'p>

pub fn label(&self) -> Option<&'p Target>

pub fn instruction_index_offset(&self) -> usize

pub fn instructions(&self) -> &[&'p Instruction]

pub fn terminator(&self) -> &BasicBlockTerminator<'p>

pub fn as_schedule_seconds( &self, program: &Program, ) -> Result<Schedule<Seconds>, BasicBlockScheduleError>

Compute the flattened schedule for this BasicBlock in terms of seconds, using a default built-in calculation for the duration of scheduled instructions. See [BasicBlockOwned::as_schedule].

Arguments

• program - The program containing this basic block. This is used to retrieve frame and calibration information. Generally, this should be the program from which the block was extracted.

How it Works

• Expanding each instruction within the block using the program’s calibration definitions
• Resolving the ScheduleSeconds of the expanded instructions
• Mapping calibrated instructions back to the original instructions within this block, such that the block’s instruction is represented as a timespan encompassing all of its expanded instructions

Notes

If the basic block contains gates, the program must contain corresponding DEFCALs for those gates. Gates do not inherently have durations, but rather inherit them from the PULSE, CAPTURE, DELAY, and other instructions within their calibrations. Without a calibration, a gate’s duration cannot be computed.

Python Example

For Python users, the following example demonstrates construction of such a schedule for a simple program without explicit control flow (and thus with only one basic block):

from quil.program import Program

program = Program.parse("CZ 0 1; CZ 0 2")
print(program.to_quil())

control_flow_graph = program.control_flow_graph()
assert control_flow_graph.has_dynamic_control_flow() == False

basic_blocks = control_flow_graph.basic_blocks()
assert len(basic_blocks) == 1

schedule = blocks[0].as_schedule_seconds(program)
print(f"Duration = {schedule.duration()}")
print(schedule.items())

pub fn as_schedule<F, Time>( &self, program: &'p Program, get_duration: F, ) -> Result<Schedule<Time>, BasicBlockScheduleError>

where F: Fn(&Program, &Instruction) -> Option<Time>, Time: Clone + Debug + PartialOrd + Add<Time, Output = Time> + Sub<Time, Output = Time> + Zero,

Compute the schedule for this BasicBlock in terms of a generic unit of time, using a provided function to calculate the duration of scheduled instructions in that unit.

Arguments

• program - The program containing this basic block. This is used to retrieve frame and calibration information.
• get_duration - A function that takes a program and an instruction and returns the duration of the instruction in the desired time unit, or None if the instruction’s duration is not known.

Note: when an instruction is expanded, the “time” of that original instruction includes the times of all of the resulting instructions. This may cause gate times to be longer than a user might expect.

To understand why, consider a program like this:

# One-qubit frame
DEFFRAME 0 "a":
    ATTRIBUTE: 1

# Two-qubit frame
DEFFRAME 0 1 "b":
    ATTRIBUTE: 1

DEFCAL A 0:
    PULSE 0 "a" flat(duration: 1.0)

DEFCAL B 0 1:
    FENCE 1
    PULSE 0 1 "b" flat(duration: 1.0)

A 0
B 0 1

B 0 will be scheduled from time 0 to time 2, because its inner FENCE is scheduled for time 0. This may be unexpected if the user expects to see only the timing of the inner PULSE.

Trait Implementations

impl<'p> Clone for BasicBlock<'p>

fn clone(&self) -> BasicBlock<'p>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'p> Debug for BasicBlock<'p>

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

Formats the value using the given formatter.

impl<'p> Default for BasicBlock<'p>

fn default() -> BasicBlock<'p>

Returns the “default value” for a type.

impl<'b> From<&'b BasicBlockOwned> for BasicBlock<'b>

fn from(value: &'b BasicBlockOwned) -> Self

Converts to this type from the input type.

impl From<BasicBlock<'_>> for BasicBlockOwned

fn from(value: BasicBlock<'_>) -> Self

Converts to this type from the input type.

impl<'a> TryFrom<&BasicBlock<'a>> for QubitGraph<'a>

type Error = QubitGraphError

The type returned in the event of a conversion error.

fn try_from(block: &BasicBlock<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a Program> for BasicBlock<'a>

type Error = ProgramEmptyOrContainsMultipleBasicBlocks

The type returned in the event of a conversion error.

fn try_from(value: &'a Program) -> Result<Self, Self::Error>

Performs the conversion.