test: parallelize suite, tier tests, and trim noise_fit cost

The suite had grown to ~8min serially. Cut it to <2min and add a
sub-20s inner loop without losing coverage:

- Enable pytest-xdist by default (addopts = -n auto).
- Add slow/cpp markers via a centralized conftest auto-marker so
  `pytest -m "not slow and not cpp"` runs the fast 516-test inner loop.
- Shrink the NoiseFit recovery/uninformed solves (fixed-seed, so margins
  stay deterministic): the module fixture solve drops ~165s -> ~57s while
  keeping multi-window coverage and a 3% error vs the 20% bar.
- Drop the redundant Madgwick C++ roundtrip: it compiled the same
  lower_recurrence path PID covers and Mahony already roundtrips a
  quaternion output through C++. Numpy behavior + emit smoke tests kept.

Co-Authored-By: Claude Opus 4.8 <[email protected]>

Author: rohan2017

pyproject.toml

@@ -30,3 +30,11 @@ dev = ["pytest>=9.0", "pytest-xdist>=3.8"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["manta"]
+
+[tool.pytest.ini_options]
+# Run in parallel by default (pytest-xdist). Override with `-n0` to serialize.
+addopts = "-n auto"
+markers = [
+    "slow: long-running fits, Monte-Carlo, or fine-dt convergence sweeps",
+    "cpp: shells out to a C/C++ compiler (codegen roundtrips)",
+]

tests/conftest.py

@@ -0,0 +1,55 @@
+"""Shared pytest configuration: auto-marking of slow / cpp tests.
+
+Rather than scatter ``@pytest.mark`` decorators across the suite, the policy
+for which tests are expensive lives here in one auditable place. Two markers
+are applied at collection time:
+
+* ``cpp``  — the test shells out to a C/C++ compiler (codegen roundtrips,
+  syntax checks). These already self-skip when no toolchain is on PATH; the
+  marker lets you *also* exclude them when a compiler *is* present.
+* ``slow`` — long-running fits, Monte-Carlo consistency runs, or fine-dt
+  convergence sweeps.
+
+Fast inner-loop run:  ``pytest -m "not slow and not cpp"``
+Full suite (CI):      ``pytest``           (markers are not filtered)
+"""
+
+# Tests whose *name* contains any of these substrings invoke a compiler.
+_CPP_NAME_MARKERS = (
+    "cpp_roundtrip",        # *_python_cpp_roundtrip across pid/madgwick/etc.
+    "multicraft_roundtrip",
+    "compiles_with_cc",
+    "emits_scalar_ref",     # test_codegen_emit_cpp _syntax_check tests
+)
+
+# Whole modules dominated by long fits / Monte-Carlo work.
+_SLOW_MODULES = frozenset({
+    "test_noise_fit",
+    "test_consistency",
+    "test_fit",
+})
+
+# Individual slow tests living in otherwise-fast modules (long sims / sweeps).
+_SLOW_NAME_MARKERS = (
+    "frictionless_energy_converges_with_dt",
+    "double_pendulum_conserves_energy_undamped",
+    "double_pendulum_converges_to_textbook_rk4",
+    "gimbal_pendulum_precesses_at_minus_omega",
+    "no_precession_without_hub_spin",
+    "gimbal_conserves_momentum_and_energy",
+    "eskf_nees_consistency_over_seeds",
+    "random_walk_bias_walks_with_driver",
+    "grad_through_rollout_is_finite",
+)
+
+
+def pytest_collection_modifyitems(config, items):
+    import pytest
+
+    for item in items:
+        module = item.module.__name__.rsplit(".", 1)[-1]
+        name = item.name
+        if any(s in name for s in _CPP_NAME_MARKERS):
+            item.add_marker(pytest.mark.cpp)
+        if module in _SLOW_MODULES or any(s in name for s in _SLOW_NAME_MARKERS):
+            item.add_marker(pytest.mark.slow)

tests/test_madgwick.py

@@ -1,13 +1,12 @@
-"""Madgwick AHRS recurrence block — numpy behavior + C++ roundtrip.
+"""Madgwick AHRS recurrence block — numpy behavior + codegen smoke.
 
-Madgwick adds zero backend code (it reuses the generic `lower_recurrence`
-path PID established). These tests pin the convention (gyro integration,
-accelerometer convergence, quaternion stays unit) and prove the compiled
-C++ `step()` reproduces the numpy quaternion trajectory exactly.
+Madgwick adds zero backend code: it reuses the generic `lower_recurrence`
+path PID establishes and Mahony already roundtrips through compiled C++
+(quaternion output included). So there's no separate Madgwick C++ roundtrip
+— these tests pin the convention (gyro integration, accelerometer
+convergence, quaternion stays unit) and that the C++ target emits its files.
 """
 
-import shutil
-import subprocess
 from pathlib import Path
 
 import numpy as np
@@ -61,83 +60,11 @@ def test_madgwick_quaternion_stays_unit():
         assert np.linalg.norm(q) == pytest.approx(1.0, abs=1e-9)
 
 
-# --- C++ roundtrip ----------------------------------------------------------
-
-_GYRO = [[0.1, -0.2, 0.05], [0.3, 0.1, -0.1], [-0.2, 0.2, 0.15],
-         [0.0, -0.3, 0.2], [0.25, 0.1, -0.05]]
-_ACCEL = [[0.0, 0.0, 9.81], [0.5, 0.0, 9.7], [0.3, -0.4, 9.6],
-          [-0.2, 0.3, 9.75], [0.1, 0.1, 9.8]]
-_DT = 0.02
-
-_HARNESS = r"""
-#include "madgwick.hpp"
-#include <cstdio>
-
-int main() {
-    manta_gen::Madgwick f;
-    const double g[5][3] = {{0.1,-0.2,0.05},{0.3,0.1,-0.1},{-0.2,0.2,0.15},
-                            {0.0,-0.3,0.2},{0.25,0.1,-0.05}};
-    const double a[5][3] = {{0.0,0.0,9.81},{0.5,0.0,9.7},{0.3,-0.4,9.6},
-                            {-0.2,0.3,9.75},{0.1,0.1,9.8}};
-    for (int i = 0; i < 5; ++i) {
-        manta_gen::Madgwick::Inputs u;
-        u.gyro  << g[i][0], g[i][1], g[i][2];
-        u.accel << a[i][0], a[i][1], a[i][2];
-        auto o = f.step(u, 0.02, 0.0);
-        std::printf("q %.17g %.17g %.17g %.17g\n",
-                    o.orientation[0], o.orientation[1],
-                    o.orientation[2], o.orientation[3]);
-    }
-    return 0;
-}
-"""
+# --- codegen smoke ----------------------------------------------------------
 
 
 def test_madgwick_emits_cpp_files(tmp_path: Path):
     result = TargetCpp(Madgwick(beta=0.1), tmp_path, class_name="Madgwick")
     for p in (result.kernels_c, result.kernels_h, result.wrapper_hpp,
               result.wrapper_cpp, result.cmakelists):
         assert p.exists(), p
-
-
-def test_madgwick_python_cpp_roundtrip(tmp_path: Path):
-    cxx = next((c for c in ("c++", "g++", "clang++") if shutil.which(c)), None)
-    cc = next((c for c in ("cc", "gcc", "clang") if shutil.which(c)), None)
-    if cxx is None or cc is None:
-        pytest.skip("no C/C++ compiler on PATH")
-    eigen_inc = next((p for p in ("/usr/include/eigen3",
-                                  "/usr/local/include/eigen3")
-                      if Path(p, "Eigen", "Dense").exists()), None)
-    if eigen_inc is None:
-        pytest.skip("Eigen headers not found")
-
-    f = Madgwick(beta=0.1)
-    result = TargetCpp(f, tmp_path, class_name="Madgwick")
-
-    k_obj, w_obj = tmp_path / "k.o", tmp_path / "w.o"
-    for cmd in (
-        [cc, "-c", "-O2", "-fPIC", str(result.kernels_c), "-o", str(k_obj)],
-        [cxx, "-c", "-std=c++17", "-O2", "-fPIC", f"-I{eigen_inc}",
-         f"-I{tmp_path}", str(result.wrapper_cpp), "-o", str(w_obj)],
-    ):
-        p = subprocess.run(cmd, capture_output=True, text=True)
-        assert p.returncode == 0, p.stderr
-
-    h_src = tmp_path / "harness_main.cpp"
-    h_src.write_text(_HARNESS)
-    binary = tmp_path / "harness"
-    p = subprocess.run(
-        [cxx, "-std=c++17", "-O2", f"-I{eigen_inc}", f"-I{tmp_path}",
-         str(h_src), str(w_obj), str(k_obj), "-o", str(binary)],
-        capture_output=True, text=True)
-    assert p.returncode == 0, p.stderr
-    p = subprocess.run([str(binary)], capture_output=True, text=True)
-    assert p.returncode == 0, p.stderr
-    cpp_q = [[float(x) for x in line.split()[1:]]
-             for line in p.stdout.strip().splitlines()]
-
-    r = TargetNumpy(f)
-    np_q = [list(r.step(_DT, gyro=g, accel=a)["orientation"])
-            for g, a in zip(_GYRO, _ACCEL)]
-
-    np.testing.assert_allclose(cpp_q, np_q, atol=1e-12)

tests/test_noise_fit.py

@@ -47,7 +47,7 @@ def _record(world, n_win=3, K=120, seed=5):
 @pytest.fixture(scope="module")
 def fitted():
     """One shared recovery solve: model starts 5x off, each way."""
-    windows = _record(_noisy_drone(), n_win=2, K=100)
+    windows = _record(_noisy_drone(), n_win=2, K=35)
     model = _noisy_drone(gyro=0.02, accel=0.01)
     nf = NoiseFit(model, noise={
         "imu.gyro_noise": Prior(sigma=2.0),
@@ -60,7 +60,7 @@ def test_noise_fit_recovers_sigmas(fitted):
     _, res = fitted
     g = res.values["drone.imu.gyro_noise"]
     a = res.values["drone.imu.accel_noise"]
-    # ~200 samples/axis: expect σ to ~10%; assert 20%.
+    # ~70 samples/axis: expect σ to ~15%; assert 20%.
     assert abs(g - TRUE_GYRO) / TRUE_GYRO < 0.2, g
     assert abs(a - TRUE_ACCEL) / TRUE_ACCEL < 0.2, a
     # The data informed both: posterior ≪ prior.
@@ -167,7 +167,7 @@ def test_noise_fit_uninformed_channel_posterior_stays_at_prior():
     noise under dominant measurement noise, short window): its Laplace
     posterior must come back ≈ the prior — 'this σ is your prior
     talking' — while the measurement channels are pinned down."""
-    windows = _record(_noisy_drone(), n_win=1, K=60, seed=11)
+    windows = _record(_noisy_drone(), n_win=1, K=40, seed=11)
     model = _noisy_drone()
     t1 = next(p for p in model.crafts[0].parts if p.name == "t1")
     t1.force_noise_sigma = 1e-4               # active but ~invisible