refactor(autorouter/autorouter): Do some more refactors, renamings, struct-wrappings

committed.toml

@@ -27,15 +27,15 @@ allowed_scopes = [
   "autorouter/invoker",
   "autorouter/measure_length",
   "autorouter/multilayer_autoroute",
+  "autorouter/multilayer_preconfigurer",
   "autorouter/multilayer_reconfigurator",
   "autorouter/multilayer_reconfigurer",
   "autorouter/place_via",
   "autorouter/planar_autoroute",
+  "autorouter/planar_preconfigurer",
   "autorouter/planar_reconfigurator",
   "autorouter/planar_reconfigurer",
-  "autorouter/planner",
   "autorouter/pointroute",
-  "autorouter/presorter",
   "autorouter/ratsnest",
   "autorouter/ratsnests",
   "autorouter/ratline",

src/autorouter/autorouter.rs

@@ -13,13 +13,10 @@ use thiserror::Error;
 use crate::{
     autorouter::{
         multilayer_autoroute::MultilayerAutorouteOptions,
-        multilayer_reconfigurator::{
+        multilayer_preconfigurer::MultilayerAutoroutePreconfigurerInput,
-            MultilayerAutorouteReconfigurator, MultilayerAutorouteReconfiguratorInput,
+        multilayer_reconfigurator::MultilayerAutorouteReconfigurator,
-        },
+        planar_preconfigurer::PlanarAutoroutePreconfigurerInput,
-        planar_reconfigurator::{
+        planar_reconfigurator::PlanarAutorouteReconfigurator, ratsnests::Ratsnests,
-            PlanarAutorouteReconfigurator, PlanarAutorouteReconfiguratorInput,
-        },
-        ratsnests::Ratsnests,
     },
     board::{AccessMesadata, Board},
     drawing::{band::BandTermsegIndex, graph::MakePrimitiveRef},
@@ -33,7 +30,6 @@ use crate::{
 use super::{
     measure_length::MeasureLengthExecutionStepper,
     place_via::PlaceViaExecutionStepper,
-    planar_autoroute::PlanarAutorouteExecutionStepper,
     pointroute::PointrouteExecutionStepper,
     ratline::RatlineUid,
     ratsnest::RatvertexNodeIndex,
@@ -125,7 +121,7 @@ impl<M: AccessMesadata> Autorouter<M> {
     ) -> Result<MultilayerAutorouteReconfigurator, AutorouterError> {
         MultilayerAutorouteReconfigurator::new(
             self,
-            MultilayerAutorouteReconfiguratorInput {
+            MultilayerAutoroutePreconfigurerInput {
                 ratlines: self.selected_ratlines(selection, options.planar.principal_layer),
             },
             options,
@@ -139,7 +135,7 @@ impl<M: AccessMesadata> Autorouter<M> {
     ) -> Result<PlanarAutorouteReconfigurator, AutorouterError> {
         PlanarAutorouteReconfigurator::new(
             self,
-            PlanarAutorouteReconfiguratorInput {
+            PlanarAutoroutePreconfigurerInput {
                 ratlines: self.selected_planar_ratlines(selection, options.principal_layer),
             },
             options,

src/autorouter/mod.rs

@@ -11,15 +11,15 @@ pub mod history;
 pub mod invoker;
 pub mod measure_length;
 pub mod multilayer_autoroute;
+pub mod multilayer_preconfigurer;
 pub mod multilayer_reconfigurator;
 pub mod multilayer_reconfigurer;
 pub mod place_via;
 pub mod planar_autoroute;
+pub mod planar_preconfigurer;
 pub mod planar_reconfigurator;
 pub mod planar_reconfigurer;
-pub mod planner;
 pub mod pointroute;
-pub mod presorter;
 pub mod ratline;
 pub mod ratsnest;
 pub mod ratsnests;

src/autorouter/multilayer_autoroute.rs

@@ -11,10 +11,8 @@ use crate::{
     autorouter::{
         anterouter::{Anterouter, AnterouterOptions, AnterouterPlan},
         invoker::GetDebugOverlayData,
-        planar_reconfigurator::{
+        planar_preconfigurer::PlanarAutoroutePreconfigurerInput,
-            PlanarAutorouteReconfigurator, PlanarAutorouteReconfiguratorInput,
+        planar_reconfigurator::{PlanarAutorouteReconfigurator, PlanarReconfiguratorStatus},
-            PlanarReconfiguratorStatus,
-        },
         Autorouter, AutorouterError, PlanarAutorouteOptions,
     },
     board::edit::BoardEdit,
@@ -27,7 +25,7 @@ use crate::{
 #[derive(Clone, Debug)]
 pub struct MultilayerAutorouteConfiguration {
     pub plan: AnterouterPlan,
-    pub planar: PlanarAutorouteReconfiguratorInput,
+    pub planar: PlanarAutoroutePreconfigurerInput,
 }
 
 #[derive(Clone, Copy, Debug, Deserialize, Serialize)]

src/autorouter/multilayer_preconfigurer.rs

@@ -21,17 +21,26 @@ use crate::{
     graph::MakeRef,
 };
 
+#[derive(Clone, Debug)]
+pub struct MultilayerAutoroutePreconfigurerInput {
+    pub ratlines: Vec<RatlineUid>,
+}
+
 #[derive(Getters)]
-pub struct Planner {
+pub struct MultilayerPreconfigurer {
     plan: AnterouterPlan,
 }
 
-impl Planner {
+impl MultilayerPreconfigurer {
-    pub fn new(autorouter: &Autorouter<impl AccessMesadata>, ratlines: &[RatlineUid]) -> Self {
+    pub fn new(
+        autorouter: &Autorouter<impl AccessMesadata>,
+        input: MultilayerAutoroutePreconfigurerInput,
+    ) -> Self {
         Self::new_from_layer_map(
             autorouter,
-            ratlines,
+            &input.ratlines,
-            ratlines
+            input
+                .ratlines
                 .iter()
                 .enumerate()
                 .map(|(i, ratline)| (*ratline, i % 2))

src/autorouter/multilayer_reconfigurator.rs

@@ -13,10 +13,12 @@ use crate::{
             MultilayerAutorouteConfiguration, MultilayerAutorouteExecutionStepper,
             MultilayerAutorouteOptions,
         },
+        multilayer_preconfigurer::{
+            MultilayerAutoroutePreconfigurerInput, MultilayerPreconfigurer,
+        },
         multilayer_reconfigurer::MultilayerReconfigurer,
-        planar_reconfigurator::{PlanarAutorouteReconfiguratorInput, PlanarReconfiguratorStatus},
+        planar_preconfigurer::PlanarAutoroutePreconfigurerInput,
-        planner::Planner,
+        planar_reconfigurator::PlanarReconfiguratorStatus,
-        ratline::RatlineUid,
         Autorouter, AutorouterError,
     },
     board::edit::BoardEdit,
@@ -26,10 +28,6 @@ use crate::{
     stepper::{Abort, EstimateProgress, ReconfiguratorStatus, Reconfigure, Step},
 };
 
-pub struct MultilayerAutorouteReconfiguratorInput {
-    pub ratlines: Vec<RatlineUid>,
-}
-
 pub type MultilayerReconfiguratorStatus = ReconfiguratorStatus<(), PlanarReconfiguratorStatus>;
 
 pub struct MultilayerAutorouteReconfigurator {
@@ -43,13 +41,13 @@ pub struct MultilayerAutorouteReconfigurator {
 impl MultilayerAutorouteReconfigurator {
     pub fn new(
         autorouter: &mut Autorouter<impl AccessMesadata>,
-        input: MultilayerAutorouteReconfiguratorInput,
+        input: MultilayerAutoroutePreconfigurerInput,
         options: MultilayerAutorouteOptions,
     ) -> Result<Self, AutorouterError> {
-        let planner = Planner::new(autorouter, &input.ratlines);
+        let planner = MultilayerPreconfigurer::new(autorouter, input.clone());
         let preconfiguration = MultilayerAutorouteConfiguration {
             plan: planner.plan().clone(),
-            planar: PlanarAutorouteReconfiguratorInput {
+            planar: PlanarAutoroutePreconfigurerInput {
                 ratlines: input.ratlines.clone(),
             },
         };

src/autorouter/multilayer_reconfigurer.rs

@@ -7,8 +7,8 @@ use std::time::SystemTime;
 use specctra_core::mesadata::AccessMesadata;
 
 use crate::autorouter::{
-    anterouter::AnterouterPlan, multilayer_autoroute::MultilayerAutorouteOptions, planner::Planner,
+    anterouter::AnterouterPlan, multilayer_autoroute::MultilayerAutorouteOptions,
-    ratline::RatlineUid, Autorouter,
+    multilayer_preconfigurer::MultilayerPreconfigurer, ratline::RatlineUid, Autorouter,
 };
 
 pub struct MultilayerReconfigurer {
@@ -30,7 +30,7 @@ impl MultilayerReconfigurer {
         &mut self,
         autorouter: &Autorouter<impl AccessMesadata>,
     ) -> Option<AnterouterPlan> {
-        let planner = Planner::new_from_layer_map(
+        let planner = MultilayerPreconfigurer::new_from_layer_map(
             autorouter,
             &self.original_ratlines,
             self.original_ratlines

src/autorouter/planar_preconfigurer.rs

@@ -7,7 +7,15 @@ use enum_dispatch::enum_dispatch;
 use petgraph::algo::tarjan_scc;
 use specctra_core::mesadata::AccessMesadata;
 
-use crate::autorouter::{ratline::RatlineUid, scc::Scc, Autorouter, PlanarAutorouteOptions};
+use crate::autorouter::{
+    planar_autoroute::PlanarAutorouteConfiguration, ratline::RatlineUid, scc::Scc, Autorouter,
+    PlanarAutorouteOptions,
+};
+
+#[derive(Clone, Debug)]
+pub struct PlanarAutoroutePreconfigurerInput {
+    pub ratlines: Vec<RatlineUid>,
+}
 
 pub struct PresortParams {
     pub intersector_count_weight: f64,
@@ -15,28 +23,28 @@ pub struct PresortParams {
 }
 
 #[enum_dispatch]
-pub trait PresortRatlines {
+pub trait PreconfigurePlanarAutoroute {
-    fn presort_ratlines(
+    fn preconfigure(
         &self,
         autorouter: &mut Autorouter<impl AccessMesadata>,
-        ratlines: &[RatlineUid],
+        input: PlanarAutoroutePreconfigurerInput,
-    ) -> Vec<RatlineUid>;
+    ) -> PlanarAutorouteConfiguration;
 }
 
 #[enum_dispatch(PresortRatlines)]
-pub enum RatlinesPresorter {
+pub enum PlanarAutoroutePreconfigurer {
-    SccIntersectionsLength(SccIntersectionsAndLengthPresorter),
+    SccIntersectionsLength(SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer),
 }
 
 #[derive(Getters, Dissolve)]
-pub struct SccIntersectionsAndLengthPresorter {
+pub struct SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer {
     sccs: Vec<Scc>,
 }
 
-impl SccIntersectionsAndLengthPresorter {
+impl SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer {
     pub fn new(
         autorouter: &mut Autorouter<impl AccessMesadata>,
-        ratlines: &[RatlineUid],
+        input: PlanarAutoroutePreconfigurerInput,
         params: &PresortParams,
         options: &PlanarAutorouteOptions,
     ) -> Self {
@@ -46,11 +54,19 @@ impl SccIntersectionsAndLengthPresorter {
             .on_principal_layer(options.principal_layer)
             .graph()
             .clone();
-        filtered_ratsnest.retain_edges(|_g, i| ratlines.iter().any(|ratline| ratline.index == i));
+        filtered_ratsnest
+            .retain_edges(|_g, i| input.ratlines.iter().any(|ratline| ratline.index == i));
 
         let mut sccs: Vec<_> = tarjan_scc(&filtered_ratsnest)
             .into_iter()
-            .map(|node_indices| Scc::new(autorouter, ratlines, &filtered_ratsnest, node_indices))
+            .map(|node_indices| {
+                Scc::new(
+                    autorouter,
+                    &input.ratlines,
+                    &filtered_ratsnest,
+                    node_indices,
+                )
+            })
             .collect();
 
         sccs.sort_unstable_by(|a, b| {
@@ -66,22 +82,24 @@ impl SccIntersectionsAndLengthPresorter {
     }
 }
 
-impl PresortRatlines for SccIntersectionsAndLengthPresorter {
+impl PreconfigurePlanarAutoroute for SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer {
-    fn presort_ratlines(
+    fn preconfigure(
         &self,
         autorouter: &mut Autorouter<impl AccessMesadata>,
-        ratlines: &[RatlineUid],
+        input: PlanarAutoroutePreconfigurerInput,
-    ) -> Vec<RatlineUid> {
+    ) -> PlanarAutorouteConfiguration {
         let mut presorted_ratlines = vec![];
 
         for scc in self.sccs.iter() {
-            for ratline in ratlines.iter() {
+            for ratline in input.ratlines.iter() {
                 if scc.scc_ref(autorouter).contains(*ratline) {
                     presorted_ratlines.push(*ratline);
                 }
             }
         }
 
-        presorted_ratlines
+        PlanarAutorouteConfiguration {
+            ratlines: presorted_ratlines,
+        }
     }
 }

src/autorouter/planar_reconfigurator.rs

@@ -13,9 +13,11 @@ use crate::{
             PlanarAutorouteConfiguration, PlanarAutorouteConfigurationResult,
             PlanarAutorouteContinueStatus, PlanarAutorouteExecutionStepper,
         },
-        planar_reconfigurer::{PermuteRatlines, PlanarReconfigurer},
+        planar_preconfigurer::{
-        presorter::{PresortParams, PresortRatlines, SccIntersectionsAndLengthPresorter},
+            PlanarAutoroutePreconfigurerInput, PreconfigurePlanarAutoroute, PresortParams,
-        ratline::RatlineUid,
+            SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer,
+        },
+        planar_reconfigurer::{MakeNextPlanarAutorouteConfiguration, PlanarAutorouteReconfigurer},
         Autorouter, AutorouterError, PlanarAutorouteOptions,
     },
     board::edit::BoardEdit,
@@ -25,40 +27,37 @@ use crate::{
     stepper::{Abort, EstimateProgress, ReconfiguratorStatus, Reconfigure, Step},
 };
 
-#[derive(Clone, Debug)]
-pub struct PlanarAutorouteReconfiguratorInput {
-    pub ratlines: Vec<RatlineUid>,
-}
-
 pub type PlanarReconfiguratorStatus =
     ReconfiguratorStatus<PlanarAutorouteConfigurationResult, PlanarAutorouteContinueStatus>;
 
 pub struct PlanarAutorouteReconfigurator {
     stepper: PlanarAutorouteExecutionStepper,
-    reconfigurer: PlanarReconfigurer,
+    reconfigurer: PlanarAutorouteReconfigurer,
     options: PlanarAutorouteOptions,
 }
 
 impl PlanarAutorouteReconfigurator {
     pub fn new(
         autorouter: &mut Autorouter<impl AccessMesadata>,
-        input: PlanarAutorouteReconfiguratorInput,
+        input: PlanarAutoroutePreconfigurerInput,
         options: PlanarAutorouteOptions,
     ) -> Result<Self, AutorouterError> {
-        let presorter = SccIntersectionsAndLengthPresorter::new(
+        let preconfigurer = SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer::new(
             autorouter,
-            &input.ratlines,
+            input.clone(),
             &PresortParams {
                 intersector_count_weight: 1.0,
                 length_weight: 0.001,
             },
             &options,
         );
-        let preconfiguration = PlanarAutorouteConfiguration {
+        let preconfiguration = preconfigurer.preconfigure(autorouter, input);
-            ratlines: presorter.presort_ratlines(autorouter, &input.ratlines),
+        let reconfigurer = PlanarAutorouteReconfigurer::new(
-        };
+            autorouter,
-        let reconfigurer =
+            preconfiguration.clone(),
-            PlanarReconfigurer::new(autorouter, preconfiguration.clone(), presorter, &options);
+            preconfigurer,
+            &options,
+        );
 
         Ok(Self {
             stepper: PlanarAutorouteExecutionStepper::new(autorouter, preconfiguration, options)?,
@@ -89,9 +88,9 @@ impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarReconfigura
                 }
 
                 loop {
-                    let Some(permutation) = self
+                    let Some(configuration) = self
                         .reconfigurer
-                        .permute_ratlines(autorouter, &self.stepper)
+                        .next_configuration(autorouter, &self.stepper)
                     else {
                         return Ok(ControlFlow::Break(None));
                     };
@@ -99,7 +98,7 @@ impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarReconfigura
                     match self.stepper.reconfigure(
                         autorouter,
                         PlanarAutorouteConfiguration {
-                            ratlines: permutation,
+                            ratlines: configuration,
                         },
                     ) {
                         Ok(result) => {

src/autorouter/planar_reconfigurer.rs

@@ -11,7 +11,7 @@ use specctra_core::mesadata::AccessMesadata;
 use crate::{
     autorouter::{
         planar_autoroute::{PlanarAutorouteConfiguration, PlanarAutorouteExecutionStepper},
-        presorter::SccIntersectionsAndLengthPresorter,
+        planar_preconfigurer::SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer,
         ratline::RatlineUid,
         scc::Scc,
         Autorouter, PlanarAutorouteOptions,
@@ -22,49 +22,51 @@ use crate::{
 };
 
 #[enum_dispatch]
-pub trait PermuteRatlines {
+pub trait MakeNextPlanarAutorouteConfiguration {
-    fn permute_ratlines(
+    fn next_configuration(
         &mut self,
         autorouter: &mut Autorouter<impl AccessMesadata>,
         stepper: &PlanarAutorouteExecutionStepper,
     ) -> Option<Vec<RatlineUid>>;
 }
 
-#[enum_dispatch(PermuteRatlines)]
+#[enum_dispatch(MakeNextPlanarAutorouteConfiguration)]
-pub enum PlanarReconfigurer {
+pub enum PlanarAutorouteReconfigurer {
-    RatlineCuts(RatlineCutsPlanarReconfigurer),
+    RatlineCuts(RatlineCutsPlanarAutorouteReconfigurer),
-    SccPermutations(SccPermutationsPlanarReconfigurer),
+    SccPermutations(SccPermutationsPlanarAutorouteReconfigurer),
 }
 
-impl PlanarReconfigurer {
+impl PlanarAutorouteReconfigurer {
     pub fn new(
         autorouter: &mut Autorouter<impl AccessMesadata>,
         input_configuration: PlanarAutorouteConfiguration,
-        presorter: SccIntersectionsAndLengthPresorter,
+        presorter: SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer,
         options: &PlanarAutorouteOptions,
     ) -> Self {
-        PlanarReconfigurer::SccPermutations(SccPermutationsPlanarReconfigurer::new(
+        PlanarAutorouteReconfigurer::SccPermutations(
-            autorouter,
+            SccPermutationsPlanarAutorouteReconfigurer::new(
-            input_configuration,
+                autorouter,
-            presorter,
+                input_configuration,
-            options,
+                presorter,
-        ))
+                options,
+            ),
+        )
         /*RatlinesPermuter::RatlineCuts(RatlineCutsRatlinePermuter::new(
             autorouter, ratlines, presorter, options,
         ))*/
     }
 }
 
-pub struct SccPermutationsPlanarReconfigurer {
+pub struct SccPermutationsPlanarAutorouteReconfigurer {
     sccs_permutations_iter: Skip<Permutations<std::vec::IntoIter<Scc>>>,
-    input_configuration: PlanarAutorouteConfiguration,
+    initial_configuration: PlanarAutorouteConfiguration,
 }
 
-impl SccPermutationsPlanarReconfigurer {
+impl SccPermutationsPlanarAutorouteReconfigurer {
     pub fn new(
         _autorouter: &mut Autorouter<impl AccessMesadata>,
         input_configuration: PlanarAutorouteConfiguration,
-        presorter: SccIntersectionsAndLengthPresorter,
+        presorter: SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer,
         _options: &PlanarAutorouteOptions,
     ) -> Self {
         // TODO: Instead of instantiating presorter again here, get it from
@@ -74,13 +76,13 @@ impl SccPermutationsPlanarReconfigurer {
 
         Self {
             sccs_permutations_iter: sccs.into_iter().permutations(sccs_len).skip(1),
-            input_configuration,
+            initial_configuration: input_configuration,
         }
     }
 }
 
-impl PermuteRatlines for SccPermutationsPlanarReconfigurer {
+impl MakeNextPlanarAutorouteConfiguration for SccPermutationsPlanarAutorouteReconfigurer {
-    fn permute_ratlines(
+    fn next_configuration(
         &mut self,
         autorouter: &mut Autorouter<impl AccessMesadata>,
         _stepper: &PlanarAutorouteExecutionStepper,
@@ -89,7 +91,7 @@ impl PermuteRatlines for SccPermutationsPlanarReconfigurer {
         let mut ratlines = vec![];
 
         for scc in scc_permutation {
-            for ratline in self.input_configuration.ratlines.iter() {
+            for ratline in self.initial_configuration.ratlines.iter() {
                 if scc.node_indices().contains(
                     &autorouter
                         .ratsnests()
@@ -116,15 +118,15 @@ impl PermuteRatlines for SccPermutationsPlanarReconfigurer {
     }
 }
 
-pub struct RatlineCutsPlanarReconfigurer {
+pub struct RatlineCutsPlanarAutorouteReconfigurer {
     //sccs: Vec<Vec<NodeIndex<usize>>>,
 }
 
-impl RatlineCutsPlanarReconfigurer {
+impl RatlineCutsPlanarAutorouteReconfigurer {
     pub fn new(
         _autorouter: &mut Autorouter<impl AccessMesadata>,
         _ratlines: Vec<RatlineUid>,
-        _presorter: SccIntersectionsAndLengthPresorter,
+        _presorter: SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer,
         _options: &PlanarAutorouteOptions,
     ) -> Self {
         /*Self {
@@ -134,8 +136,8 @@ impl RatlineCutsPlanarReconfigurer {
     }
 }
 
-impl PermuteRatlines for RatlineCutsPlanarReconfigurer {
+impl MakeNextPlanarAutorouteConfiguration for RatlineCutsPlanarAutorouteReconfigurer {
-    fn permute_ratlines(
+    fn next_configuration(
         &mut self,
         autorouter: &mut Autorouter<impl AccessMesadata>,
         stepper: &PlanarAutorouteExecutionStepper,