PERF-2 P0: intra-step profiler — StepTimers on the overset solver (RTX_PROFILE; overlap build / predictors / patch BiCGSTAB / background Poisson with its setup-vs-iterate split / round exchange / apply / end exchange), PoissonSolution carries setup_ns and iterate_ns, the harness times advance / restore / snapshot / load sampling / force / FEA predictor and prints the wall split of the coupled phase; no clock is read when profiling is off; the reclassified/step progress denominator fixed (was ×4)

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Claude-Session: https://claude.ai/code/session_01YJPeT6WA2e7YvAnS875AHL

crates/specialized/rtx-cfd/src/solvers/incompressible/curvilinear/projection.rs

@@ -6,7 +6,7 @@
 use super::{CurvilinearPisoSolver, PatchField, PressureSystem, SideBc, StepGeometry};
 use crate::mesh::PatchSide;
 use crate::solvers::incompressible::sparse_bicgstab::{
-    bicgstab_jacobi, project_mean, BicgstabResult, CsrMatrix,
+    BicgstabResult, CsrMatrix, bicgstab_jacobi, project_mean,
 };
 
 impl CurvilinearPisoSolver {

crates/specialized/rtx-cfd/src/solvers/incompressible/embedded/mod.rs

@@ -41,7 +41,7 @@ mod projection;
 use super::ale::{AleBoundaries, SideBoundary};
 use super::embedded_body::{EmbeddedBody, EmbeddedMask, FaceKind};
 use super::poisson::{
-    solve_multigrid_pcg, MgPrecision, MultigridParameters, PoissonProblem, PoissonSolverKind,
+    MgPrecision, MultigridParameters, PoissonProblem, PoissonSolverKind, solve_multigrid_pcg,
 };
 use super::simple::ConvectionScheme;
 use super::{FlowField, SolverResult};
@@ -168,6 +168,9 @@ pub struct EmbeddedPisoSolver {
     /// (measured: at 1e-2 the first corrector's rounds never settled below
     /// a 1e-3 relative change — 20/20 rounds every step).
     inner_stop_factor: f64,
+    /// PERF-2 P0: Poisson `(setup ns, iterate ns, calls)` summed over
+    /// every multigrid-PCG solve (`docs/perf2_campaign.md`).
+    poisson_profile: std::cell::Cell<(u64, u64, u64)>,
     moving: bool,
     /// Mask hysteresis band in multiples of the min cell size (0 = off).
     mask_hysteresis: f64,
@@ -194,6 +197,7 @@ impl EmbeddedPisoSolver {
             fringe: None,
             fringe_correction: Vec::new(),
             inner_stop_factor: 1e-2,
+            poisson_profile: std::cell::Cell::new((0, 0, 0)),
             moving: false,
             mask_hysteresis: 0.0,
             time: 0.0,
@@ -290,6 +294,11 @@ impl EmbeddedPisoSolver {
     }
 
     /// Relative part of the pressure solve's inner stop (see the field).
+    /// The Poisson solves' `(setup ns, iterate ns, calls)` so far.
+    pub fn poisson_profile(&self) -> (u64, u64, u64) {
+        self.poisson_profile.get()
+    }
+
     pub fn set_inner_stop_factor(&mut self, factor: f64) {
         self.inner_stop_factor = factor;
     }

crates/specialized/rtx-cfd/src/solvers/incompressible/embedded/projection.rs

@@ -4,12 +4,12 @@
 //! meshes before applying the correction once.
 
 use super::EmbeddedPisoSolver;
+use crate::CfdResult;
 use crate::solvers::incompressible::ale::SideBoundary;
 use crate::solvers::incompressible::poisson::{
-    solve_multigrid_pcg, MultigridParameters, PoissonProblem, PoissonSolverKind,
+    MultigridParameters, PoissonProblem, PoissonSolverKind, solve_multigrid_pcg,
 };
 use crate::solvers::incompressible::{EmbeddedMask, FlowField};
-use crate::CfdResult;
 
 impl EmbeddedPisoSolver {
     /// The pressure-correction system of one projection as a
@@ -304,6 +304,9 @@ impl EmbeddedPisoSolver {
                 inner_stop,
                 anchor_cell,
             );
+            let (s0, i0, c0) = self.poisson_profile.get();
+            self.poisson_profile
+                .set((s0 + solution.setup_ns, i0 + solution.iterate_ns, c0 + 1));
             // Unconverged: fall back to the SOR sweeps for this projection
             // rather than apply a correction that did not reach the stop.
             multigrid_converged = solution.converged;
@@ -337,44 +340,28 @@ impl EmbeddedPisoSolver {
                         // prescribed: a domain side with velocity data, or a
                         // non-fluid interior face.
                         let ae = if i + 1 == nx {
-                            if b.right == outlet {
-                                ae_outlet
-                            } else {
-                                0.0
-                            }
+                            if b.right == outlet { ae_outlet } else { 0.0 }
                         } else if self.u_is_fluid(j, i + 1) {
                             ae_interior
                         } else {
                             0.0
                         };
                         let aw = if i == 0 {
-                            if b.left == outlet {
-                                ae_outlet
-                            } else {
-                                0.0
-                            }
+                            if b.left == outlet { ae_outlet } else { 0.0 }
                         } else if self.u_is_fluid(j, i) {
                             ae_interior
                         } else {
                             0.0
                         };
                         let an = if j + 1 == ny {
-                            if b.top == outlet {
-                                an_outlet
-                            } else {
-                                0.0
-                            }
+                            if b.top == outlet { an_outlet } else { 0.0 }
                         } else if self.v_is_fluid(j + 1, i) {
                             an_interior
                         } else {
                             0.0
                         };
                         let as_ = if j == 0 {
-                            if b.bottom == outlet {
-                                an_outlet
-                            } else {
-                                0.0
-                            }
+                            if b.bottom == outlet { an_outlet } else { 0.0 }
                         } else if self.v_is_fluid(j, i) {
                             an_interior
                         } else {

crates/specialized/rtx-cfd/src/solvers/incompressible/embedded_body.rs

@@ -322,11 +322,7 @@ pub fn polygon_signed_distance(vertices: &[(f64, f64)], x: f64, y: f64) -> f64 {
         }
     }
     let dist = dist2.sqrt();
-    if inside {
-        -dist
-    } else {
-        dist
-    }
+    if inside { -dist } else { dist }
 }
 
 /// Velocity of the point on a closed polygon nearest to `(x, y)`, where

crates/specialized/rtx-cfd/src/solvers/incompressible/mod.rs

@@ -53,13 +53,13 @@ pub use curvilinear::{
 };
 pub use embedded::{EmbeddedParameters, EmbeddedPisoSolver, EmbeddedResult, EmbeddedSolverState};
 pub use embedded_body::{
-    polygon_interface_velocity, polygon_signed_distance, EmbeddedBody, EmbeddedMask, FaceKind,
-    SurfaceForce, SurfaceSample,
+    EmbeddedBody, EmbeddedMask, FaceKind, SurfaceForce, SurfaceSample, polygon_interface_velocity,
+    polygon_signed_distance,
 };
 pub use flow_field::FlowField;
 pub use overset::{
     CellClass, MomentumResidual, OverlapMap, OversetField, OversetParameters, OversetPisoSolver,
-    OversetResult, OversetSolverState, ResidualBucket,
+    OversetResult, OversetSolverState, ResidualBucket, StepTimers,
 };
 pub use piso::{PisoParameters, PisoResult, PisoSolver};
 #[cfg(feature = "cuda")]

crates/specialized/rtx-cfd/src/solvers/incompressible/overset/mod.rs

@@ -155,6 +155,35 @@ pub struct OversetSolverState {
 }
 
 /// The composite solver.
+/// PERF-2 P0 (`docs/perf2_campaign.md`): where one composite step's wall
+/// time goes, in nanoseconds, summed over the steps since construction.
+/// Present only when `RTX_PROFILE` is set at construction; the phase
+/// boundaries are the ones of [`OversetPisoSolver::advance`].
+#[derive(Debug, Clone, Default)]
+pub struct StepTimers {
+    /// The overlap rebuild + reclassification + fringe re-stamp (phase 1).
+    pub overlap_build_ns: u64,
+    /// The patch predictor (phase 1b: operators, predict, pressure matrix).
+    pub predictor_patch_ns: u64,
+    /// The background predictor (phase 2).
+    pub predictor_bg_ns: u64,
+    /// Patch pressure solves (BiCGSTAB), summed over rounds.
+    pub patch_solve_ns: u64,
+    /// Background pressure solves (rhs assembly + multigrid-PCG), summed.
+    pub bg_solve_ns: u64,
+    /// The rest of a round: gathers, scatters, mean removal, Anderson.
+    pub round_exchange_ns: u64,
+    /// The correctors' applications on both meshes.
+    pub apply_ns: u64,
+    /// The end-of-step exchange, defects and clocks (phase 4).
+    pub end_exchange_ns: u64,
+    /// The whole of `advance`.
+    pub advance_ns: u64,
+    /// Steps and Schwarz rounds counted.
+    pub steps: u64,
+    pub rounds: u64,
+}
+
 pub struct OversetPisoSolver {
     background: EmbeddedPisoSolver,
     patch: CurvilinearPisoSolver,
@@ -162,6 +191,8 @@ pub struct OversetPisoSolver {
     params: OversetParameters,
     grid: (usize, usize, f64, f64),
     pending: Option<PatchMesh>,
+    /// PERF-2 P0 timers (`RTX_PROFILE`), or `None` — no clock is read then.
+    timers: Option<Box<StepTimers>>,
     /// The first corrector's converged acceptor `p'` of the previous step:
     /// the temporal warm start (the correction is correlated step to step).
     acceptor_warm: Vec<f64>,
@@ -293,10 +324,32 @@ impl OversetPisoSolver {
             params,
             grid,
             pending: None,
+            timers: std::env::var_os("RTX_PROFILE").map(|_| Box::default()),
             acceptor_warm: Vec::new(),
         })
     }
 
+    /// The step timers, when profiling (`RTX_PROFILE`).
+    pub fn timers(&self) -> Option<&StepTimers> {
+        self.timers.as_deref()
+    }
+
+    /// Charge the time since `start` to `slot` and return a fresh start;
+    /// `None` in, `None` out when not profiling (no clock is read).
+    fn lap(
+        &mut self,
+        start: Option<std::time::Instant>,
+        slot: fn(&mut StepTimers) -> &mut u64,
+    ) -> Option<std::time::Instant> {
+        match (start, self.timers.as_deref_mut()) {
+            (Some(t), Some(s)) => {
+                *slot(s) += t.elapsed().as_nanos() as u64;
+                Some(std::time::Instant::now())
+            }
+            _ => None,
+        }
+    }
+
     /// The background solver.
     pub fn background(&self) -> &EmbeddedPisoSolver {
         &self.background
@@ -512,6 +565,8 @@ impl OversetPisoSolver {
     /// Advance both meshes one step of `dt`.
     pub async fn advance(&mut self, field: &mut OversetField, dt: f64) -> CfdResult<OversetResult> {
         let (nx, ny, dx, dy) = self.grid;
+        let t_advance = self.timers.as_ref().map(|_| std::time::Instant::now());
+        let mut t_lap = t_advance;
 
         // 1. If the patch moves, the overlap follows the NEXT mesh before any
         //    predictor runs: the background is reclassified (fresh cells
@@ -663,14 +718,17 @@ impl OversetPisoSolver {
             self.overlap.stamp_fringe_cells(&mut field.background.p, &p);
         }
 
+        t_lap = self.lap(t_lap, |s| &mut s.overlap_build_ns);
         // 1b. Patch predictor (swaps in the pending mesh).
         let patch_start = self.patch.begin_step(&mut field.patch, dt)?;
+        t_lap = self.lap(t_lap, |s| &mut s.predictor_patch_ns);
 
         // 2. Background predictor.
         let bg_start = self.background.begin_step(&mut field.background, dt)?;
         if let Some(old) = &old_class {
             self.trace_reclassification_source(field, old, dt);
         }
+        t_lap = self.lap(t_lap, |s| &mut s.predictor_bg_ns);
 
         // 3. Correctors: alternating Schwarz on the acceptor p' vector `a`
         //    (patch solve with Dirichlet a → fringe p' → background solve →
@@ -721,6 +779,7 @@ impl OversetPisoSolver {
                     }
                     None => patch_pc.iter_mut().for_each(|v| *v = 0.0),
                 }
+                t_lap = self.lap(t_lap, |s| &mut s.patch_solve_ns);
                 // Background with the fringe p' from the patch.
                 let fringe_vals = self.overlap.fringe_cell_values(&patch_pc);
                 self.background
@@ -730,6 +789,7 @@ impl OversetPisoSolver {
                     dt,
                     corrector == 0 || round > 0,
                 )?;
+                t_lap = self.lap(t_lap, |s| &mut s.bg_solve_ns);
                 // Pin the composite level: the coupled p' problem is pure
                 // Neumann (walls everywhere), so its constant mode is
                 // undamped by the rounds and the warm start hands each
@@ -744,6 +804,10 @@ impl OversetPisoSolver {
                 step_scale = step_scale.max(g_max);
                 let scale = step_scale.max(1e-300);
                 let change = r.iter().fold(0.0_f64, |m, v| m.max(v.abs()));
+                t_lap = self.lap(t_lap, |s| &mut s.round_exchange_ns);
+                if let Some(s) = self.timers.as_deref_mut() {
+                    s.rounds += 1;
+                }
                 if trace_rounds {
                     println!(
                         "      corrector {corrector} round {round}: |G(a) − a| {change:.3e} / step scale {scale:.3e} = {:.3e} (max|G(a)| {g_max:.3e})",
@@ -785,6 +849,7 @@ impl OversetPisoSolver {
                 } else {
                     next
                 };
+                t_lap = self.lap(t_lap, |s| &mut s.round_exchange_ns);
             }
             schwarz_converged &= done;
             rounds.push(used);
@@ -800,6 +865,7 @@ impl OversetPisoSolver {
             if corrector + 1 < self.params.corrector_steps.max(1) {
                 field.background.copy_to_starred();
             }
+            t_lap = self.lap(t_lap, |s| &mut s.apply_ns);
         }
         let patch_max_div = self.patch.max_divergence_pub(&field.patch.flux);
 
@@ -822,6 +888,11 @@ impl OversetPisoSolver {
             patch_iterations,
             patch_converged,
         );
+        let _ = self.lap(t_lap, |s| &mut s.end_exchange_ns);
+        if let (Some(t0), Some(s)) = (t_advance, self.timers.as_deref_mut()) {
+            s.advance_ns += t0.elapsed().as_nanos() as u64;
+            s.steps += 1;
+        }
         if (self.patch.time() - self.background.time()).abs()
             > 1e-12 * self.patch.time().abs().max(1.0)
         {

crates/specialized/rtx-cfd/src/solvers/incompressible/piso.rs

@@ -38,7 +38,7 @@
 //!   instead of using the prescribed boundary faces that exist there.
 
 use super::poisson::{
-    solve_multigrid_pcg, MgPrecision, MultigridParameters, PoissonProblem, PoissonSolverKind,
+    MgPrecision, MultigridParameters, PoissonProblem, PoissonSolverKind, solve_multigrid_pcg,
 };
 use super::{BoundaryConditions, FlowField, IncompressibleSolver, SolverResult};
 use crate::{CfdConfig, CfdResult};

crates/specialized/rtx-cfd/src/solvers/incompressible/poisson.rs

@@ -310,6 +310,10 @@ pub struct PoissonSolution {
     pub residual: f64,
     /// `residual < tolerance` at exit.
     pub converged: bool,
+    /// Wall time of the setup (hierarchy, fine level, components) [ns].
+    pub setup_ns: u64,
+    /// Wall time of the CG iteration (including the V-cycles) [ns].
+    pub iterate_ns: u64,
 }
 
 /// Which inner solver a projection uses for its pressure-correction system.
@@ -761,6 +765,7 @@ fn solve_pcg_with<T: MgScalar>(
         "invalid PoissonProblem: {:?}",
         problem.validate()
     );
+    let t_entry = std::time::Instant::now();
 
     let mut hier = Hierarchy::<T>::build(problem, params);
     let fine = Level::<f64>::new(problem.clone());
@@ -771,6 +776,8 @@ fn solve_pcg_with<T: MgScalar>(
             iterations: 0,
             residual: 0.0,
             converged: true,
+            setup_ns: t_entry.elapsed().as_nanos() as u64,
+            iterate_ns: 0,
         };
     }
 
@@ -818,6 +825,8 @@ fn solve_pcg_with<T: MgScalar>(
         |p: &[f64], r: &mut [f64], fine: &Level<f64>| -> f64 { fine.residual(&b, p, r) };
 
     let anchor = anchor.filter(|&a| a < n && fine.active[a]);
+    let setup_ns = t_entry.elapsed().as_nanos() as u64;
+    let t_iter = std::time::Instant::now();
     let finish = |p: &mut [f64], iterations: usize, residual: f64| {
         // Level of each singular component: the anchor's component is
         // shifted so p[anchor] == 0, every other singular component to mean
@@ -839,6 +848,8 @@ fn solve_pcg_with<T: MgScalar>(
             iterations,
             residual,
             converged: residual < tolerance,
+            setup_ns,
+            iterate_ns: t_iter.elapsed().as_nanos() as u64,
         }
     };
 

crates/specialized/rtx-cfd/src/solvers/incompressible/polygon_sdf.rs

@@ -206,11 +206,7 @@ impl PolygonSdf {
         }
 
         let dist = dist2.sqrt();
-        if inside {
-            -dist
-        } else {
-            dist
-        }
+        if inside { -dist } else { dist }
     }
 }