From 2e507b7cab8ed19ff7b11b9e3f377d2188a29644 Mon Sep 17 00:00:00 2001
From: Mikolaj Wielgus <wielgusmikolaj@gmail.com>
Date: Tue, 4 Nov 2025 03:22:46 +0100
Subject: [PATCH] refactor(autorouter/multilayer_reconfigurer): Process planar
 autoroute result in separate method

---
 src/autorouter/multilayer_reconfigurator.rs | 10 +++----
 src/autorouter/multilayer_reconfigurer.rs   | 32 +++++++++++++++------
 2 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/src/autorouter/multilayer_reconfigurator.rs b/src/autorouter/multilayer_reconfigurator.rs
index 7f71a3c..ab87a11 100644
--- a/src/autorouter/multilayer_reconfigurator.rs
+++ b/src/autorouter/multilayer_reconfigurator.rs
@@ -74,7 +74,7 @@ impl MultilayerAutorouteReconfigurator {
                 preconfiguration,
                 options,
             )?,
-            reconfiguration_trigger: SmaRateReconfigurationTrigger::new(10, 0.5, 0.5),
+            reconfiguration_trigger: SmaRateReconfigurationTrigger::new(4, 0.5, 0.5),
             reconfigurer,
             options,
         })
@@ -90,10 +90,10 @@ impl MultilayerAutorouteReconfigurator {
         self.reconfiguration_trigger = SmaRateReconfigurationTrigger::new(4, 0.5, 0.5);
 
         loop {
-            let configuration = match self
-                .reconfigurer
-                .next_configuration(autorouter, planar_result.clone())
-            {
+            self.reconfigurer
+                .process_planar_result(autorouter, planar_result.clone());
+
+            let configuration = match self.reconfigurer.next_configuration(autorouter) {
                 ControlFlow::Continue(()) => {
                     return Ok(ControlFlow::Continue(ReconfiguratorStatus::Running(
                         ReconfiguratorStatus::Reconfigured(planar_result?),
diff --git a/src/autorouter/multilayer_reconfigurer.rs b/src/autorouter/multilayer_reconfigurer.rs
index 4016bc5..54f3ff2 100644
--- a/src/autorouter/multilayer_reconfigurer.rs
+++ b/src/autorouter/multilayer_reconfigurer.rs
@@ -16,10 +16,15 @@ use crate::autorouter::{
 
 #[enum_dispatch]
 pub trait MakeNextMultilayerAutorouteConfiguration {
-    fn next_configuration(
+    fn process_planar_result(
         &mut self,
         autorouter: &Autorouter<impl AccessMesadata>,
         planar_result: Result<PlanarAutorouteConfigurationStatus, AutorouterError>,
+    );
+
+    fn next_configuration(
+        &mut self,
+        autorouter: &Autorouter<impl AccessMesadata>,
     ) -> ControlFlow<Option<MultilayerAutorouteConfiguration>>;
 }
 
@@ -53,15 +58,15 @@ impl IncrementFailedRatlineLayersMultilayerAutorouteReconfigurer {
 impl MakeNextMultilayerAutorouteConfiguration
     for IncrementFailedRatlineLayersMultilayerAutorouteReconfigurer
 {
-    fn next_configuration(
+    fn process_planar_result(
         &mut self,
-        autorouter: &Autorouter<impl AccessMesadata>,
+        _autorouter: &Autorouter<impl AccessMesadata>,
         planar_result: Result<PlanarAutorouteConfigurationStatus, AutorouterError>,
-    ) -> ControlFlow<Option<MultilayerAutorouteConfiguration>> {
+    ) {
         self.planar_autoroute_reconfiguration_count += 1;
 
         let Ok(planar_status) = planar_result else {
-            return ControlFlow::Break(None);
+            return;
         };
 
         self.maybe_last_planar_status = Some(planar_status.clone());
@@ -73,7 +78,12 @@ impl MakeNextMultilayerAutorouteConfiguration
         {
             self.maybe_best_planar_status = Some(planar_status.clone());
         }
+    }
 
+    fn next_configuration(
+        &mut self,
+        autorouter: &Autorouter<impl AccessMesadata>,
+    ) -> ControlFlow<Option<MultilayerAutorouteConfiguration>> {
         if self.planar_autoroute_reconfiguration_count < 10 {
             return ControlFlow::Continue(());
         }
@@ -82,17 +92,21 @@ impl MakeNextMultilayerAutorouteConfiguration
 
         let mut new_anterouter_plan = self.last_configuration.plan.clone();
 
+        let Some(ref last_planar_status) = self.maybe_last_planar_status else {
+            return ControlFlow::Break(None);
+        };
+
         if let Some(ref best_planar_status) = self.maybe_best_planar_status {
-            for ratline_index in
-                best_planar_status.costs.lengths.len()..planar_status.configuration.ratlines.len()
+            for ratline_index in best_planar_status.costs.lengths.len()
+                ..last_planar_status.configuration.ratlines.len()
             {
                 *new_anterouter_plan
                     .layer_map
-                    .get_mut(&planar_status.configuration.ratlines[ratline_index])
+                    .get_mut(&last_planar_status.configuration.ratlines[ratline_index])
                     .unwrap() += 1;
                 *new_anterouter_plan
                     .layer_map
-                    .get_mut(&planar_status.configuration.ratlines[ratline_index])
+                    .get_mut(&last_planar_status.configuration.ratlines[ratline_index])
                     .unwrap() %= autorouter.board().layout().drawing().layer_count();
             }
         }