cmtc 0.1.2

The cmtc compiler providing cmtir-based passes to generate backends including FIRRTL, SystemVerilog and simulators.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::collections::HashSet;

use super::*;

/// MethodRelInferPass
/// NOTE: must be run after SetPrivatePass
/// should get methodrels including SA and SB from schedules
/// for example, schedule [method m0, method m1] indicates m0 SA m1
/// also, from the opposite direction, SA/SB methodrels should also indicate the
/// schedule for example, m0 SA m1 indicates schedule [m0, m1]
pub struct MethodRelInferPass {}

impl MethodRelInferPass {
  pub fn new() -> Self {
    Self {}
  }
}

impl Visitor for MethodRelInferPass {
  fn name() -> &'static str {
    "methodrel_infer"
  }

  fn after_visit_rules(
    &mut self,
    data: &mut VisitorData,
  ) -> anyhow::Result<()> {
    // first, use methodrels to indicate schedule
    let mut new_schedules = vec![];
    for methodrel in data.module.method_rels() {
      match methodrel {
        ir::RuleRel::Method {
          rel: ir::MethodRel::SA,
          lhs: m0s,
          rhs: m1s,
        } => {
          for m0 in m0s {
            for m1 in m1s {
              new_schedules.push(vec![m0.clone(), m1.clone()]);
            }
          }
        }
        ir::RuleRel::Method {
          rel: ir::MethodRel::SB,
          lhs: m0s,
          rhs: m1s,
        } => {
          for m0 in m0s {
            for m1 in m1s {
              new_schedules.push(vec![m1.clone(), m0.clone()]);
            }
          }
        }
        _ => {}
      }
    }

    for schedule in new_schedules {
      data.module.add_schedule(schedule);
    }

    // next extract exisiting public methods, and use the schedules to sort them
    let public_methods = data
      .module
      .rules()
      .filter_map(|rule| {
        if !rule.is_private() && rule.is_method() {
          Some(ir::InstRule::new(vec![rule.name.clone()]).canonicalize())
        } else {
          None
        }
      })
      .collect::<Vec<_>>();

    let mut public_method_set =
      public_methods.clone().into_iter().collect::<HashSet<_>>();

    let public_methods = data.schedule_rules(public_methods)?;

    // remove all method-only schedules
    data.module.rule_rels.retain(|rule_rel| match rule_rel {
      &ir::RuleRel::Schedule(ref schedule) => {
        schedule.iter().any(|inst_rule| {
          !public_method_set.contains(&inst_rule.canonicalize())
        })
      }
      _ => true,
    });

    // add a new schedule due to public_methods_with_idx
    data.module.add_schedule(public_methods.clone());

    // add new rule_x C rule_x for all rule_x with any inputs
    let mut rules_with_inputs = vec![];
    for rule in data.module.rules() {
      if rule.inputs().len() > 0 {
        rules_with_inputs.push(rule.name.clone());
      }
    }

    for rule_name in rules_with_inputs {
      data.module.add_rule_rel(ir::RuleRel::Method {
        rel: ir::MethodRel::C,
        lhs: vec![InstRule::new(vec![rule_name.clone()]).canonicalize()],
        rhs: vec![InstRule::new(vec![rule_name.clone()]).canonicalize()],
      });
    }

    log::debug!(
      "after methodrel infer:\n\t{}",
      data
        .module
        .rule_rels()
        .map(|r| r.ir_dump())
        .collect::<Vec<_>>()
        .join("\n\t")
    );
    Ok(())
  }
}