feat(compiler): add error handling for invalid rounding

Author: rohanku

core/compiler/src/compile.rs

@@ -2269,6 +2269,18 @@ impl<'a> ExecPass<'a> {
                 kind: ExecErrorKind::InconsistentConstraint(constraint),
             });
         }
+        for var in self
+            .cell_state_mut(cell_id)
+            .solver
+            .invalid_rounding()
+            .clone()
+        {
+            self.errors.push(ExecError {
+                span: None,
+                cell: cell_id,
+                kind: ExecErrorKind::InvalidRounding(var),
+            });
+        }
 
         self.partial_cells
             .pop_back()
@@ -4217,6 +4229,9 @@ pub enum ExecErrorKind {
     /// Inconsistent constraint.
     #[error("inconsistent constraint")]
     InconsistentConstraint(ConstraintId),
+    /// Invalid rounding (e.g. solved value is not sufficiently close to a rounding step).
+    #[error("invalid rounding")]
+    InvalidRounding(Var),
     /// A cell or instance had an empty bounding box.
     #[error("empty bbox")]
     EmptyBbox,

core/compiler/src/lib.rs

@@ -18,8 +18,9 @@ mod tests {
     };
     use approx::assert_relative_eq;
     use const_format::concatcp;
+    use gds21::GdsUnits;
 
-    use crate::compile::{compile, CellArg, CompileInput};
+    use crate::compile::{CellArg, CompileInput, compile};
     const EPSILON: f64 = 1e-10;
 
     const EXAMPLES_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../examples");
@@ -439,6 +440,7 @@ mod tests {
         cells
             .to_gds(
                 GdsMap::from_lyp(SKY130_LYP).expect("failed to create GDS map"),
+                GdsUnits::new(1e-3, 1e-9),
                 work_dir.join("layout.gds"),
             )
             .expect("Failed to write to GDS");
@@ -506,7 +508,7 @@ mod tests {
         assert_eq!(cells.errors.len(), 1);
         assert!(matches!(
             cells.errors.first().unwrap().kind,
-            ExecErrorKind::InconsistentConstraint(_)
+            ExecErrorKind::InvalidRounding(_)
         ));
     }
 
@@ -681,6 +683,7 @@ mod tests {
         cells
             .to_gds(
                 GdsMap::from_lyp(SKY130_LYP).expect("failed to create GDS map"),
+                GdsUnits::new(1e-3, 1e-9),
                 work_dir.join("layout.gds"),
             )
             .expect("Failed to write to GDS");

core/compiler/src/solver.rs

@@ -1,4 +1,4 @@
-use approx::relative_eq;
+use approx::{relative_eq, relative_ne};
 use indexmap::{IndexMap, IndexSet};
 use itertools::{Either, Itertools};
 use nalgebra::{DMatrix, DVector};
@@ -19,6 +19,7 @@ pub struct Solver {
     var_to_constraints: IndexMap<Var, IndexSet<ConstraintId>>,
     solved_vars: IndexMap<Var, f64>,
     inconsistent_constraints: IndexSet<ConstraintId>,
+    invalid_rounding: IndexSet<Var>,
 }
 
 fn round(x: f64) -> f64 {
@@ -57,6 +58,11 @@ impl Solver {
         &self.inconsistent_constraints
     }
 
+    #[inline]
+    pub fn invalid_rounding(&self) -> &IndexSet<Var> {
+        &self.invalid_rounding
+    }
+
     pub fn unsolved_vars(&self) -> IndexSet<Var> {
         IndexSet::from_iter((0..self.next_var).map(Var).filter(|&v| !self.is_solved(v)))
     }
@@ -95,11 +101,15 @@ impl Solver {
             let (coeff, var) = constraint.coeffs[0];
             let val = -constraint.constant / coeff;
             if let Some(old_val) = self.solved_vars.get(&var) {
-                if !relative_eq!(*old_val, val, epsilon = EPSILON) {
+                if relative_ne!(*old_val, val, epsilon = EPSILON) {
                     self.inconsistent_constraints.insert(constraint_id);
                 }
             } else {
-                self.solved_vars.insert(var, val);
+                let rounded_val = round(val);
+                if relative_ne!(val, rounded_val, epsilon = EPSILON) {
+                    self.invalid_rounding.insert(var);
+                }
+                self.solved_vars.insert(var, rounded_val);
             }
             self.constraints.swap_remove(&constraint_id);
             for constraint in self
@@ -146,8 +156,7 @@ impl Solver {
             if !self.solved_vars.contains_key(&Var(i))
                 && relative_eq!(recons, 1., epsilon = EPSILON)
             {
-                let val = round(sol[(i as usize, 0)]);
-                self.solved_vars.insert(Var(i), val);
+                self.solved_vars.insert(Var(i), sol[(i as usize, 0)]);
             }
         }
         for (id, constraint) in self.constraints.iter_mut() {
@@ -158,6 +167,16 @@ impl Solver {
                 self.inconsistent_constraints.insert(*id);
             }
         }
+        for i in 0..self.next_var {
+            if let Some(val) = self.solved_vars.get_mut(&Var(i)) {
+                let rounded_val = round(*val);
+                if relative_ne!(*val, rounded_val, epsilon = EPSILON) {
+                    self.invalid_rounding.insert(Var(i));
+                } else {
+                    *val = rounded_val;
+                }
+            }
+        }
         self.constraints
             .retain(|_, constraint| !constraint.coeffs.is_empty());
     }