tmp

Author: UnsignedByte

crates/filament/src/ir_passes/build_domination.rs

@@ -46,7 +46,8 @@ impl BuildDomination {
         // First pass to register all paremeter owners.
         for (id, cmd) in cmds.iter().enumerate() {
             match cmd {
-                ir::Command::Let(ir::Let { param, .. }) => {
+                ir::Command::Exists(ir::Exists { param, .. })
+                | ir::Command::Let(ir::Let { param, .. }) => {
                     log::trace!("let-bound param {}", comp.display(*param));
                     param_map.insert(*param, id);
                 }
@@ -72,21 +73,27 @@ impl BuildDomination {
         // Second pass to add dependencies between parameter owners and users.
         for (id, cmd) in cmds.iter().enumerate() {
             match cmd {
-                ir::Command::Let(ir::Let { expr, param }) => {
-                    if let Some(expr) = expr {
-                        for idx in expr.relevant_vars(comp) {
-                            log::trace!(
-                                "param {} is used by {}",
-                                comp.display(idx),
-                                comp.display(*param)
-                            );
-                            if let Some(pid) = param_map.get(&idx) {
-                                // Add a dependency from the let to the parameter owner, if it is defined in this scope
-                                topo.add_dependency(*pid, id);
-                            }
+                ir::Command::Let(ir::Let {
+                    expr: Some(expr),
+                    param,
+                })
+                | ir::Command::Exists(ir::Exists { param, expr }) => {
+                    for idx in expr.relevant_vars(comp) {
+                        log::trace!(
+                            "param {} is used by {}",
+                            comp.display(idx),
+                            comp.display(*param)
+                        );
+                        if let Some(pid) = param_map.get(&idx) {
+                            // Add a dependency from the let to the parameter owner, if it is defined in this scope
+                            topo.add_dependency(*pid, id);
                         }
                     }
                 }
+                ir::Command::Let(ir::Let { expr: None, .. }) => {
+                    // If the let does not have an expression, it depends on nothing.
+                    // We can ignore it.
+                }
                 ir::Command::Instance(inst) => {
                     for idx in (*inst).relevant_vars(comp) {
                         log::trace!(
@@ -154,6 +161,11 @@ impl BuildDomination {
     fn add_let(&mut self, let_: ir::Let) {
         self.plets.last_mut().unwrap().push(let_.into());
     }
+
+    fn add_exists(&mut self, exists: ir::Exists) {
+        // We can treat exists as a let binding
+        self.plets.last_mut().unwrap().push(exists.into());
+    }
 }
 
 impl Visitor for BuildDomination {
@@ -179,6 +191,16 @@ impl Visitor for BuildDomination {
         Action::Change(vec![])
     }
 
+    fn exists(
+        &mut self,
+        exists: &mut ir::Exists,
+        _: &mut VisitorData,
+    ) -> Action {
+        self.add_exists(exists.clone());
+        // Remove the exists
+        Action::Change(vec![])
+    }
+
     fn start_cmds(&mut self, _: &mut Vec<ir::Command>, _: &mut VisitorData) {
         self.start_scope();
     }

crates/filament/src/ir_passes/mod.rs

@@ -10,6 +10,7 @@ mod lower;
 mod mono;
 mod phantom_check;
 mod prop_simplify;
+// mod schedule;
 mod type_check;
 
 pub use assignment_check::AssignCheck;

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

@@ -24,12 +24,6 @@ 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> {
@@ -45,7 +39,6 @@ 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(),
         }
     }
 }
@@ -105,12 +98,23 @@ impl MonoDeferred<'_, '_> {
 
         // Insert the existential parameters into the monomorphization
         // Also extend the binding with existential parameters
-        for (param, expr) in self.exist_params.iter() {
+        let exist_params = self
+            .monosig
+            .binding
+            .iter()
+            .filter(|(p, _)| self.underlying.get(*p).is_existential())
+            .copied()
+            .collect_vec();
+
+        for (param, expr) in exist_params {
             let comp_key = self.monosig.comp_key.clone();
             let base_comp = self.monosig.base.comp();
-            let v = expr.get().as_concrete(base_comp).unwrap();
+            let v = expr.get().as_concrete(base_comp).unwrap_or_else(
+                || unreachable!("Existential parameter {} was bound to non-constant value {}", self.underlying.display(param), base_comp.display(expr.get())),
+            );
 
             self.pass.inst_info_mut(comp_key).add_exist_val(param, v);
+            // replace the old binding with this new one
             self.monosig.push_binding(param, v);
         }
 
@@ -286,30 +290,20 @@ impl MonoDeferred<'_, '_> {
         let ir::Fact { prop, reason, .. } = fact;
 
         let prop = prop.ul();
-        let (params, _) = self.underlying.relevant_vars(prop);
 
-        if !params
-            .into_iter()
-            .all(|idx| self.monosig.binding.get(&idx).is_some())
-        {
-            // Discards the assertion if it references parameters that can't be resolved (bundle parameters, etc)
-            // TODO(edmund): Find a better solution to this - we should resolve bundle assertions when bundles are unrolled.
-            None
-        } else {
-            let prop = self.monosig.prop(&self.underlying, prop, self.pass);
-            let prop = self
-                .monosig
-                .base
-                .resolve_prop(self.monosig.base.get(prop).clone())
-                .get();
+        let prop = self.monosig.prop(&self.underlying, prop, self.pass);
+        // let prop = self
+        //     .monosig
+        //     .base
+        //     .resolve_prop(self.monosig.base.get(prop).clone())
+        //     .get();
 
-            let reason = reason.ul();
-            let reason =
-                self.monosig.info(&self.underlying, self.pass, reason).get();
+        let reason = reason.ul();
+        let reason =
+            self.monosig.info(&self.underlying, self.pass, reason).get();
 
-            // After monomorphization, both assumes and asserts become asserts.
-            Some(ir::Fact::assert(prop, reason))
-        }
+        // After monomorphization, both assumes and asserts become asserts.
+        Some(ir::Fact::assert(prop.get(), reason))
     }
 
     /// Compile the given command and return the generated command if any.
@@ -380,7 +374,7 @@ impl MonoDeferred<'_, '_> {
                 let e =
                     self.monosig.expr(&self.underlying, expr.ul(), self.pass);
 
-                self.exist_params.push(param.ul(), e);
+                self.monosig.binding.push(param.ul(), e);
                 None
             }
             // XXX(rachit): We completely get rid of facts in the program here.

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

@@ -258,10 +258,15 @@ impl MonoSig {
                 }
             };
             unreachable!(
-                "{} `{}' should have been resolved in the binding but the binding was: [{}]",
+                "{} `{}' should have been resolved in the binding but the binding was: [{}], param_map was: {:?}",
                 msg,
                 p_rep,
                 self.binding_rep(ul),
+                self.param_map
+                    .clone()
+                    .iter()
+                    .map(|(k, v)| (ul.display(k), self.base.display(*v)))
+                    .collect_vec()
             )
         }
     }
@@ -854,6 +859,18 @@ impl MonoSig {
 
         self.base.push_port_attrs(new_port, attrs.clone());
 
+        // Add the bundle parameters associated with this port.
+        // We need to do this here because signature ports can have their
+        // Bundle idxs referred to in assertions before their data has been monomorphized
+        let ir::Liveness { idxs, .. } = live;
+
+        self.bundle_params(
+            underlying,
+            pass,
+            &idxs.iter().map(|idx| idx.ul()).collect_vec(),
+            new_port,
+        );
+
         // Overwrite the value in the port map if any. This is okay because this
         // method can be called on local ports defined in iterative scopes.
         self.port_map.insert(port_map_k, new_port);
@@ -880,17 +897,16 @@ impl MonoSig {
         // Find the new port owner
         let mono_owner = self.find_new_portowner(underlying, pass, owner);
 
-        let ir::Liveness { idxs, lens, range } = live;
-
-        let mono_idxs = self.bundle_params(
-            underlying,
-            pass,
-            &idxs.iter().map(|idx| idx.ul()).collect_vec(),
-            new_port,
-        );
+        let ir::Liveness { lens, range, .. } = live;
 
         let mut mono_liveness = ir::Liveness {
-            idxs: mono_idxs.iter().map(|idx| idx.get()).collect_vec(),
+            idxs: self
+                .bundle_param_map
+                .get(&new_port)
+                .unwrap()
+                .iter()
+                .map(|idx| idx.get())
+                .collect_vec(),
             lens: vec![],         // placeholder
             range: range.clone(), // placeholder
         };

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

@@ -81,7 +81,6 @@ impl Retime {
         });
         src_info.events.push(event, "G".into());
         src_info.interface_ports.push(event, "write_en".into());
-
         comp.event_args = Box::new([event]);
 
         // Concrete expressions