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 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
use crate::traversal::{Action, Named, VisResult, Visitor};
use calyx_ir as ir;
use calyx_ir::structure;
use calyx_ir::LibrarySignatures;
use ir::build_assignments;
use std::rc::Rc;
#[derive(Default)]
pub struct StaticInliner;
impl Named for StaticInliner {
fn name() -> &'static str {
"static-inline"
}
fn description() -> &'static str {
"Compiles Static Control into a single Static Enable"
}
}
impl StaticInliner {
// updates single assignment in the same way `update_assignments_timing` does
// adds offset to each timing guard in `assigns`
// e.g., %[2,3] with offset = 2 -> %[4,5]
// all guards also must update so that guard -> guard & %[offset, offset+latency] since that
// is when the group will be active in the control, i.e., dst = guard ? src
// becomes dst = guard & %[offset, offset+latency] ? src
fn update_assignment_timing(
assign: &mut ir::Assignment<ir::StaticTiming>,
offset: u64,
latency: u64,
) {
// adding the offset to each timing interval
assign.for_each_interval(|timing_interval| {
let (beg, end) = timing_interval.get_interval();
Some(ir::Guard::Info(ir::StaticTiming::new((
beg + offset,
end + offset,
))))
});
// adding the interval %[offset, offset + latency]
assign
.guard
.add_interval(ir::StaticTiming::new((offset, offset + latency)));
}
// calls update_assignment_timing on each assignment in assigns, which does the following:
// adds offset to each timing guard in `assigns`
// e.g., %[2,3] with offset = 2 -> %[4,5]
// all guards also must update so that guard -> guard & %[offset, offset+latency] since that
// is when the group will be active in the control, i.e., dst = guard ? src
// becomes dst = guard & %[offset, offset+latency] ? src
fn update_assignments_timing(
assigns: &mut Vec<ir::Assignment<ir::StaticTiming>>,
offset: u64,
latency: u64,
) {
for assign in assigns {
Self::update_assignment_timing(assign, offset, latency);
}
}
// Makes assignments such that if branches can start executing on the first
// possible cycle.
// essentially, on the first cycle, we write port's value into a `cond` = a register.
// this is because the tru/false branch might alter port's value when it executes
// cond_wire reads from port on the first cycle, and then cond for the other cycles.
// this means that all of the tru branch assigns can get the cond_wire ? in front of them,
// and all false branch assigns can get !cond_wire ? in front of them
// makes the following assignments:
// read more here: https://github.com/cucapra/calyx/issues/1344 (specifically
// the section "Conditionl")
fn make_cond_assigns(
cond: ir::RRC<ir::Cell>,
cond_wire: ir::RRC<ir::Cell>,
port: ir::RRC<ir::Port>,
latency: u64,
builder: &mut ir::Builder,
) -> Vec<ir::Assignment<ir::StaticTiming>> {
structure!( builder;
let signal_on = constant(1,1);
);
let mut cond_assigns = vec![];
let cycle_0_guard = ir::Guard::Info(ir::StaticTiming::new((0, 1)));
// = %[1:latency] ?
let other_cycles_guard =
ir::Guard::Info(ir::StaticTiming::new((1, latency)));
// cond.in = port
let cond_gets_port = builder.build_assignment(
cond.borrow().get("in"),
Rc::clone(&port),
ir::Guard::True,
);
// cond_wire.in = %0 ? port
let cond_wire_gets_port = builder.build_assignment(
cond_wire.borrow().get("in"),
port,
cycle_0_guard.clone(),
);
cond_assigns.push(cond_gets_port);
cond_assigns.push(cond_wire_gets_port);
let asgns = build_assignments!(builder;
// cond.write_en = %0 ? 1'd1 (since we also have cond.in = %0 ? port)
// cond_wire.in = %[1:latency] ? cond.out (since we also have cond_wire.in = %0 ? port)
cond["write_en"] = cycle_0_guard ? signal_on["out"];
cond_wire["in"] = other_cycles_guard ? cond["out"];
);
cond_assigns.extend(asgns.to_vec());
cond_assigns
}
// inlines the static control `sc` and returns an equivalent single static group
fn inline_static_control(
sc: &ir::StaticControl,
builder: &mut ir::Builder,
) -> ir::RRC<ir::StaticGroup> {
match sc {
ir::StaticControl::Enable(ir::StaticEnable { group, .. }) => {
Rc::clone(group)
}
ir::StaticControl::Seq(ir::StaticSeq {
stmts,
latency,
attributes,
}) => {
let seq_group =
builder.add_static_group("static_seq", *latency);
let mut seq_group_assigns: Vec<
ir::Assignment<ir::StaticTiming>,
> = vec![];
let mut cur_offset = 0;
for stmt in stmts {
let stmt_latency = stmt.get_latency();
// first recursively call each stmt in seq, and turn each stmt
// into static group g.
let g = StaticInliner::inline_static_control(stmt, builder);
assert!(
g.borrow().get_latency() == stmt_latency,
"static group latency doesn't match static stmt latency"
);
// get the assignments from g
// currently we clone, since we might need these assignments elsewhere
// We could probably do some sort of analysis to see when we need to
// clone vs. can drain
let mut g_assigns: Vec<ir::Assignment<ir::StaticTiming>> =
g.borrow_mut().assignments.clone();
// add cur_offset to each static guard in g_assigns
// and add %[offset, offset + latency] to each assignment in
// g_assigns
StaticInliner::update_assignments_timing(
&mut g_assigns,
cur_offset,
stmt_latency,
);
// add g_assigns to seq_group_assigns
seq_group_assigns.extend(g_assigns.into_iter());
// updates cur_offset so that next stmt gets its static timign
// offset appropriately
cur_offset += stmt_latency;
}
assert!(
*latency == cur_offset,
"static group latency doesn't match static seq latency"
);
seq_group.borrow_mut().assignments = seq_group_assigns;
seq_group.borrow_mut().attributes = attributes.clone();
seq_group
}
ir::StaticControl::Par(ir::StaticPar {
stmts,
latency,
attributes,
}) => {
let par_group =
builder.add_static_group("static_par", *latency);
let mut par_group_assigns: Vec<
ir::Assignment<ir::StaticTiming>,
> = vec![];
for stmt in stmts {
let stmt_latency = stmt.get_latency();
// recursively turn each stmt in the par block into a group g
let g = StaticInliner::inline_static_control(stmt, builder);
assert!(
g.borrow().get_latency() == stmt_latency,
"static group latency doesn't match static stmt latency"
);
// get the assignments from g
// see note on the StaticControl::Seq(..) case abt why we need to clone
let mut g_assigns: Vec<ir::Assignment<ir::StaticTiming>> =
g.borrow_mut().assignments.clone();
// offset = 0 (all start at beginning of par),
// but still should add %[0:stmt_latency] to beginning of group
StaticInliner::update_assignments_timing(
&mut g_assigns,
0,
stmt_latency,
);
// add g_assigns to par_group_assigns
par_group_assigns.extend(g_assigns.into_iter());
}
par_group.borrow_mut().assignments = par_group_assigns;
par_group.borrow_mut().attributes = attributes.clone();
par_group
}
ir::StaticControl::If(ir::StaticIf {
port,
tbranch,
fbranch,
latency,
attributes,
}) => {
let if_group = builder.add_static_group("static_if", *latency);
let mut if_group_assigns: Vec<
ir::Assignment<ir::StaticTiming>,
> = vec![];
structure!( builder;
let cond = prim std_reg(port.borrow().width);
let cond_wire = prim std_wire(port.borrow().width);
);
// build_cond_assigns makes assigns such that
// cond_wire.in can guard all of the tru branch assigns,
// and !cond_wire.in can guard all fo the false branch assigns x
let cond_assigns = StaticInliner::make_cond_assigns(
Rc::clone(&cond),
Rc::clone(&cond_wire),
Rc::clone(port),
*latency,
builder,
);
if_group_assigns.extend(cond_assigns.to_vec());
let tbranch_latency = tbranch.get_latency();
let fbranch_latency = fbranch.get_latency();
let max_latency =
std::cmp::max(tbranch_latency, fbranch_latency);
assert_eq!(max_latency, *latency, "if group latency and max of the if branch latencies do not match");
// turn tbranch into group and put assigns into tgroup_assigns
let tgroup =
StaticInliner::inline_static_control(tbranch, builder);
assert_eq!(
tbranch_latency,
tgroup.borrow().get_latency(),
"tru branch and tru branch group latency do not match"
);
let mut tgroup_assigns: Vec<ir::Assignment<ir::StaticTiming>> =
tgroup.borrow_mut().assignments.clone();
// turn fgroup (if it exists) into group and put assigns into fgroup_assigns
let mut fgroup_assigns: Vec<ir::Assignment<ir::StaticTiming>> =
match **fbranch {
ir::StaticControl::Empty(_) => vec![],
_ => {
let fgroup = StaticInliner::inline_static_control(
fbranch, builder,
);
assert_eq!(fbranch_latency, fgroup.borrow().get_latency(), "false branch and false branch group latency do not match");
let fgroup_assigns: Vec<
ir::Assignment<ir::StaticTiming>,
> = fgroup.borrow_mut().assignments.clone();
fgroup_assigns
}
};
// need to do two things:
// add cond_wire.out ? in front of each tgroup assignment
// (and ! cond_wire.out for fgroup assignemnts)
// add %[0:tbranch_latency] in front of each tgroup assignment
// (and %[0: fbranch_latency]) in front of each fgroup assignment
let cond_wire_guard =
ir::Guard::Port(cond_wire.borrow().get("out"));
let not_cond_wire_guard =
ir::Guard::Not(Box::new(cond_wire_guard.clone()));
tgroup_assigns.iter_mut().for_each(|assign| {
// adds the %[0:tbranch_latency] ? guard
Self::update_assignment_timing(assign, 0, tbranch_latency);
// adds the cond_wire ? guard
assign
.guard
.update(|guard| guard.and(cond_wire_guard.clone()))
});
if_group_assigns.extend(tgroup_assigns);
fgroup_assigns.iter_mut().for_each(|assign| {
// adds the %[0:fbranch_latency] ? guard
Self::update_assignment_timing(assign, 0, fbranch_latency);
// adds the !cond_wire ? guard
assign
.guard
.update(|guard| guard.and(not_cond_wire_guard.clone()))
});
if_group_assigns.extend(fgroup_assigns);
if_group.borrow_mut().assignments = if_group_assigns;
if_group.borrow_mut().attributes = attributes.clone();
if_group
}
ir::StaticControl::Repeat(ir::StaticRepeat {
latency,
num_repeats,
body,
attributes,
}) => {
let repeat_group =
builder.add_static_group("static_repeat", *latency);
// turn body into a group body_group by recursively calling inline_static_control
let body_group =
StaticInliner::inline_static_control(body, builder);
assert_eq!(*latency, (num_repeats * body_group.borrow().get_latency()), "latency of static repeat is not equal to num_repeats * latency of body");
// the assignments in the repeat group should simply trigger the
// body group. So the static group will literally look like:
// static group static_repeat <num_repeats * body_latency> {body[go] = 1'd1;}
structure!( builder;
let signal_on = constant(1,1);
);
let trigger_body = build_assignments!(builder;
body_group["go"] = ? signal_on["out"];
);
repeat_group.borrow_mut().assignments = trigger_body.to_vec();
repeat_group.borrow_mut().attributes = attributes.clone();
repeat_group
}
ir::StaticControl::Empty(_) => unreachable!(
"should not call inline_static_control on empty stmt"
),
ir::StaticControl::Invoke(inv) => {
dbg!(inv.comp.borrow().name());
todo!("implement static inlining for invokes")
}
}
}
}
impl Visitor for StaticInliner {
/// Executed after visiting the children of a [ir::Static] node.
fn start_static_control(
&mut self,
s: &mut ir::StaticControl,
comp: &mut ir::Component,
sigs: &LibrarySignatures,
_comps: &[ir::Component],
) -> VisResult {
let mut builder = ir::Builder::new(comp, sigs);
let replacement_group =
StaticInliner::inline_static_control(s, &mut builder);
Ok(Action::Change(Box::new(ir::Control::from(
ir::StaticControl::from(replacement_group),
))))
}
}