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

refactor(autorouter/multilayer_reconfigurer): Move multilayer reconfiguration trigger code

This commit is contained in:
Mikolaj Wielgus 2025-10-27 22:55:53 +01:00
parent 813345863e
commit 81e27f0f60
5 changed files with 96 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/autorouter/multilayer_autoroute.rs
View File

@ -12,7 +12,9 @@ use crate::{
anterouter::{Anterouter, AnterouterOptions, AnterouterPlan},
invoker::GetDebugOverlayData,
planar_preconfigurer::PlanarAutoroutePreconfigurerInput,
planar_reconfigurator::{PlanarAutorouteReconfigurator, PlanarReconfiguratorStatus},
planar_reconfigurator::{
PlanarAutorouteReconfigurator, PlanarAutorouteReconfiguratorStatus,
},
Autorouter, AutorouterError, PlanarAutorouteOptions,
},
board::edit::BoardEdit,
@ -66,7 +68,7 @@ impl MultilayerAutorouteExecutionStepper {
}
}
impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarReconfiguratorStatus>
impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarAutorouteReconfiguratorStatus>
for MultilayerAutorouteExecutionStepper
{
type Error = AutorouterError;
@ -74,7 +76,8 @@ impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarReconfigura
fn step(
&mut self,
autorouter: &mut Autorouter<M>,
) -> Result<ControlFlow<Option<BoardEdit>, PlanarReconfiguratorStatus>, AutorouterError> {
) -> Result<ControlFlow<Option<BoardEdit>, PlanarAutorouteReconfiguratorStatus>, AutorouterError>
{
match self.planar.step(autorouter) {
Ok(ControlFlow::Break(Some(edit))) => {
self.anteroute_edit.merge(edit);

52
src/autorouter/multilayer_reconfigurator.rs
View File

@ -16,9 +16,13 @@ use crate::{
multilayer_preconfigurer::{
MultilayerAutoroutePreconfigurerInput, MultilayerPreconfigurer,
},
multilayer_reconfigurer::MultilayerReconfigurer,
multilayer_reconfigurer::{
MakeNextMultilayerAutorouteConfiguration, MultilayerAutorouteReconfigurer,
UniformRandomLayersMultilayerAutorouteReconfigurer,
},
planar_autoroute::PlanarAutorouteConfigurationStatus,
planar_preconfigurer::PlanarAutoroutePreconfigurerInput,
planar_reconfigurator::PlanarReconfiguratorStatus,
planar_reconfigurator::PlanarAutorouteReconfiguratorStatus,
Autorouter, AutorouterError,
},
board::edit::BoardEdit,
@ -28,14 +32,13 @@ use crate::{
stepper::{Abort, EstimateProgress, ReconfiguratorStatus, Reconfigure, Step},
};
pub type MultilayerReconfiguratorStatus = ReconfiguratorStatus<(), PlanarReconfiguratorStatus>;
pub type MultilayerReconfiguratorStatus =
ReconfiguratorStatus<(), PlanarAutorouteReconfiguratorStatus>;
pub struct MultilayerAutorouteReconfigurator {
stepper: MultilayerAutorouteExecutionStepper,
reconfigurer: MultilayerReconfigurer,
reconfigurer: MultilayerAutorouteReconfigurer,
options: MultilayerAutorouteOptions,
// TODO: Obviously, we need something more sophisticated here.
planar_autoroute_reconfiguration_count: u64,
}
impl MultilayerAutorouteReconfigurator {
@ -53,8 +56,13 @@ impl MultilayerAutorouteReconfigurator {
terminating_dot_map: BTreeMap::new(),
},
};
let reconfigurer =
MultilayerReconfigurer::new(autorouter, preconfiguration.clone(), &options);
let reconfigurer = MultilayerAutorouteReconfigurer::UniformRandomLayers(
UniformRandomLayersMultilayerAutorouteReconfigurer::new(
autorouter,
preconfiguration.clone(),
&options,
),
);
Ok(Self {
stepper: MultilayerAutorouteExecutionStepper::new(
@ -64,18 +72,27 @@ impl MultilayerAutorouteReconfigurator {
)?,
reconfigurer,
options,
planar_autoroute_reconfiguration_count: 0,
})
}
fn reconfigure<M: AccessMesadata>(
&mut self,
autorouter: &mut Autorouter<M>,
planar_result: Result<PlanarAutorouteConfigurationStatus, AutorouterError>,
) -> Result<ControlFlow<Option<BoardEdit>, MultilayerReconfiguratorStatus>, AutorouterError>
{
loop {
let Some(configuration) = self.reconfigurer.next_configuration(autorouter) else {
return Ok(ControlFlow::Break(None));
let configuration = match self
.reconfigurer
.next_configuration(autorouter, planar_result.clone())
{
ControlFlow::Continue(()) => {
return Ok(ControlFlow::Continue(ReconfiguratorStatus::Running(
ReconfiguratorStatus::Reconfigured(planar_result?),
)))
}
ControlFlow::Break(None) => return Ok(ControlFlow::Break(None)),
ControlFlow::Break(Some(configuration)) => configuration,
};
match self.stepper.reconfigure(autorouter, configuration) {
@ -109,18 +126,9 @@ impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, MultilayerReconfi
)))
}
Ok(ControlFlow::Continue(ReconfiguratorStatus::Reconfigured(status))) => {
self.planar_autoroute_reconfiguration_count += 1;
if self.planar_autoroute_reconfiguration_count >= 100 {
self.planar_autoroute_reconfiguration_count = 0;
self.reconfigure(autorouter)
} else {
Ok(ControlFlow::Continue(ReconfiguratorStatus::Running(
ReconfiguratorStatus::Reconfigured(status),
)))
}
self.reconfigure(autorouter, Ok(status))
}
Err(_) => self.reconfigure(autorouter),
Err(err) => self.reconfigure(autorouter, Err(err)),
}
}
}

68
src/autorouter/multilayer_reconfigurer.rs
View File

@ -2,33 +2,73 @@
//
// SPDX-License-Identifier: MIT
use std::{collections::BTreeMap, time::SystemTime};
use std::{collections::BTreeMap, ops::ControlFlow, time::SystemTime};
use enum_dispatch::enum_dispatch;
use specctra_core::mesadata::AccessMesadata;
use crate::autorouter::{
multilayer_autoroute::{MultilayerAutorouteConfiguration, MultilayerAutorouteOptions},
planar_autoroute::PlanarAutorouteConfigurationStatus,
planar_preconfigurer::PlanarAutoroutePreconfigurerInput,
Autorouter,
Autorouter, AutorouterError,
};
pub struct MultilayerReconfigurer {
preconfiguration: MultilayerAutorouteConfiguration,
#[enum_dispatch]
pub trait MakeNextMultilayerAutorouteConfiguration {
fn next_configuration(
&mut self,
autorouter: &Autorouter<impl AccessMesadata>,
planar_result: Result<PlanarAutorouteConfigurationStatus, AutorouterError>,
) -> ControlFlow<Option<MultilayerAutorouteConfiguration>>;
}
impl MultilayerReconfigurer {
#[enum_dispatch(MakeNextMultilayerAutorouteConfiguration)]
pub enum MultilayerAutorouteReconfigurer {
UniformRandomLayers(UniformRandomLayersMultilayerAutorouteReconfigurer),
}
pub struct UniformRandomLayersMultilayerAutorouteReconfigurer {
preconfiguration: MultilayerAutorouteConfiguration,
planar_autoroute_reconfiguration_count: u64,
}
impl UniformRandomLayersMultilayerAutorouteReconfigurer {
pub fn new(
_autorouter: &Autorouter<impl AccessMesadata>,
preconfiguration: MultilayerAutorouteConfiguration,
_options: &MultilayerAutorouteOptions,
) -> Self {
Self { preconfiguration }
Self {
preconfiguration,
planar_autoroute_reconfiguration_count: 0,
}
}
pub fn next_configuration(
fn crude_random_bit() -> usize {
let duration_since_epoch = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap();
let timestamp_nanos = duration_since_epoch.as_nanos();
(timestamp_nanos % 2) as usize
}
}
impl MakeNextMultilayerAutorouteConfiguration
for UniformRandomLayersMultilayerAutorouteReconfigurer
{
fn next_configuration(
&mut self,
_autorouter: &Autorouter<impl AccessMesadata>,
) -> Option<MultilayerAutorouteConfiguration> {
planar_result: Result<PlanarAutorouteConfigurationStatus, AutorouterError>,
) -> ControlFlow<Option<MultilayerAutorouteConfiguration>> {
if self.planar_autoroute_reconfiguration_count < 100 {
self.planar_autoroute_reconfiguration_count += 1;
return ControlFlow::Continue(());
}
self.planar_autoroute_reconfiguration_count = 0;
let mut new_anterouter_plan = self.preconfiguration.plan.clone();
new_anterouter_plan.layer_map = self
.preconfiguration
@ -40,20 +80,12 @@ impl MultilayerReconfigurer {
.map(|(_, ratline)| (*ratline, Self::crude_random_bit()))
.collect();
Some(MultilayerAutorouteConfiguration {
ControlFlow::Break(Some(MultilayerAutorouteConfiguration {
plan: new_anterouter_plan,
planar: PlanarAutoroutePreconfigurerInput {
ratlines: self.preconfiguration.planar.ratlines.clone(),
terminating_dot_map: BTreeMap::new(),
},
})
}
fn crude_random_bit() -> usize {
let duration_since_epoch = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap();
let timestamp_nanos = duration_since_epoch.as_nanos();
(timestamp_nanos % 2) as usize
}))
}
}

8
src/autorouter/planar_autoroute.rs
View File

@ -62,7 +62,7 @@ pub struct PlanarAutorouteCosts {
}
#[derive(Clone, Debug)]
pub struct PlanarAutorouteConfigurationResult {
pub struct PlanarAutorouteConfigurationStatus {
pub configuration: PlanarAutorouteConfiguration,
pub costs: PlanarAutorouteCosts,
}
@ -275,13 +275,13 @@ impl<M: AccessMesadata> Abort<Autorouter<M>> for PlanarAutorouteExecutionStepper
impl<M: AccessMesadata> Reconfigure<Autorouter<M>> for PlanarAutorouteExecutionStepper {
type Configuration = PlanarAutorouteConfiguration;
type Output = Result<PlanarAutorouteConfigurationResult, AutorouterError>;
type Output = Result<PlanarAutorouteConfigurationStatus, AutorouterError>;
fn reconfigure(
&mut self,
autorouter: &mut Autorouter<M>,
new_configuration: PlanarAutorouteConfiguration,
) -> Result<PlanarAutorouteConfigurationResult, AutorouterError> {
) -> Result<PlanarAutorouteConfigurationStatus, AutorouterError> {
let Some(new_index) = new_configuration
.ratlines
.iter()
@ -291,7 +291,7 @@ impl<M: AccessMesadata> Reconfigure<Autorouter<M>> for PlanarAutorouteExecutionS
return Err(AutorouterError::NothingToUndoForReconfiguration);
};
let result = PlanarAutorouteConfigurationResult {
let result = PlanarAutorouteConfigurationStatus {
configuration: std::mem::replace(&mut self.configuration, new_configuration),
costs: PlanarAutorouteCosts {
lengths: vec![], // TODO.

11
src/autorouter/planar_reconfigurator.rs
View File

@ -10,7 +10,7 @@ use crate::{
autorouter::{
invoker::GetDebugOverlayData,
planar_autoroute::{
PlanarAutorouteConfigurationResult, PlanarAutorouteContinueStatus,
PlanarAutorouteConfigurationStatus, PlanarAutorouteContinueStatus,
PlanarAutorouteExecutionStepper,
},
planar_preconfigurer::{
@ -27,8 +27,8 @@ use crate::{
stepper::{Abort, EstimateProgress, ReconfiguratorStatus, Reconfigure, Step},
};
pub type PlanarReconfiguratorStatus =
ReconfiguratorStatus<PlanarAutorouteConfigurationResult, PlanarAutorouteContinueStatus>;
pub type PlanarAutorouteReconfiguratorStatus =
ReconfiguratorStatus<PlanarAutorouteConfigurationStatus, PlanarAutorouteContinueStatus>;
pub struct PlanarAutorouteReconfigurator {
stepper: PlanarAutorouteExecutionStepper,
@ -68,7 +68,7 @@ impl PlanarAutorouteReconfigurator {
}
}
impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarReconfiguratorStatus>
impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarAutorouteReconfiguratorStatus>
for PlanarAutorouteReconfigurator
{
type Error = AutorouterError;
@ -76,7 +76,8 @@ impl<M: AccessMesadata> Step<Autorouter<M>, Option<BoardEdit>, PlanarReconfigura
fn step(
&mut self,
autorouter: &mut Autorouter<M>,
) -> Result<ControlFlow<Option<BoardEdit>, PlanarReconfiguratorStatus>, AutorouterError> {
) -> Result<ControlFlow<Option<BoardEdit>, PlanarAutorouteReconfiguratorStatus>, AutorouterError>
{
match self.stepper.step(autorouter) {
Ok(ControlFlow::Break(maybe_edit)) => Ok(ControlFlow::Break(maybe_edit)),
Ok(ControlFlow::Continue(status)) => {