berkus
/
topola
mirror of https://codeberg.org/topola/topola.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

This commit is contained in:
Mikolaj Wielgus 2025-10-23 16:40:19 +02:00
parent 0311aee613
commit 5c39bd60de
10 changed files with 123 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
committed.toml
View File

@ -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",

16
src/autorouter/autorouter.rs
View File

@ -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<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,

4
src/autorouter/mod.rs
View File

@ -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;

8
src/autorouter/multilayer_autoroute.rs
View File

@ -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)]

19
src/autorouter/planner.rs → src/autorouter/multilayer_preconfigurer.rs
View File

@ -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 {
pub fn new(autorouter: &Autorouter<impl AccessMesadata>, ratlines: &[RatlineUid]) -> Self {
impl MultilayerPreconfigurer {
pub fn new(
autorouter: &Autorouter<impl AccessMesadata>,
input: MultilayerAutoroutePreconfigurerInput,
) -> Self {
Self::new_from_layer_map(
autorouter,
ratlines,
ratlines
&input.ratlines,
input
.ratlines
.iter()
.enumerate()
.map(|(i, ratline)| (*ratline, i % 2))

18
src/autorouter/multilayer_reconfigurator.rs
View File

@ -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<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(),
},
};

6
src/autorouter/multilayer_reconfigurer.rs
View File

@ -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<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

54
src/autorouter/presorter.rs → src/autorouter/planar_preconfigurer.rs
View File

@ -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 {
fn presort_ratlines(
pub trait PreconfigurePlanarAutoroute {
fn preconfigure(
&self,
autorouter: &mut Autorouter<impl AccessMesadata>,
ratlines: &[RatlineUid],
) -> Vec<RatlineUid>;
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<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 {
fn presort_ratlines(
impl PreconfigurePlanarAutoroute for SccIntersectionsAndLengthRatlinePlanarAutoroutePreconfigurer {
fn preconfigure(
&self,
autorouter: &mut Autorouter<impl AccessMesadata>,
ratlines: &[RatlineUid],
) -> Vec<RatlineUid> {
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,
}
}
}

39
src/autorouter/planar_reconfigurator.rs
View File

@ -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<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 {
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<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) => {

58
src/autorouter/planar_reconfigurer.rs
View File

@ -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<impl AccessMesadata>,
stepper: &PlanarAutorouteExecutionStepper,
) -> Option<Vec<RatlineUid>>;
}
#[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<impl AccessMesadata>,
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<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 {
fn permute_ratlines(
impl MakeNextPlanarAutorouteConfiguration for SccPermutationsPlanarAutorouteReconfigurer {
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 {
fn permute_ratlines(
impl MakeNextPlanarAutorouteConfiguration for RatlineCutsPlanarAutorouteReconfigurer {
fn next_configuration(
&mut self,
autorouter: &mut Autorouter<impl AccessMesadata>,
stepper: &PlanarAutorouteExecutionStepper,