Merge pull request #4 from Ameyanagi/feat/optimize-core-pipeline-performance

perf: reduce xafs clone churn and gate bench flamegraph profiling

Author: Ameyanagi

crates/xraytsubaki/benches/autobk_stage_benchmark.rs

@@ -1,5 +1,8 @@
+mod perf;
+
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
+use perf::FlamegraphProfiler;
 use xraytsubaki::xafs::background::{AUTOBKSolver, AUTOBK};
 use xraytsubaki::xafs::normalization::{NormalizationMethod, PrePostEdge};
 
@@ -53,9 +56,20 @@ fn criterion_benchmark(c: &mut Criterion) {
     });
 }
 
+fn custom() -> Criterion {
+    let base = Criterion::default().sample_size(20);
+    let enable_profiler = std::env::args()
+        .any(|arg| arg == "--profile-time" || arg.starts_with("--profile-time="));
+    if enable_profiler {
+        base.with_profiler(FlamegraphProfiler::new(1000))
+    } else {
+        base
+    }
+}
+
 criterion_group! {
     name = benches;
-    config = Criterion::default().sample_size(20);
+    config = custom();
     targets = criterion_benchmark
 }
 

crates/xraytsubaki/doc/profiling.md

@@ -262,3 +262,64 @@ Notes:
 
 - This slice reduced allocation pressure in both single and parallel allocator-instrumented runs.
 - Runtime impact is mixed: parallel center estimate improved while sequential and AUTOBK-stage medians regressed modestly on this machine/run.
+
+## Slice H Metrics (allocation-pressure proposal implementation)
+
+Date: 2026-02-08
+
+Environment:
+
+- `rustc 1.93.0`
+- `cargo 1.93.0`
+- `Darwin 25.2.0 arm64`
+
+Commands:
+
+```bash
+cargo test -p xraytsubaki
+cargo bench -p xraytsubaki --bench autobk_stage_benchmark -- --noplot
+cargo bench -p xraytsubaki --bench xas_group_benchmark_single -- --noplot
+cargo bench -p xraytsubaki --bench xas_group_benchmark_parallel -- --noplot
+cargo run -p xraytsubaki --example alloc_baseline --release
+bash crates/xraytsubaki/scripts/bench_regression_gate.sh informational
+cargo bench -p xraytsubaki --bench autobk_stage_benchmark -- --profile-time 5
+```
+
+Pre-change baseline for this slice (captured before edits):
+
+- `autobk_stage_legacy_lm`: `[2.4009 ms 2.4325 ms 2.4624 ms]`
+- `autobk_stage_linear_direct`: `[120.13 µs 121.48 µs 122.76 µs]`
+- `xas_group_benchmark_single`: `[1.5536 s 1.5717 s 1.5861 s]`
+- `xas_group_benchmark_parallel`: `[337.67 ms 344.21 ms 351.27 ms]`
+- `xas_group_benchmark_single_alloc`:
+  - `alloc_calls=258799`
+  - `alloc_bytes=85411908`
+- `xas_group_benchmark_parallel_alloc`:
+  - `alloc_calls=25800408`
+  - `alloc_bytes=8439161224`
+
+Post-change results:
+
+- `autobk_stage_legacy_lm` median point estimate: `2.581180 ms`
+- `autobk_stage_linear_direct` median point estimate: `123.671 µs`
+- `xas_group_benchmark_single` median point estimate: `1.585049 s`
+- `xas_group_benchmark_parallel` median point estimate: `392.217 ms`
+- `xas_group_benchmark_single_alloc`:
+  - `alloc_calls=258799` (`0.00%`)
+  - `alloc_bytes=85411908` (`0.00%`)
+- `xas_group_benchmark_parallel_alloc`:
+  - `alloc_calls=25800407` (`-0.000004%`)
+  - `alloc_bytes=8439161176` (`-0.000001%`)
+
+Profiler output status:
+
+- `autobk_stage_benchmark` now uses conditional profiler wiring.
+- `--profile-time` run emits flamegraphs at:
+  - `target/criterion/autobk_stage_legacy_lm/profile/flamegraph.svg`
+  - `target/criterion/autobk_stage_linear_direct/profile/flamegraph.svg`
+- Normal `--noplot` runs do not force profiling overhead.
+
+Notes:
+
+- Allocation-reduction targets for this slice were not met on this machine/run.
+- Regression gate is green in informational mode for the stored baseline (`10%` threshold).

crates/xraytsubaki/src/xafs/xasgroup.rs

@@ -256,28 +256,34 @@ impl XASGroup {
     where
         F: FnMut(&mut XASSpectrum) -> Result<&mut XASSpectrum, XAFSError>,
     {
-        let errors = self
-            .spectra
-            .iter_mut()
-            .enumerate()
-            .filter_map(|(index, spectrum)| {
-                op(spectrum)
-                    .err()
-                    .map(|source| BatchSpectrumError { index, source })
-            })
-            .collect::<Vec<_>>();
+        if self.spectra.is_empty() {
+            return Ok(self);
+        }
 
-        if errors.is_empty() {
-            Ok(self)
-        } else {
+        let mut errors: Option<Vec<BatchSpectrumError>> = None;
+        for (index, spectrum) in self.spectra.iter_mut().enumerate() {
+            if let Err(source) = op(spectrum) {
+                errors
+                    .get_or_insert_with(|| Vec::with_capacity(4))
+                    .push(BatchSpectrumError { index, source });
+            }
+        }
+
+        if let Some(errors) = errors {
             Err(BatchProcessError { errors })
+        } else {
+            Ok(self)
         }
     }
 
     fn collect_par_errors<F>(&mut self, op: F) -> Result<&mut Self, BatchProcessError>
     where
         F: Fn(&mut XASSpectrum) -> Result<&mut XASSpectrum, XAFSError> + Sync + Send,
     {
+        if self.spectra.is_empty() {
+            return Ok(self);
+        }
+
         let mut errors = self
             .spectra
             .par_iter_mut()
@@ -288,11 +294,12 @@ impl XASGroup {
                     .map(|source| BatchSpectrumError { index, source })
             })
             .collect::<Vec<_>>();
-        errors.sort_by_key(|err| err.index);
-
         if errors.is_empty() {
             Ok(self)
         } else {
+            if errors.len() > 1 {
+                errors.sort_by_key(|err| err.index);
+            }
             Err(BatchProcessError { errors })
         }
     }
@@ -491,6 +498,23 @@ mod tests {
         assert_eq!(par_err.errors[0].index, 1);
     }
 
+    #[test]
+    fn test_batch_find_e0_par_multiple_errors_are_sorted_by_index() {
+        let path = String::from(TOP_DIR) + "/tests/testfiles/Ru_QAS.dat";
+        let valid = io::load_spectrum_QAS_trans(&path).unwrap();
+        let invalid = XASSpectrum::new();
+
+        let mut par_group = XASGroup::new();
+        par_group
+            .add_spectrum(invalid.clone())
+            .add_spectrum(valid)
+            .add_spectrum(invalid);
+
+        let par_err = par_group.find_e0_par().unwrap_err();
+        let indices = par_err.errors.iter().map(|err| err.index).collect::<Vec<_>>();
+        assert_eq!(indices, vec![0, 2]);
+    }
+
     #[test]
     fn test_default_and_par_error_semantics_match() {
         let path = String::from(TOP_DIR) + "/tests/testfiles/Ru_QAS.dat";

crates/xraytsubaki/src/xafs/xasspectrum.rs

@@ -145,35 +145,23 @@ impl XASSpectrum {
         energy: T,
     ) -> Result<&mut Self, XAFSError> {
         self.energy = Some(energy.into());
-
-        let energy = self.energy.clone().ok_or_else(|| DataError::MissingData {
+        let energy = self.energy.as_ref().ok_or_else(|| DataError::MissingData {
             field: "energy".to_string(),
         })?;
-        let mu = self
-            .raw_mu
-            .clone()
-            .ok_or_else(|| DataError::MissingData {
-                field: "raw_mu".to_string(),
-            })?
-            .data
-            .as_vec()
-            .to_vec();
-        let knot = self
-            .raw_energy
-            .clone()
-            .ok_or_else(|| DataError::MissingData {
-                field: "raw_energy".to_string(),
-            })?
-            .data
-            .as_vec()
-            .to_vec();
+        let mu = self.raw_mu.as_ref().ok_or_else(|| DataError::MissingData {
+            field: "raw_mu".to_string(),
+        })?;
+        let knot = self.raw_energy.as_ref().ok_or_else(|| DataError::MissingData {
+            field: "raw_energy".to_string(),
+        })?;
 
-        self.mu = Some(energy.interpolate(&knot, &mu).map_err(|e| {
+        let interpolated = energy.interpolate(knot.as_slice(), mu.as_slice()).map_err(|e| {
             super::errors::MathError::SplineEvalFailed {
                 x: 0.0,
                 reason: e.to_string(),
             }
-        })?);
+        })?;
+        self.mu = Some(interpolated);
 
         Ok(self)
     }
@@ -649,6 +637,46 @@ pub mod tests {
         ));
     }
 
+    #[test]
+    fn test_interpolate_spectrum_updates_energy_and_mu() {
+        let mut spectrum = XASSpectrum::new();
+        spectrum.set_spectrum(vec![0.0, 1.0, 2.0, 3.0], vec![0.0, 2.0, 4.0, 6.0]);
+
+        spectrum
+            .interpolate_spectrum(vec![0.5, 1.5, 2.5])
+            .unwrap();
+
+        assert_eq!(
+            spectrum.energy.as_ref().unwrap(),
+            &DVector::from_vec(vec![0.5, 1.5, 2.5])
+        );
+
+        let mu = spectrum.mu.as_ref().unwrap();
+        assert_abs_diff_eq!(mu[0], 1.0, epsilon = TEST_TOL);
+        assert_abs_diff_eq!(mu[1], 3.0, epsilon = TEST_TOL);
+        assert_abs_diff_eq!(mu[2], 5.0, epsilon = TEST_TOL);
+    }
+
+    #[test]
+    fn test_interpolate_spectrum_missing_raw_mu_keeps_existing_mu() {
+        let mut spectrum = XASSpectrum::new();
+        spectrum.raw_energy = Some(DVector::from_vec(vec![0.0, 1.0]));
+        spectrum.raw_mu = None;
+        spectrum.mu = Some(DVector::from_vec(vec![42.0]));
+
+        let err = spectrum.interpolate_spectrum(vec![0.25, 0.75]).unwrap_err();
+        assert!(matches!(
+            err,
+            XAFSError::Data(DataError::MissingData { ref field }) if field == "raw_mu"
+        ));
+
+        assert_eq!(
+            spectrum.energy.as_ref().unwrap(),
+            &DVector::from_vec(vec![0.25, 0.75])
+        );
+        assert_eq!(spectrum.mu.as_ref().unwrap(), &DVector::from_vec(vec![42.0]));
+    }
+
     #[test]
     #[cfg(feature = "ndarray-compat")]
     fn test_borrowed_k_chi_views_match_owned_getters() -> Result<(), Box<dyn std::error::Error>> {