Struct PipelineSchedule 

pub struct PipelineSchedule {
    pub stage: Vec<usize>,
    pub result: usize,
    pub budget: f64,
    pub inputs: Inputs,
}

Where every op of a residual computes, and which op leaves the pipeline.

Fields

stage: Vec<usize>

The stage of each op; wiring carries its operands’ stage.

result: usize

budget: f64

The per-stage depth budget the schedule was cut to, in the units of op_delay.

inputs: Inputs

Where stage 0 reads the inputs.

Implementations

impl PipelineSchedule

pub fn stages(&self) -> usize

The register boundaries between the inputs and the output register, plus one.

pub fn latency(&self) -> usize

Clocks from presenting an input to its result on the output register: the input register when there is one, the boundaries between stages, and the output register.

pub fn reading(self, inputs: Inputs) -> PipelineSchedule

The same stages, reading the inputs from inputs.

pub fn stage_depth(&self, ops: &[FabricOp]) -> f64

The deepest path inside any one stage of the emitted pipeline, in the units of op_delay: a value read in its own stage arrives when it is computed, and a value read in a later stage arrives from a register at depth zero. Ops the result does not need are never emitted and never counted.

pub fn check(&self, ops: &[FabricOp]) -> Result<(), String>

The schedule respects dataflow: no op computes before an operand, and wiring sits in its operands’ stage.

impl PipelineSchedule

pub fn register_bits(&self, ops: &[FabricOp]) -> u64

The live bits the emitted pipeline’s registers hold: each input register, each value’s live bits once per stage it is delayed across, and the result register’s live bits.

pub fn register_words(&self, ops: &[FabricOp]) -> usize

The 64-bit registers the emitted pipeline holds: one per input when it registers them, one per stage each value is delayed across, and the result register.

Trait Implementations

impl Clone for PipelineSchedule

fn clone(&self) -> PipelineSchedule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PipelineSchedule

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

Formats the value using the given formatter.

impl PartialEq for PipelineSchedule

fn eq(&self, other: &PipelineSchedule) -> 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 StructuralPartialEq for PipelineSchedule