Struct Plan 

pub struct Plan {
    pub period: i64,
    pub latency: i64,
    pub policy: Cuts,
    pub stage: Vec<i64>,
    pub registers: BTreeMap<usize, i64>,
    pub bits: i64,
}

A pipeline: each node’s stage, and the registers each net bit carries.

Fields

period: i64

latency: i64

policy: Cuts

stage: Vec<i64>

Each node’s stage: the registers between the inputs and it.

registers: BTreeMap<usize, i64>

The net bits that carry registers, with how many, by node.

bits: i64

The register bits in all, the least any pipeline of this period and latency needs.

Implementations

impl Plan

pub fn with_outputs_registered(&self, graph: &TimingGraph) -> Plan

The same pipeline a clock longer, every output net carrying one more register past the last stage: its outputs read straight from registers. A pipeline whose outputs are registers is one a clock shorter with them added, so of those, this has the fewest bits.

pub fn cuts(&self, graph: &TimingGraph) -> Vec<(String, i64, Vec<usize>)>

The registers by net, its bits gathered: each net’s name, and for each register count the bits carrying it.

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Plan

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

Formats the value using the given formatter.

impl PartialEq for Plan

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

impl StructuralPartialEq for Plan