Struct FSMGenPass

pub struct FSMGenPass {
    pub fsm_cnt: usize,
    pub step_cnt: usize,
    pub seq_cnt: usize,
    pub par_cnt: usize,
    pub branch_cnt: usize,
    pub for_cnt: usize,
    pub pipeline_cnt: usize,
    pub cur_module_name: String,
    pub cfs: Vec<(Vec<InstRule>, Vec<InstRule>)>,
    pub gen_modules: Vec<Module>,
    pub top_fsms: Vec<String>,
}

Fields

fsm_cnt: usize

step_cnt: usize

seq_cnt: usize

par_cnt: usize

branch_cnt: usize

for_cnt: usize

pipeline_cnt: usize

cur_module_name: String

cfs: Vec<(Vec<InstRule>, Vec<InstRule>)>

gen_modules: Vec<Module>

top_fsms: Vec<String>

Implementations

impl FSMGenPass

pub fn new() -> Self

pub fn visit_step(&mut self, step: &BodyOp) -> FSMRet

pub fn visit_seq(&mut self, seq: &BodyOp) -> FSMRet

pub fn visit_par(&mut self, par: &ParOp) -> FSMRet

pub fn visit_branch(&mut self, branch: &BranchOp) -> FSMRet

pub fn visit_for(&mut self, for_op: &ForOp) -> FSMRet

pub fn visit_pipeline(&mut self, ops: &Vec<Op>) -> FSMRet

pub fn visit_op(&mut self, op: &Op) -> FSMRet

pub fn gen_rules( &mut self, fsm: FSMRet, data: &mut VisitorData<'_>, fsm_rule: Rule, ) -> Vec<Rule>

Trait Implementations

impl Visitor for FSMGenPass

fn skip_tb() -> bool

tb module should have no fsm

fn name() -> &'static str

fn before_visit_rules(&mut self, data: &mut VisitorData<'_>) -> Result<()>

fn visit_rule_impl( &mut self, data: &mut VisitorData<'_>, ) -> Result<(Vec<Rule>, Vec<RuleRel>), Error>

fn after_visit_rules(&mut self, data: &mut VisitorData<'_>) -> Result<()>

fn after_pass(&mut self, circuit: &mut Circuit) -> Result<()>

fn filter_item<'a, T>( items: impl Iterator<Item = T>, filter_fn: impl Fn(&T) -> bool, ) -> Vec<T>

fn filter_op<'a>( ops: impl Iterator<Item = &'a Op>, filter_fn: impl Fn(&Op) -> bool, ) -> Vec<&'a Op>

fn flatten_op<'a>(op: &'a Op) -> Vec<&'a Op>

fn flatten_ops<'a>(ops: impl Iterator<Item = &'a Op>) -> Vec<&'a Op>

fn filter_map<'a, T: Clone + 'a, P>( items: impl Iterator<Item = &'a T>, filter_fn: impl Fn(&T) -> Option<P>, ) -> (Vec<P>, HashMap<usize, usize>)

fn dump_results(&self, data: &mut VisitorData<'_>)

fn visit_op_impl( &mut self, op: &mut Op, data: &mut VisitorData<'_>, ) -> Result<(), Error>

fn visit_op( &mut self, op: &mut Op, data: &mut VisitorData<'_>, ) -> Result<(), Error>

fn visit_rule_prelog( &mut self, rule: &Rule, data: &mut VisitorData<'_>, ) -> Result<(), Error>

fn visit_rule_guard(&mut self, data: &mut VisitorData<'_>) -> Result<(), Error>

fn visit_rule( &mut self, rule: Rule, data: &mut VisitorData<'_>, ) -> Result<(Vec<Rule>, Vec<RuleRel>), Error>

fn topo_sort_rules<'a, T: Clone + Debug>( rules: impl Iterator<Item = &'a Rule> + Clone, f: impl Fn(usize, &'a Rule) -> (String, T), ) -> Vec<T>

fn get_rules_in_topo_order(&mut self, data: &mut VisitorData<'_>) -> Vec<Rule>

this is very dangerous to use in get_rules_in_order, since the topo order doesn’t guarentee any original order

fn get_rules_in_order(&mut self, data: &mut VisitorData<'_>) -> Vec<Rule>

fn infer_rule_relations( &mut self, data: &mut VisitorData<'_>, ) -> Result<(), Error>

fn prepare_visit_module_impl( &mut self, data: &mut VisitorData<'_>, ) -> Result<(), Error>

fn prepare_visit_module(&mut self, data: VisitorData<'_>) -> Result<(), Error>

fn visit_module(&mut self, data: VisitorData<'_>) -> Result<(), Error>

fn pass_prelog(&mut self, circuit: &mut Circuit) -> Result<(), Error>

fn visit_function( &mut self, function: &mut Function, circuit: &mut Circuit, ) -> Result<(), Error>

fn after_visit_modules(&mut self, circuit: &mut Circuit) -> Result<(), Error>

fn apply_pass(&mut self, circuit: &mut Circuit) -> Result<(), Error>

apply the pass to the every module in the circuit