more restructuring

Author: UnsignedByte

crates/filament/src/ir_passes/mod.rs

@@ -10,7 +10,6 @@ mod lower;
 mod mono;
 mod phantom_check;
 mod prop_simplify;
-mod schedule;
 mod type_check;
 
 pub use assignment_check::AssignCheck;
@@ -25,5 +24,4 @@ pub use lower::Compile;
 pub use mono::Monomorphize;
 pub use phantom_check::PhantomCheck;
 pub use prop_simplify::Simplify;
-pub use schedule::Schedule;
 pub use type_check::TypeCheck;

crates/filament/src/ir_passes/mono/monodeferred.rs

@@ -1,8 +1,8 @@
 use super::{
-    CompKey, IntoBase, IntoUdl, MonoSig, Monomorphize, Underlying,
+    Base, CompKey, IntoBase, IntoUdl, MonoSig, Monomorphize, Underlying,
     UnderlyingComp,
 };
-use fil_ir::{self as ir, AddCtx, Ctx};
+use fil_ir::{self as ir, AddCtx, Ctx, SparseInfoMap};
 use fil_utils::{self as utils, AttrCtx};
 use ir::DisplayCtx;
 use itertools::Itertools;
@@ -24,6 +24,12 @@ pub struct MonoDeferred<'comp, 'pass: 'comp> {
 
     /// If this component should be scheduled, this stores the scheduling type
     pub schedule: Option<u64>,
+
+    /// Existential parameter map.
+    /// These are not interned until [Self::sig_complete_mono] as scheduling
+    /// may affect the values of existential parameters.
+    exist_params:
+        SparseInfoMap<ir::Param, Base<ir::Expr>, Underlying<ir::Param>>,
 }
 
 impl<'a, 'pass: 'a> MonoDeferred<'a, 'pass> {
@@ -39,6 +45,7 @@ impl<'a, 'pass: 'a> MonoDeferred<'a, 'pass> {
             monosig,
             // Set to false if we call `sig_partial_mono` and true once we call `sig_complete_mono`
             sig_mono_complete: true,
+            exist_params: SparseInfoMap::default(),
         }
     }
 }
@@ -96,6 +103,17 @@ impl MonoDeferred<'_, '_> {
     pub fn sig_complete_mono(&mut self) {
         assert!(!self.sig_mono_complete);
 
+        // Insert the existential parameters into the monomorphization
+        // Also extend the binding with existential parameters
+        for (param, expr) in self.exist_params.iter() {
+            let comp_key = self.monosig.comp_key.clone();
+            let base_comp = self.monosig.base.comp();
+            let v = expr.get().as_concrete(base_comp).unwrap();
+
+            self.pass.inst_info_mut(comp_key).add_exist_val(param, v);
+            self.monosig.push_binding(param, v);
+        }
+
         // Make sure all assertions generated by existential parameters evaluate to true
         // The type checker ensures this cannot happen for Filament-level
         // components but externally generated components might violate their
@@ -153,19 +171,6 @@ impl MonoDeferred<'_, '_> {
             self.monosig.base.extend_cmds(cmd);
         }
 
-        // Extend the binding with existential parameters
-        let info = self.pass.inst_info(&self.monosig.comp_key);
-        for param in self.underlying.exist_params() {
-            let param = param.ul();
-            let Some(v) = info.get_exist_val(param) else {
-                unreachable!(
-                    "No binding for existential parameter `{}'. Is the body missing an assignment to the parameter?",
-                    self.underlying.display(param)
-                )
-            };
-            self.monosig.push_binding(param, v);
-        }
-
         // Monomorphize the rest of the signature
         self.sig_complete_mono();
 
@@ -372,22 +377,10 @@ impl MonoDeferred<'_, '_> {
                 None
             }
             ir::Command::Exists(ir::Exists { param, expr }) => {
-                let comp_key = self.monosig.comp_key.clone();
-                let e = self
-                    .monosig
-                    .expr(&self.underlying, expr.ul(), self.pass)
-                    .get();
-                let base_comp = self.monosig.base.comp();
-                let Some(v) = e.as_concrete(base_comp) else {
-                    unreachable!(
-                        "exists binding evaluated to: {}",
-                        base_comp.display(e)
-                    )
-                };
+                let e =
+                    self.monosig.expr(&self.underlying, expr.ul(), self.pass);
 
-                self.pass
-                    .inst_info_mut(comp_key)
-                    .add_exist_val(param.ul(), v);
+                self.exist_params.push(param.ul(), e);
                 None
             }
             // XXX(rachit): We completely get rid of facts in the program here.

crates/filament/src/ir_passes/mono/utils/comp.rs

@@ -130,6 +130,18 @@ impl BaseComp {
     pub fn resolve_prop(&mut self, prop: ir::Prop) -> Base<ir::Prop> {
         self.0.resolve_prop(prop).base()
     }
+
+    pub fn inputs(
+        &self,
+    ) -> impl Iterator<Item = (Base<ir::Port>, &'_ ir::Port)> {
+        self.0.inputs().map(|(k, v)| (k.base(), v))
+    }
+
+    pub fn outputs(
+        &self,
+    ) -> impl Iterator<Item = (Base<ir::Port>, &'_ ir::Port)> {
+        self.0.outputs().map(|(k, v)| (k.base(), v))
+    }
 }
 
 impl<T> MutCtx<T, Base<T>> for BaseComp

crates/filament/src/ir_passes/schedule/mod.rs

@@ -1,9 +1,7 @@
 mod combinational_paths;
-mod pass;
 mod retime;
 mod solve;
 
 use combinational_paths::CombDataflow;
-pub use pass::Schedule;
 use retime::Retime;
 use solve::Solve;

crates/filament/src/ir_passes/schedule/pass.rs

@@ -1,5 +1,11 @@
 use super::CombDataflow;
-use crate::ir_visitor::{Action, Construct, Visitor, VisitorData};
+use crate::{
+    ir_passes::{
+        Monomorphize,
+        mono::{BaseComp, MonoSig, Underlying, UnderlyingComp},
+    },
+    ir_visitor::{Action, Construct, Visitor, VisitorData},
+};
 use easy_smt::{self as smt, SExpr, SExprData};
 use fil_ir::{self as ir, AddCtx, Ctx, DisplayCtx, MutCtx};
 use fil_utils::{AttrCtx, CompNum};
@@ -23,22 +29,59 @@ impl From<u64> for SchedulingGoal {
 }
 
 /// Sets the proper FSM Attributes for every component
-pub struct Solve {
+pub struct Solve<'comp, 'pass: 'comp> {
     /// Solver context
     sol: smt::Context,
     /// Scheduling goal
     goal: SchedulingGoal,
     /// The expression to minimize
     minimize_expr: smt::SExpr,
-    // /// Map from ir elements to SExprs
-    // expr_map: ir::SparseInfoMap<ir::Expr, SExpr>,
-    // port_map: ir::SparseInfoMap<ir::PortIdx, SExpr>,
-    // event_map: ir::SparseInfoMap<ir::EventIdx, SExpr>,
-    // time_map: ir::SparseInfoMap<ir::TimeIdx, SExpr>,
-    // prop_map: ir::SparseInfoMap<ir::PropIdx, SExpr>,
+
+    /// The underlying component to be monomorphized
+    pub underlying_idx: Underlying<ir::Component>,
+    /// Underlying pointer
+    pub pass: &'comp mut Monomorphize<'pass>,
+    /// Struct to keep track of all the mapping information from things owned by
+    /// `underlying` to things owned by `base`
+    pub monosig: &'comp MonoSig,
 }
 
-impl Solve {
+impl<'comp, 'pass> Solve<'comp, 'pass>
+where
+    'pass: 'comp,
+{
+    fn new(
+        underlying_idx: Underlying<ir::Component>,
+        pass: &'comp mut Monomorphize<'pass>,
+        monosig: &'comp MonoSig,
+        goal: u64,
+        solver_file: Option<&str>,
+    ) -> Self {
+        // We have to use Z3 as only it supports maximization of an objective function
+        let (name, s_opts) = ("z3", vec!["-smt2", "-in"]);
+
+        let mut sol = smt::ContextBuilder::new()
+            .replay_file(
+                solver_file.as_ref().map(|s| fs::File::create(s).unwrap()),
+            )
+            .solver(name, s_opts)
+            .build()
+            .unwrap();
+
+        sol.push_many(1).unwrap();
+
+        Self {
+            underlying_idx,
+            pass,
+            monosig,
+            minimize_expr: sol.numeral(0),
+            goal: goal.into(),
+            sol,
+        }
+    }
+}
+
+impl Solve<'_, '_> {
     /// Get the constant names for the start and end of a port
     pub fn get_port_name(&self, pidx: ir::PortIdx) -> (String, String) {
         (
@@ -225,59 +268,15 @@ impl Solve {
     }
 }
 
-impl Construct for Solve {
-    fn from(opts: &crate::cmdline::Opts, _: &mut ir::Context) -> Self {
-        // We have to use Z3 as only it supports maximization of an objective function
-        let (name, s_opts) = ("z3", vec!["-smt2", "-in"]);
-
-        let mut sol = smt::ContextBuilder::new()
-            .replay_file(
-                opts.solver_replay_file
-                    .as_ref()
-                    .map(|s| fs::File::create(s).unwrap()),
-            )
-            .solver(name, s_opts)
-            .build()
-            .unwrap();
-
-        sol.push_many(1).unwrap();
-
-        Self {
-            minimize_expr: sol.numeral(0),
-            goal: SchedulingGoal::Latency,
-            sol,
-        }
-    }
-
-    fn clear_data(&mut self) {
-        // Create a new solver context
-        self.sol.pop_many(1).unwrap();
-        self.sol.push_many(1).unwrap();
-    }
-}
-
-impl Visitor for Solve {
-    fn name() -> &'static str {
-        "schedule-solve"
-    }
-
-    fn start(&mut self, data: &mut VisitorData) -> Action {
-        // Quit the pass if this attribute does not have the #[schedule] attribute
-        if let Some(&goal) = data.comp.attrs.get(CompNum::Schedule) {
-            self.goal = goal.into()
-        } else {
-            return Action::Stop;
-        }
-
-        // make sure this component only has one event
-        assert_eq!(
-            data.comp.events().idx_iter().count(),
-            1,
-            "Attempting to schedule a component with multiple events"
-        );
-
+impl Solve<'_, '_> {
+    fn comp(&mut self) -> Action {
         // For the inputs and outputs of the component, we need to schedule them as expected.
-        for (pidx, port) in data.comp.inputs().chain(data.comp.outputs()) {
+        for (pidx, port) in self
+            .monosig
+            .base
+            .inputs()
+            .chain(self.monosig.base.outputs())
+        {
             let ir::Range { start, end } = port.live.range;
 
             let start = data.comp.get(start).offset.concrete(&data.comp);
@@ -304,8 +303,6 @@ impl Visitor for Solve {
                 .assert(self.sol.eq(self.sol.numeral(end), end_expr))
                 .unwrap();
         }
-
-        Action::Continue
     }
 
     fn connect(

crates/filament/src/ir_passes/schedule/solve.rs

@@ -95,8 +95,7 @@ fn run(opts: &cmdline::Opts) -> Result<(), u64> {
         ip::Simplify,
         ip::AssignCheck,
         ip::BundleElim,
-        ip::AssignCheck,
-        ip::Schedule
+        ip::AssignCheck
     }
     // type check again before lowering
     ir_pass_pipeline! {opts, ir;

crates/filament/src/main.rs

@@ -5,10 +5,14 @@ comp main<'G: 1>(
   in: ['G, 'G+1] 32,
 ) -> (
   out: ['G+10, 'G+11] 32
-)
+) with {
+    some L;
+}
 {
     let x = ?;
     let xx = 2;
     let y = x + xx;
     let z = y + 1;
+
+    L := z;
 }