diff --git a/committed.toml b/committed.toml index 6629fd7..3c065d9 100644 --- a/committed.toml +++ b/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", diff --git a/src/autorouter/autorouter.rs b/src/autorouter/autorouter.rs index ed6f4cf..70e1fc1 100644 --- a/src/autorouter/autorouter.rs +++ b/src/autorouter/autorouter.rs @@ -13,13 +13,10 @@ use thiserror::Error; use crate::{ autorouter::{ multilayer_autoroute::MultilayerAutorouteOptions, - multilayer_reconfigurator::{ - MultilayerAutorouteReconfigurator, MultilayerAutorouteReconfiguratorInput, - }, - planar_reconfigurator::{ - PlanarAutorouteReconfigurator, PlanarAutorouteReconfiguratorInput, - }, - ratsnests::Ratsnests, + multilayer_preconfigurer::MultilayerAutoroutePreconfigurerInput, + multilayer_reconfigurator::MultilayerAutorouteReconfigurator, + planar_preconfigurer::PlanarAutoroutePreconfigurerInput, + planar_reconfigurator::PlanarAutorouteReconfigurator, 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 Autorouter { ) -> Result { MultilayerAutorouteReconfigurator::new( self, - MultilayerAutorouteReconfiguratorInput { + MultilayerAutoroutePreconfigurerInput { ratlines: self.selected_ratlines(selection, options.planar.principal_layer), }, options, @@ -139,7 +135,7 @@ impl Autorouter { ) -> Result { PlanarAutorouteReconfigurator::new( self, - PlanarAutorouteReconfiguratorInput { + PlanarAutoroutePreconfigurerInput { ratlines: self.selected_planar_ratlines(selection, options.principal_layer), }, options, diff --git a/src/autorouter/mod.rs b/src/autorouter/mod.rs index 18d2d20..c12113e 100644 --- a/src/autorouter/mod.rs +++ b/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; diff --git a/src/autorouter/multilayer_autoroute.rs b/src/autorouter/multilayer_autoroute.rs index fa97479..4f1a643 100644 --- a/src/autorouter/multilayer_autoroute.rs +++ b/src/autorouter/multilayer_autoroute.rs @@ -11,10 +11,8 @@ use crate::{ autorouter::{ anterouter::{Anterouter, AnterouterOptions, AnterouterPlan}, invoker::GetDebugOverlayData, - planar_reconfigurator::{ - PlanarAutorouteReconfigurator, PlanarAutorouteReconfiguratorInput, - PlanarReconfiguratorStatus, - }, + planar_preconfigurer::PlanarAutoroutePreconfigurerInput, + planar_reconfigurator::{PlanarAutorouteReconfigurator, 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)] diff --git a/src/autorouter/planner.rs b/src/autorouter/multilayer_preconfigurer.rs similarity index 89% rename from src/autorouter/planner.rs rename to src/autorouter/multilayer_preconfigurer.rs index 0431aa9..66b8728 100644 --- a/src/autorouter/planner.rs +++ b/src/autorouter/multilayer_preconfigurer.rs @@ -21,17 +21,26 @@ use crate::{ graph::MakeRef, }; +#[derive(Clone, Debug)] +pub struct MultilayerAutoroutePreconfigurerInput { + pub ratlines: Vec, +} + #[derive(Getters)] -pub struct Planner { +pub struct MultilayerPreconfigurer { plan: AnterouterPlan, } -impl Planner { - pub fn new(autorouter: &Autorouter, ratlines: &[RatlineUid]) -> Self { +impl MultilayerPreconfigurer { + pub fn new( + autorouter: &Autorouter, + input: MultilayerAutoroutePreconfigurerInput, + ) -> Self { Self::new_from_layer_map( autorouter, - ratlines, - ratlines + &input.ratlines, + input + .ratlines .iter() .enumerate() .map(|(i, ratline)| (*ratline, i % 2)) diff --git a/src/autorouter/multilayer_reconfigurator.rs b/src/autorouter/multilayer_reconfigurator.rs index 67e534e..94469de 100644 --- a/src/autorouter/multilayer_reconfigurator.rs +++ b/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}, - planner::Planner, - ratline::RatlineUid, + planar_preconfigurer::PlanarAutoroutePreconfigurerInput, + planar_reconfigurator::PlanarReconfiguratorStatus, Autorouter, AutorouterError, }, board::edit::BoardEdit, @@ -26,10 +28,6 @@ use crate::{ stepper::{Abort, EstimateProgress, ReconfiguratorStatus, Reconfigure, Step}, }; -pub struct MultilayerAutorouteReconfiguratorInput { - pub ratlines: Vec, -} - pub type MultilayerReconfiguratorStatus = ReconfiguratorStatus<(), PlanarReconfiguratorStatus>; pub struct MultilayerAutorouteReconfigurator { @@ -43,13 +41,13 @@ pub struct MultilayerAutorouteReconfigurator { impl MultilayerAutorouteReconfigurator { pub fn new( autorouter: &mut Autorouter, - input: MultilayerAutorouteReconfiguratorInput, + input: MultilayerAutoroutePreconfigurerInput, options: MultilayerAutorouteOptions, ) -> Result { - 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(), }, }; diff --git a/src/autorouter/multilayer_reconfigurer.rs b/src/autorouter/multilayer_reconfigurer.rs index 92db76e..d01d393 100644 --- a/src/autorouter/multilayer_reconfigurer.rs +++ b/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, - ratline::RatlineUid, Autorouter, + anterouter::AnterouterPlan, multilayer_autoroute::MultilayerAutorouteOptions, + multilayer_preconfigurer::MultilayerPreconfigurer, ratline::RatlineUid, Autorouter, }; pub struct MultilayerReconfigurer { @@ -30,7 +30,7 @@ impl MultilayerReconfigurer { &mut self, autorouter: &Autorouter, ) -> Option { - let planner = Planner::new_from_layer_map( + let planner = MultilayerPreconfigurer::new_from_layer_map( autorouter, &self.original_ratlines, self.original_ratlines diff --git a/src/autorouter/presorter.rs b/src/autorouter/planar_preconfigurer.rs similarity index 53% rename from src/autorouter/presorter.rs rename to src/autorouter/planar_preconfigurer.rs index d738736..20dd912 100644 --- a/src/autorouter/presorter.rs +++ b/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, +} pub struct PresortParams { pub intersector_count_weight: f64, @@ -15,28 +23,28 @@ pub struct PresortParams { } #[enum_dispatch] -pub trait PresortRatlines { - fn presort_ratlines( +pub trait PreconfigurePlanarAutoroute { + fn preconfigure( &self, autorouter: &mut Autorouter, - ratlines: &[RatlineUid], - ) -> Vec; + input: PlanarAutoroutePreconfigurerInput, + ) -> PlanarAutorouteConfiguration; } #[enum_dispatch(PresortRatlines)] -pub enum RatlinesPresorter { - SccIntersectionsLength(SccIntersectionsAndLengthPresorter), +pub enum PlanarAutoroutePreconfigurer { + SccIntersectionsLength(SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer), } #[derive(Getters, Dissolve)] -pub struct SccIntersectionsAndLengthPresorter { +pub struct SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer { sccs: Vec, } -impl SccIntersectionsAndLengthPresorter { +impl SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer { pub fn new( autorouter: &mut Autorouter, - 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 { - fn presort_ratlines( +impl PreconfigurePlanarAutoroute for SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer { + fn preconfigure( &self, autorouter: &mut Autorouter, - ratlines: &[RatlineUid], - ) -> Vec { + input: PlanarAutoroutePreconfigurerInput, + ) -> 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, + } } } diff --git a/src/autorouter/planar_reconfigurator.rs b/src/autorouter/planar_reconfigurator.rs index 230f1ac..271b1f4 100644 --- a/src/autorouter/planar_reconfigurator.rs +++ b/src/autorouter/planar_reconfigurator.rs @@ -13,9 +13,11 @@ use crate::{ PlanarAutorouteConfiguration, PlanarAutorouteConfigurationResult, PlanarAutorouteContinueStatus, PlanarAutorouteExecutionStepper, }, - planar_reconfigurer::{PermuteRatlines, PlanarReconfigurer}, - presorter::{PresortParams, PresortRatlines, SccIntersectionsAndLengthPresorter}, - ratline::RatlineUid, + planar_preconfigurer::{ + PlanarAutoroutePreconfigurerInput, PreconfigurePlanarAutoroute, PresortParams, + 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, -} - pub type PlanarReconfiguratorStatus = ReconfiguratorStatus; pub struct PlanarAutorouteReconfigurator { stepper: PlanarAutorouteExecutionStepper, - reconfigurer: PlanarReconfigurer, + reconfigurer: PlanarAutorouteReconfigurer, options: PlanarAutorouteOptions, } impl PlanarAutorouteReconfigurator { pub fn new( autorouter: &mut Autorouter, - input: PlanarAutorouteReconfiguratorInput, + input: PlanarAutoroutePreconfigurerInput, options: PlanarAutorouteOptions, ) -> Result { - 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 { - ratlines: presorter.presort_ratlines(autorouter, &input.ratlines), - }; - let reconfigurer = - PlanarReconfigurer::new(autorouter, preconfiguration.clone(), presorter, &options); + let preconfiguration = preconfigurer.preconfigure(autorouter, input); + let reconfigurer = PlanarAutorouteReconfigurer::new( + autorouter, + preconfiguration.clone(), + preconfigurer, + &options, + ); Ok(Self { stepper: PlanarAutorouteExecutionStepper::new(autorouter, preconfiguration, options)?, @@ -89,9 +88,9 @@ impl Step, Option, 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 Step, Option, PlanarReconfigura match self.stepper.reconfigure( autorouter, PlanarAutorouteConfiguration { - ratlines: permutation, + ratlines: configuration, }, ) { Ok(result) => { diff --git a/src/autorouter/planar_reconfigurer.rs b/src/autorouter/planar_reconfigurer.rs index 4d12a2f..ccbe7ea 100644 --- a/src/autorouter/planar_reconfigurer.rs +++ b/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 { - fn permute_ratlines( +pub trait MakeNextPlanarAutorouteConfiguration { + fn next_configuration( &mut self, autorouter: &mut Autorouter, stepper: &PlanarAutorouteExecutionStepper, ) -> Option>; } -#[enum_dispatch(PermuteRatlines)] -pub enum PlanarReconfigurer { - RatlineCuts(RatlineCutsPlanarReconfigurer), - SccPermutations(SccPermutationsPlanarReconfigurer), +#[enum_dispatch(MakeNextPlanarAutorouteConfiguration)] +pub enum PlanarAutorouteReconfigurer { + RatlineCuts(RatlineCutsPlanarAutorouteReconfigurer), + SccPermutations(SccPermutationsPlanarAutorouteReconfigurer), } -impl PlanarReconfigurer { +impl PlanarAutorouteReconfigurer { pub fn new( autorouter: &mut Autorouter, input_configuration: PlanarAutorouteConfiguration, - presorter: SccIntersectionsAndLengthPresorter, + presorter: SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer, options: &PlanarAutorouteOptions, ) -> Self { - PlanarReconfigurer::SccPermutations(SccPermutationsPlanarReconfigurer::new( - autorouter, - input_configuration, - presorter, - options, - )) + PlanarAutorouteReconfigurer::SccPermutations( + SccPermutationsPlanarAutorouteReconfigurer::new( + autorouter, + input_configuration, + presorter, + options, + ), + ) /*RatlinesPermuter::RatlineCuts(RatlineCutsRatlinePermuter::new( autorouter, ratlines, presorter, options, ))*/ } } -pub struct SccPermutationsPlanarReconfigurer { +pub struct SccPermutationsPlanarAutorouteReconfigurer { sccs_permutations_iter: Skip>>, - input_configuration: PlanarAutorouteConfiguration, + initial_configuration: PlanarAutorouteConfiguration, } -impl SccPermutationsPlanarReconfigurer { +impl SccPermutationsPlanarAutorouteReconfigurer { pub fn new( _autorouter: &mut Autorouter, 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 { - fn permute_ratlines( +impl MakeNextPlanarAutorouteConfiguration for SccPermutationsPlanarAutorouteReconfigurer { + fn next_configuration( &mut self, autorouter: &mut Autorouter, _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>>, } -impl RatlineCutsPlanarReconfigurer { +impl RatlineCutsPlanarAutorouteReconfigurer { pub fn new( _autorouter: &mut Autorouter, _ratlines: Vec, - _presorter: SccIntersectionsAndLengthPresorter, + _presorter: SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer, _options: &PlanarAutorouteOptions, ) -> Self { /*Self { @@ -134,8 +136,8 @@ impl RatlineCutsPlanarReconfigurer { } } -impl PermuteRatlines for RatlineCutsPlanarReconfigurer { - fn permute_ratlines( +impl MakeNextPlanarAutorouteConfiguration for RatlineCutsPlanarAutorouteReconfigurer { + fn next_configuration( &mut self, autorouter: &mut Autorouter, stepper: &PlanarAutorouteExecutionStepper,