Struct ParNodes

pub struct ParNodes {
    pub group_name: Id,
    pub latency: u64,
    pub num_repeats: u64,
    pub threads: Vec<(Node, (u64, u64))>,
}

Represents a group of Nodes that execute in parallel.

Fields

group_name: Id

Name of the par_group that fires off the threads

latency: u64

Latency

num_repeats: u64

Num Repeats

threads: Vec<(Node, (u64, u64))>

(Thread, interval thread is active). Interval thread is active should always start at 0.

Implementations

impl ParNodes

pub fn instantiate_fsms( &mut self, builder: &mut Builder<'_>, coloring: &HashMap<Id, Id>, colors_to_max_values: &HashMap<Id, (u64, u64)>, colors_to_fsm: &mut HashMap<Id, (Option<RRC<StaticFSM>>, Option<RRC<StaticFSM>>)>, one_hot_cutoff: u64, )

Instantiates FSMs by recursively instantiating FSM for each thread.

pub fn count_to_n( &mut self, builder: &mut Builder<'_>, incr_start_cond: Option<Guard<Nothing>>, )

Counts to N by recursively calling count_to_n on each thread.

pub fn realize( &mut self, ignore_timing_guards: bool, static_groups: &Vec<RRC<StaticGroup>>, reset_early_map: &mut HashMap<Id, Id>, fsm_info_map: &mut HashMap<Id, (Id, Guard<Nothing>, Guard<Nothing>)>, group_rewrites: &mut PortRewriteMap, builder: &mut Builder<'_>, )

Realizes static groups into dynamic group.

pub fn get_longest_node(&mut self) -> &mut SingleNode

Recursively searches each thread to get the longest (in terms of cycle counts) SingleNode.

pub fn query_between( &mut self, query: (u64, u64), builder: &mut Builder<'_>, ) -> Guard<Nothing>

Use the longest node to query between.

impl ParNodes

Used to add conflicts for graph coloring for sharing FSMs. See the equivalent SingleNode implementation for more details.

pub fn get_all_nodes(&self) -> Vec<Id>

pub fn add_conflicts(&self, conflict_graph: &mut GraphColoring<Id>)

pub fn get_max_value<F>(&self, name: &Id, f: &F) -> u64

where F: Fn(&SingleNode) -> u64,