refactor(autorouter/multilayer_autoroute): Count planar reconfigurations (not used yet)

In preparation for implementation of rudimentary multilayer reconfiguration.

src/autorouter/autorouter.rs

@@ -13,7 +13,7 @@ use thiserror::Error;
 use crate::{
     autorouter::{
         multilayer_autoroute::{MultilayerAutorouteExecutionStepper, MultilayerAutorouteOptions},
-        planar_reconfigurator::PlanarAutorouteExecutionReconfigurator,
+        planar_reconfigurator::PlanarAutorouteReconfigurator,
         planner::Planner,
         ratsnests::Ratsnests,
     },
@@ -137,8 +137,8 @@ impl<M: AccessMesadata> Autorouter<M> {
         &mut self,
         selection: &PinSelection,
         options: PlanarAutorouteOptions,
-    ) -> Result<PlanarAutorouteExecutionReconfigurator, AutorouterError> {
+    ) -> Result<PlanarAutorouteReconfigurator, AutorouterError> {
-        PlanarAutorouteExecutionReconfigurator::new(
+        PlanarAutorouteReconfigurator::new(
             self,
             self.selected_planar_ratlines(selection, options.principal_layer),
             options,

src/autorouter/execution.rs

@@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     autorouter::{
         multilayer_autoroute::{MultilayerAutorouteExecutionStepper, MultilayerAutorouteOptions},
-        planar_reconfigurator::PlanarAutorouteExecutionReconfigurator,
+        planar_reconfigurator::PlanarAutorouteReconfigurator,
     },
     board::{edit::BoardEdit, AccessMesadata},
     layout::via::ViaWeight,
@@ -50,7 +50,7 @@ pub enum Command {
 #[enum_dispatch(GetDebugOverlayData)]
 pub enum ExecutionStepper<M> {
     MultilayerAutoroute(MultilayerAutorouteExecutionStepper),
-    PlanarAutoroute(PlanarAutorouteExecutionReconfigurator),
+    PlanarAutoroute(PlanarAutorouteReconfigurator),
     TopoAutoroute(ng::AutorouteExecutionStepper<M>),
     PlaceVia(PlaceViaExecutionStepper),
     RemoveBands(RemoveBandsExecutionStepper),

src/autorouter/invoker.rs

@@ -34,7 +34,7 @@ use super::{
     measure_length::MeasureLengthExecutionStepper,
     multilayer_autoroute::MultilayerAutorouteExecutionStepper,
     place_via::PlaceViaExecutionStepper,
-    planar_reconfigurator::PlanarAutorouteExecutionReconfigurator,
+    planar_reconfigurator::PlanarAutorouteReconfigurator,
     remove_bands::RemoveBandsExecutionStepper,
     Autorouter, AutorouterError,
 };

src/autorouter/multilayer_autoroute.rs

@@ -12,7 +12,7 @@ use crate::{
         anterouter::{Anterouter, AnterouterOptions, AnterouterPlan},
         invoker::GetDebugOverlayData,
         planar_autoroute::PlanarAutorouteContinueStatus,
-        planar_reconfigurator::PlanarAutorouteExecutionReconfigurator,
+        planar_reconfigurator::{PlanarAutorouteReconfigurator, PlanarReconfiguratorStatus},
         ratline::RatlineUid,
         Autorouter, AutorouterError, PlanarAutorouteOptions,
     },
@@ -30,8 +30,10 @@ pub struct MultilayerAutorouteOptions {
 }
 
 pub struct MultilayerAutorouteExecutionStepper {
-    planar: PlanarAutorouteExecutionReconfigurator,
+    planar: PlanarAutorouteReconfigurator,
     anteroute_edit: BoardEdit,
+    // TODO: Obviously, we need something more sophisticated here.
+    planar_autoroute_reconfiguration_count: u64,
 }
 
 impl MultilayerAutorouteExecutionStepper {
@@ -46,18 +48,14 @@ impl MultilayerAutorouteExecutionStepper {
         assigner.anteroute(autorouter, &mut anteroute_edit, &options.anterouter);
 
         Ok(Self {
-            planar: PlanarAutorouteExecutionReconfigurator::new(
+            planar: PlanarAutorouteReconfigurator::new(autorouter, ratlines, options.planar)?,
-                autorouter,
-                ratlines,
-                options.planar,
-            )?,
             anteroute_edit,
+            planar_autoroute_reconfiguration_count: 0,
         })
     }
 }
 
-impl<M: AccessMesadata>
+impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarReconfiguratorStatus>
-    Step<Autorouter<M>, Option<BoardEdit>, ReconfiguratorStatus<(), PlanarAutorouteContinueStatus>>
     for MultilayerAutorouteExecutionStepper
 {
     type Error = AutorouterError;
@@ -65,16 +63,19 @@ impl<M: AccessMesadata>
     fn step(
         &mut self,
         autorouter: &mut Autorouter<M>,
-    ) -> Result<
+    ) -> Result<ControlFlow<Option<BoardEdit>, PlanarReconfiguratorStatus>, AutorouterError> {
-        ControlFlow<Option<BoardEdit>, ReconfiguratorStatus<(), PlanarAutorouteContinueStatus>>,
-        AutorouterError,
-    > {
         match self.planar.step(autorouter) {
             Ok(ControlFlow::Break(Some(edit))) => {
                 self.anteroute_edit.merge(edit);
                 // FIXME: Unnecessary large clone.
                 Ok(ControlFlow::Break(Some(self.anteroute_edit.clone())))
             }
+            Ok(ControlFlow::Continue(ReconfiguratorStatus::Reconfigured(result))) => {
+                self.planar_autoroute_reconfiguration_count += 1;
+                Ok(ControlFlow::Continue(ReconfiguratorStatus::Reconfigured(
+                    result,
+                )))
+            }
             x => x,
         }
     }

src/autorouter/planar_autoroute.rs

@@ -29,6 +29,19 @@ use super::{
     PlanarAutorouteOptions,
 };
 
+pub struct PlanarAutorouteConfiguration {
+    pub ratlines: Vec<RatlineUid>,
+}
+
+pub struct PlanarAutorouteCosts {
+    pub lengths: Vec<f64>,
+}
+
+pub struct PlanarAutorouteConfigurationResult {
+    pub configuration: PlanarAutorouteConfiguration,
+    pub costs: PlanarAutorouteCosts,
+}
+
 /// Represents the current status of the autoroute operation.
 pub enum PlanarAutorouteContinueStatus {
     /// The autoroute is currently running and in progress.
@@ -237,13 +250,13 @@ impl<M: AccessMesadata> Abort<Autorouter<M>> for PlanarAutorouteExecutionStepper
 
 impl<M: AccessMesadata> Reconfigure<Autorouter<M>> for PlanarAutorouteExecutionStepper {
     type Configuration = Vec<RatlineUid>;
-    type Output = Result<(), AutorouterError>;
+    type Output = Result<PlanarAutorouteConfigurationResult, AutorouterError>;
 
     fn reconfigure(
         &mut self,
         autorouter: &mut Autorouter<M>,
         permutation: Vec<RatlineUid>,
-    ) -> Result<(), AutorouterError> {
+    ) -> Result<PlanarAutorouteConfigurationResult, AutorouterError> {
         let Some(new_index) = permutation
             .iter()
             .zip(self.ratlines.iter())
@@ -251,10 +264,18 @@ impl<M: AccessMesadata> Reconfigure<Autorouter<M>> for PlanarAutorouteExecutionS
         else {
             return Err(AutorouterError::NothingToUndoForReconfiguration);
         };
-        self.ratlines = permutation;
+
+        let result = PlanarAutorouteConfigurationResult {
+            configuration: PlanarAutorouteConfiguration {
+                ratlines: std::mem::replace(&mut self.ratlines, permutation),
+            },
+            costs: PlanarAutorouteCosts {
+                lengths: vec![], // TODO.
+            },
+        };
 
         self.backtrace_to_index(autorouter, new_index)?;
-        Ok(())
+        Ok(result)
     }
 }
 

src/autorouter/planar_reconfigurator.rs

@@ -9,7 +9,10 @@ use specctra_core::mesadata::AccessMesadata;
 use crate::{
     autorouter::{
         invoker::GetDebugOverlayData,
-        planar_autoroute::{PlanarAutorouteContinueStatus, PlanarAutorouteExecutionStepper},
+        planar_autoroute::{
+            PlanarAutorouteConfigurationResult, PlanarAutorouteContinueStatus,
+            PlanarAutorouteExecutionStepper,
+        },
         planar_reconfigurer::{PermuteRatlines, PlanarReconfigurer},
         presorter::{PresortParams, PresortRatlines, SccIntersectionsAndLengthPresorter},
         ratline::RatlineUid,
@@ -21,14 +24,16 @@ use crate::{
     router::{navcord::Navcord, navmesh::Navmesh, thetastar::ThetastarStepper},
     stepper::{Abort, EstimateProgress, ReconfiguratorStatus, Reconfigure, Step},
 };
+pub type PlanarReconfiguratorStatus =
+    ReconfiguratorStatus<PlanarAutorouteConfigurationResult, PlanarAutorouteContinueStatus>;
 
-pub struct PlanarAutorouteExecutionReconfigurator {
+pub struct PlanarAutorouteReconfigurator {
     stepper: PlanarAutorouteExecutionStepper,
     reconfigurer: PlanarReconfigurer,
     options: PlanarAutorouteOptions,
 }
 
-impl PlanarAutorouteExecutionReconfigurator {
+impl PlanarAutorouteReconfigurator {
     pub fn new(
         autorouter: &mut Autorouter<impl AccessMesadata>,
         ratlines: Vec<RatlineUid>,
@@ -62,19 +67,15 @@ impl PlanarAutorouteExecutionReconfigurator {
     }
 }
 
-impl<M: AccessMesadata>
+impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarReconfiguratorStatus>
-    Step<Autorouter<M>, Option<BoardEdit>, ReconfiguratorStatus<(), PlanarAutorouteContinueStatus>>
+    for PlanarAutorouteReconfigurator
-    for PlanarAutorouteExecutionReconfigurator
 {
     type Error = AutorouterError;
 
     fn step(
         &mut self,
         autorouter: &mut Autorouter<M>,
-    ) -> Result<
+    ) -> Result<ControlFlow<Option<BoardEdit>, PlanarReconfiguratorStatus>, AutorouterError> {
-        ControlFlow<Option<BoardEdit>, ReconfiguratorStatus<(), PlanarAutorouteContinueStatus>>,
-        AutorouterError,
-    > {
         match self.stepper.step(autorouter) {
             Ok(ControlFlow::Break(maybe_edit)) => Ok(ControlFlow::Break(maybe_edit)),
             Ok(ControlFlow::Continue(status)) => {
@@ -94,28 +95,28 @@ impl<M: AccessMesadata>
                     };
 
                     match self.stepper.reconfigure(autorouter, permutation) {
-                        Ok(()) => break,
+                        Ok(result) => {
+                            return Ok(ControlFlow::Continue(ReconfiguratorStatus::Reconfigured(
+                                result,
+                            )))
+                        }
                         Err(AutorouterError::NothingToUndoForReconfiguration) => continue,
                         Err(err) => return Err(err),
                     }
                 }
-
-                Ok(ControlFlow::Continue(
-                    ReconfiguratorStatus::Reconfigured(()),
-                ))
             }
         }
     }
 }
 
-impl<M: AccessMesadata> Abort<Autorouter<M>> for PlanarAutorouteExecutionReconfigurator {
+impl<M: AccessMesadata> Abort<Autorouter<M>> for PlanarAutorouteReconfigurator {
     fn abort(&mut self, autorouter: &mut Autorouter<M>) {
         //self.permutations_iter.all(|_| true); // Why did I add this code here???
         self.stepper.abort(autorouter);
     }
 }
 
-impl EstimateProgress for PlanarAutorouteExecutionReconfigurator {
+impl EstimateProgress for PlanarAutorouteReconfigurator {
     type Value = f64;
 
     fn estimate_progress_value(&self) -> f64 {
@@ -129,7 +130,7 @@ impl EstimateProgress for PlanarAutorouteExecutionReconfigurator {
     }
 }
 
-impl GetDebugOverlayData for PlanarAutorouteExecutionReconfigurator {
+impl GetDebugOverlayData for PlanarAutorouteReconfigurator {
     fn maybe_thetastar(&self) -> Option<&ThetastarStepper<Navmesh, f64>> {
         self.stepper.maybe_thetastar()
     }