diff --git a/docs/lifecycle.md b/docs/lifecycle.md index 56694db..cef9ca6 100644 --- a/docs/lifecycle.md +++ b/docs/lifecycle.md @@ -7,7 +7,7 @@ it is; it adds no framework. Line references are to candidate 0f8fdbc3. |---|---|---|---| | 1. Module and its globals | Compile-time (visible to the compiler, fixed per module): `config.h` macros incl. `NX`/`NY`, `COLLISION_MODEL`, `BLOCK_ROOT_BC`, `WALL_*`. Runtime per-module globals (not visible to the compiler; written by host code): `__constant__` `d_params`, `d_w`, `d_cx`, `d_cy`, `d_block_channel`, `d_block_wall`; plus bound kernel handles | Globals are written once by the owner right after `load_module`. Uniform grid: `Simulation._recompile` (construction, body-topology sync) loads a new module and re-uploads; `update_runtime_params` rewrites `d_params` (omega, force, n_objects) between runs. Steppers: never rewritten after construction, so they are immutable for the instance's lifetime although they are runtime values. The blocked slot/reservoir root reads its slot from the `d_block_wall` constant (the former dense route used `WALL_*` macros; both were bit-identical in the parity gates). | Every owner loads its own module (`compiler.load_module` = `module_from_file`, no cache). A loaded module is never shared between live owners: globals are per module, so sharing would share mutable `d_params`. | | 2. Geometry, layout, tables | flags, curved-link tables, block layouts and halo pairs, transfer (explode/coalesce) tables, block kinds | Immutable for the life of an instance. Uniform grid: rebuilt by body sync. `FixedPatchStepper`: a geometry change is a new instance (`remap_child`), committed only after a successful transfer. | No in-place table edits. | -| 3. Controls and dependent boundary columns | Jet amplitude -> per-link `surface_velocity`; body actions (uniform grid) | Between steps, without a table or module rebuild (`set_jet_amplitude`). | Host copy commits only after the device upload succeeded; a device error fails the instance. | +| 3. Controls and dependent boundary columns | Jet amplitude -> per-link `surface_velocity`; body actions (uniform grid) | Between steps, without a table or module rebuild (`set_jet_amplitude`). | Input (index, level, amplitude) is validated before any device write; invalid input changes nothing and the instance stays usable. The host copy commits only after the upload returned. Any error after validation leaves the device column undefined and fails the instance: `FixedPatchStepper` status `failed`, `Simulation._failed`; every later call except `close()` raises, `close()` still releases resources and stays retryable. | | 4. Per-step state | population double buffers and their parity, raw-exchange ledgers, observations | Device-only during `step(n)` / `run(n)`; buffer swaps are host-handle swaps. | Valid on the host only after the single wait at the end of the call. | Storage routes are separate concerns: diff --git a/src/CelerisLab/simulation.py b/src/CelerisLab/simulation.py index 6710e86..e0534ee 100644 --- a/src/CelerisLab/simulation.py +++ b/src/CelerisLab/simulation.py @@ -47,6 +47,7 @@ class Simulation: # Internal stream for async DTOH coordination self._stream: Optional[cuda.Stream] = None self._closed = False + self._failed = None # reason after an uncertain device write; only close() remains # Load configs self.lbm_cfg = load_lbm_config(lbm_config_path) @@ -172,15 +173,26 @@ class Simulation: def set_jet_amplitude(self, index: int, amplitude: float) -> None: """Change one jet's signed amplitude; re-uploads per-link velocity only. - Invalid input changes nothing. A device error leaves the host amplitude - unchanged but the device column undefined: treat it like any other CUDA - exception here and close/recreate the Simulation before stepping again. + Invalid input raises before any change. Any error after validation + leaves the host amplitude unchanged but the device column undefined, + so the Simulation is marked failed: every later call except close() + raises; close and recreate it. """ + self._require_usable() jet = self.bodies.jets[index].with_amplitude(amplitude) if self._initialized: - self.field.curved.set_jet_amplitude(index, amplitude, self.stream) + try: + self.field.curved.set_jet_amplitude(index, amplitude, self.stream) + except BaseException as exc: + self._failed = f"jet amplitude upload failed: {exc!r}" + raise self.bodies.jets[index] = jet # later geometry syncs keep the new amplitude + def _require_usable(self): + failed = getattr(self, "_failed", None) + if failed is not None: + raise RuntimeError(f"Simulation failed ({failed}); close() and recreate it") + def remove_body(self, id: int) -> None: """Remove a body from the simulation. @@ -338,6 +350,7 @@ class Simulation: Unlike read_body this is not accumulated/time-averaged. It resets after geometry sync or checkpoint load; advance before interpreting it. """ + self._require_usable() obj = self.bodies.get(id) curved = self.field.curved has_aperture = (curved.aperture is not None @@ -365,6 +378,7 @@ class Simulation: BodyTelemetry with fields ``force``, ``torque``, ``sensor``. ``sensor`` is a dim-length array of zeros for non-sensor bodies. """ + self._require_usable() if self.bodies.obs_pinned is None: raise RuntimeError("No obs buffer. Call run() first.") if stream is None: @@ -384,6 +398,7 @@ class Simulation: This is the most efficient readback for DRL control loops (single contiguous D2H copy, no Python per-body overhead). """ + self._require_usable() if self.bodies.obs_pinned is None: raise RuntimeError("No obs buffer. Call run() first.") if stream is None: @@ -446,6 +461,7 @@ class Simulation: @context_bound def initialize(self): """Initialize flow field and sync objects to GPU.""" + self._require_usable() self._assert_allocation_contract() # Validate the complete geometry before flags, populations or modules # change. Compact-list construction publishes no outputs on failure. @@ -478,6 +494,7 @@ class Simulation: In EsoPull mode, the backing layout is decoded to physical DDF on GPU for the patched cells only, patched on host, then encoded back. """ + self._require_usable() if not self._initialized: raise RuntimeError("Call initialize() before sync_bodies()") @@ -573,6 +590,7 @@ class Simulation: sensor) on GPU and reset the step accumulator before stepping. checkpoint_interval: Nonnegative integer; if >0, save every N steps. """ + self._require_usable() if not self._initialized: raise RuntimeError("Call initialize() first") steps = operator.index(steps) @@ -637,10 +655,12 @@ class Simulation: @context_bound def get_macroscopic(self) -> Dict[str, np.ndarray]: """Download DDF and return rho, ux, uy [, uz].""" + self._require_usable() return self.field.get_macroscopic(step_id=self.stepper.step_count) @context_bound def get_ddf(self) -> np.ndarray: + self._require_usable() self.field.download_ddf(step_id=self.stepper.step_count) return self.field.ddf.copy() @@ -654,23 +674,27 @@ class Simulation: Accepted: omega, fx, fy, fz, n_objects. """ + self._require_usable() self.field.update_params(**kwargs) # -- Snapshots ----------------------------------------------------------- @context_bound def snapshot(self): """Snapshot the flow field; restore keeps the current clock and controls.""" + self._require_usable() self.field.snapshot(step_id=self.stepper.step_count) @context_bound def restore(self): """Restore the saved flow field at the current streaming parity.""" + self._require_usable() self.field.restore(step_id=self.stepper.step_count) # -- Checkpoint / Restore (HDF5) ---------------------------------------- @context_bound def save_checkpoint(self, path: str = None): """Save full simulation state to an HDF5 file.""" + self._require_usable() from .common.checkpoint import save_checkpoint if self.bodies.jets: raise NotImplementedError("Jets are not checkpointed yet") @@ -680,6 +704,7 @@ class Simulation: @context_bound def load_checkpoint(self, path: str): """Restore simulation state from an HDF5 checkpoint.""" + self._require_usable() from .common.checkpoint import load_checkpoint if not self._initialized: self.initialize() diff --git a/tests/unit/test_jet_update_failure.py b/tests/unit/test_jet_update_failure.py new file mode 100644 index 0000000..15078cc --- /dev/null +++ b/tests/unit/test_jet_update_failure.py @@ -0,0 +1,124 @@ +"""Jet amplitude update failure contract (host doubles only, no CUDA numerics). + +Both owners validate before any device write, commit host state only after the +upload returns, and refuse every later call except close() after an uncertain +device write. +""" +from types import SimpleNamespace + +import numpy as np +import pytest + +pytest.importorskip("pycuda.driver") +from CelerisLab.body.jets import Jet, Radial, Sector +from tests.unit.test_pinned_body_remap import ready +from tests.unit.test_simulation_lifecycle import make_simulation + +BAD = (float("nan"), float("inf"), 1.) + + +class Curved: + """Records uploads; ``fail`` raises once the write was attempted.""" + def __init__(self): + self.writes, self.fail = [], False + + def set_jet_amplitude(self, index, amplitude, stream): + self.writes.append((index, amplitude)) + if self.fail: + raise RuntimeError("upload failed") + + +def simulation(monkeypatch): + sim = make_simulation(monkeypatch) + jet = Jet(Sector((6., 5.), 0., .5, 4.), Radial((6., 5.)), "uniform", 1e-3) + sim._failed, sim._initialized = None, True + sim.bodies, sim.field = SimpleNamespace(jets=[jet]), SimpleNamespace(curved=Curved()) + return sim, jet + + +def test_simulation_invalid_input_writes_nothing_and_stays_usable(monkeypatch): + sim, jet = simulation(monkeypatch) + for amplitude in BAD: + with pytest.raises(ValueError): + sim.set_jet_amplitude(0, amplitude) + with pytest.raises(IndexError): + sim.set_jet_amplitude(1, 2e-3) + assert sim.field.curved.writes == [] and sim.bodies.jets[0] is jet and sim._failed is None + sim.set_jet_amplitude(0, 2e-3) # retry after a rejected input + assert sim.field.curved.writes == [(0, 2e-3)] and sim.bodies.jets[0].amplitude == 2e-3 + sim.close() + + +def test_simulation_upload_failure_keeps_host_and_blocks_reuse(monkeypatch): + sim, jet = simulation(monkeypatch) + sim.field.curved.fail = True + with pytest.raises(RuntimeError, match="upload failed"): + sim.set_jet_amplitude(0, 2e-3) + assert sim.bodies.jets[0] is jet and sim._failed is not None + sim.field.curved.fail = False + for call in (lambda: sim.set_jet_amplitude(0, 2e-3), lambda: sim.run(1), sim.step, + sim.sync_bodies, sim.initialize, sim.get_ddf, sim.get_macroscopic, + lambda: sim.read_surface_exchange(0), lambda: sim.read_body(0), + sim.read_bodies, sim.snapshot, sim.restore, sim.save_checkpoint, + lambda: sim.load_checkpoint("x.h5"), lambda: sim.update_runtime_params(omega=1.)): + with pytest.raises(RuntimeError, match="Simulation failed"): + call() + assert sim.field.curved.writes == [(0, 2e-3)] + sim.close() # cleanup still works + assert sim._closed and sim.ctx.is_closed + + +def test_simulation_before_initialize_commits_host_only(monkeypatch): + sim, _ = simulation(monkeypatch) + sim._initialized = False + sim.set_jet_amplitude(0, -2e-3) + assert sim.field.curved.writes == [] and sim.bodies.jets[0].amplitude == -2e-3 + sim.close() + + +def stepper_state(run): + boundary = run._level_boundaries[2] + return boundary.tables["surface_velocity"].copy(), boundary.jets, run._level_jets[2] + + +def test_stepper_invalid_input_writes_nothing_and_stays_ready(): + run, module, _, _, _ = ready() + try: + velocity, jets, level_jets = stepper_state(run) + module.cuda.memcpy_htod.reset_mock() + for args, kw, error in [((0, a), {"level": 2}, ValueError) for a in BAD] + [ + ((1, .01), {"level": 2}, IndexError), ((0, .01), {"level": 3}, ValueError)]: + with pytest.raises(error): + run.set_jet_amplitude(*args, **kw) + module.cuda.memcpy_htod.assert_not_called() + np.testing.assert_array_equal(run._level_boundaries[2].tables["surface_velocity"], velocity) + assert (run._level_boundaries[2].jets, run._level_jets[2]) == (jets, level_jets) + assert run._status == "ready" + run.set_jet_amplitude(0, .017, level=2) + assert run._level_jets[2][0].amplitude == .017 + finally: + run.close() + + +@pytest.mark.parametrize("where", ["upload", "synchronize"]) +def test_stepper_device_failure_keeps_host_and_blocks_reuse(where): + run, module, _, _, _ = ready() + try: + velocity, jets, level_jets = stepper_state(run) + if where == "upload": + module.cuda.memcpy_htod.side_effect = RuntimeError("upload failed") + else: + run._stream.synchronize.side_effect = RuntimeError("upload failed") + with pytest.raises(RuntimeError, match="upload failed"): + run.set_jet_amplitude(0, .017, level=2) + np.testing.assert_array_equal(run._level_boundaries[2].tables["surface_velocity"], velocity) + assert (run._level_boundaries[2].jets, run._level_jets[2]) == (jets, level_jets) + assert run._status == "failed" + module.cuda.memcpy_htod.side_effect = None + run._stream.synchronize.side_effect = None + for call in (lambda: run.set_jet_amplitude(0, .017, level=2), run.step, run.download): + with pytest.raises(RuntimeError, match="failed"): + call() + finally: + run.close() + assert run._status == "closed"