Two backends, binary64 only: retire single precision, CF4, comparison steppers; decouple native from numpy_ref

benchmarks/ab.py

@@ -106,8 +106,8 @@ def arm_environment(settings: list[str]) -> dict[str, str]:
 
 
 def arm_configuration(configuration: Record, backend: str) -> Record:
-    """Return one arm's configuration: its backend, in double precision."""
-    return {**configuration, "backend": backend, "precision": "double"}
+    """Return one arm's configuration: its backend."""
+    return {**configuration, "backend": backend}
 
 
 def arm_order(round_index: int) -> tuple[str, ...]:

benchmarks/builders.py

@@ -80,21 +80,18 @@ def integrator(stepper: str) -> Multistep | RungeKutta | None:
 
 
 def variant(configuration: Record) -> Record:
-    """Return the keywords that turn a case into its backend, precision, noise and grid.
+    """Return the keywords that turn a case into its backend, noise and grid.
 
-    ``precision`` is ``"double"`` unless the configuration names it. A single-precision
-    run, or one asked for ``noise="none"``,
-    is noiseless: no seed and no noise model, so that a cross-backend A/B compares
-    one workload. ``fft_size="pow2"`` rebuilds the case's time grid at the next power
-    of two; the transverse grids are kept, as their sizes set the physics.
+    A run asked for ``noise="none"`` is noiseless: no seed and no noise model, so that
+    a cross-backend A/B compares one workload. ``fft_size="pow2"`` rebuilds the case's
+    time grid at the next power of two; the transverse grids are kept, as their sizes
+    set the physics.
     """
-    precision = configuration.get("precision") or "double"
-    noiseless = precision == "single" or configuration.get("noise") == "none"
+    noiseless = configuration.get("noise") == "none"
     fft_size = configuration.get("fft_size") or "case"
     if fft_size not in ("case", "pow2"):
         raise SuiteError(f"unknown fft_size {fft_size}")
     return {
-        "precision": precision,
         "noiseless": noiseless,
         "fft_size": fft_size,
         "backend": configuration["backend"],
@@ -151,7 +148,6 @@ def capillary(name: str, options: Record | None = None) -> Simulation:
             energy=275e-6,
             modes=4 if name == "rdw" else 1,
             mode_average=averaged,
-            precision=options["precision"],
             backend=options["backend"],
             **_limits(options, 1.5, 800e-9, (90e-9, 4e-6), 400e-15),
             **_launch(options),
@@ -167,7 +163,6 @@ def capillary(name: str, options: Record | None = None) -> Simulation:
             energy=10e-6,
             modes=3,
             loss=0.0,
-            precision=options["precision"],
             backend=options["backend"],
             **_limits(options, 0.13, 515e-9, (220e-9, 4e-6), 2e-12),
             **_launch(options),
@@ -187,7 +182,6 @@ def capillary(name: str, options: Record | None = None) -> Simulation:
             modes=1 if name == "ctc_reduced" else 2,
             raman=True,
             temperature=294.0,
-            precision=options["precision"],
             backend=options["backend"],
             **_limits(options, 0.1, 515e-9, (250e-9, 2e-6), 2e-12),
             **_launch(options),
@@ -205,7 +199,6 @@ def capillary(name: str, options: Record | None = None) -> Simulation:
             modes=1,
             envelope=name == "argon_blueshift_envelope",
             mode_average=averaged,
-            precision=options["precision"],
             backend=options["backend"],
             **_limits(
                 options,
@@ -230,7 +223,6 @@ def capillary(name: str, options: Record | None = None) -> Simulation:
             plasma=False,
             modes=1,
             mode_average=True,
-            precision=options["precision"],
             backend=options["backend"],
             **_limits(options, 0.4, 1030e-9, (200e-9, 4e-6), 800e-15),
             **_launch(options),
@@ -249,7 +241,6 @@ def capillary(name: str, options: Record | None = None) -> Simulation:
             raman=True,
             modes=1,
             mode_average=averaged,
-            precision=options["precision"],
             backend=options["backend"],
             **_limits(options, 2.0, 1030e-9, (400e-9, 4e-6), 6e-12),
             **_launch(options),
@@ -286,7 +277,6 @@ def soliton(length: float, options: Record, **keywords: Any) -> Simulation:
         # and a seed would make it a different workload (SEP 37 measured 65 times
         # the steps with one).
         noise=None,
-        precision=options["precision"],
         backend=options["backend"],
         **_limits(options, length, 835e-9, (500e-9, 2e-6), 4e-12, envelope=True),
         **keywords,
@@ -332,7 +322,6 @@ def gnlse(name: str, options: Record | None = None) -> Simulation:
             peak_power=10e3,
             raman=True,
             shock=True,
-            precision=options["precision"],
             backend=options["backend"],
             **_limits(options, 0.15, 835e-9, (400e-9, 2e-6), 12.5e-12, envelope=True),
             **_launch(options),
@@ -591,7 +580,6 @@ def build(configuration: Record) -> Simulation:
     options = variant(configuration)
     if case.builder in ("kerr", "spatial"):
         settings = SimulationSettings(
-            precision=options["precision"],
             save_planes=itinerary,
             dz_max=case.length,
             dz_init=case.length * 1e-4,

benchmarks/registry.py

@@ -185,9 +185,8 @@ def configuration(
         """Resolve one measurement without constructing a scientific object.
 
         On a device build, `width` is the host's thread count and `device` says the
-        native backend must run on the accelerator. Every backend runs in double
-        precision; ``noise="none"`` drops the case's noise and
-        ``fft_size="pow2"`` rebuilds its time grid at a power of two
+        native backend must run on the accelerator. ``noise="none"`` drops the case's
+        noise and ``fft_size="pow2"`` rebuilds its time grid at a power of two
         (``benchmarks.builders.variant``).
         """
         if stepper not in self.steppers:
@@ -201,7 +200,6 @@ def configuration(
             "stepper": stepper,
             "threads": width,
             "backend": backend,
-            "precision": "double",
             "noise": noise,
             "fft_size": fft_size,
             "device": device,

benchmarks/sessions.py

@@ -83,7 +83,7 @@ def fibre(
     itinerary : list of float
         The save planes, m, the last at `stop`.
     options : dict
-        The backend, precision and grid variant (``benchmarks.builders.variant``).
+        The backend, noise and grid variant (``benchmarks.builders.variant``).
 
     Returns
     -------

benchmarks/track.py

@@ -82,7 +82,7 @@ def selection_options(parser: argparse.ArgumentParser) -> None:
         "--backend",
         choices=BACKENDS,
         default="native",
-        help="every backend runs in double precision",
+        help="the backend every case runs on",
     )
     parser.add_argument(
         "--noise",

benchmarks/worker.py

@@ -717,7 +717,6 @@ def measure(
             "counted": counters,
             "repeat_difference": _repeat_difference(finals),
             "integrator": integrator_label(stepper.integrator),
-            "precision": configuration.get("precision", "double"),
             "rtol": controller.rtol,
             "atol": controller.atol,
             "noise": simulation.noise_resolution.resolved

changelog.d/binary64-only.removed.md

@@ -0,0 +1 @@
+Single and mixed precision are retired: solprop computes in IEEE 754 binary64 only ([ADR-077](docs/dev/decisions.md)). The `precision` keyword of `SimulationSettings`, the `Simulation.from_*` constructors and the `prop_*` functions, and a recipe's `precision` key, are gone (a recipe's `precision = "double"` is dropped, so an old recipe still loads, and any other value is refused naming ADR-077); so are `solprop.translate.precision`, the `precision` field of `PropagationProblem` and the `precision` argument of `assemble`, the reference's binary32 path (`NumpySingleBackend`), `SINGLE_PRECISION_NOISE`, `solprop.driver.defaults.rtol_in_precision`, the `precision` argument of `default_rtol`, `default_controller`, `default_integrator`, `resolve_noise` and `solprop.backends.registry.available`, the run summary's precision row, the `precision` field of `solprop_native.BuildInfo`, and the guide's single-precision page and gallery example. The kernel's `run_options` reply lists the installed backends under `backends`, in place of `double` and `single`. Output written in single precision still opens.

changelog.d/cf4-coupled-flow.removed.md

@@ -0,0 +1 @@
+Removed the CF4 coupled-flow sections (ADR-077): `CoherentWall`'s `method`, `growth_limit` and `fallback` keywords, `solprop.translate.coupled.cf4_flow`, `cf4_defect`, `cf4_growth_bound`, `CF4_NODES`, `CF4_WEIGHTS` and `CF4_GROWTH_LIMIT`, the `"cf4"` section method, and the `flow.cf4` entry of a coherent wall's run record. They ran on `numpy_ref` alone; a recipe that gives one is refused with that reason. A varying coherent wall is integrated by the frozen-residual split, as by default; to shorten its advisory step, divide the sections (`CoherentWall(sections=...)`) or cap the step.

changelog.d/comparison-multistep.removed.md

@@ -0,0 +1 @@
+Removed `solprop.stepper.multistep.ComparisonMultistep`, the benchmark-only Adams variants SEP 13 compared and did not select (PECE, explicit Adams–Bashforth, the matched predictor–corrector pairs and their Hermite dense interpolant), with the reference's general Adams path that stepped them, `milne_factor`, `defect_integral`, the `Corrector` and `Interpolant` types, `Multistep.corrector`, `Multistep.corrector_nodes` and `IntegrationSpec.reference_only` (ADR-077). Use `Multistep()`; `Multistep(order=q, variable_order=False, formulation="interaction")` is the one-order-higher PEC variant the comparison family also named.

changelog.d/final-pi-controller.breaking.md

@@ -0,0 +1 @@
+`PIController` is final: defining a subclass raises `StepperError` (ADR-077). Both backends implement its decisions and its norm (`scale`, `accepts`, `propose`, `rejection_factor`, `start_factor`, `equivalent_norm`) themselves, so a subclass that overrode one would have stepped differently on each; it ran on `numpy_ref` alone and native refused it. Set the controller's fields instead.

changelog.d/native-numpy-ref-decoupled.breaking.md

@@ -0,0 +1,13 @@
+The general modal route's and the coupled flow's admission is part of the problem's own
+validation (`solprop.translate.admission.check_general_route`), raised once as a
+`TranslationError` naming solprop rather than as a `BackendError` from each backend;
+`solprop.backends.numpy_ref.admission` and `refuse_general_leaves` are removed. The
+general route's derivations moved to `solprop.translate.general` (`node_kerr_tensor`,
+`node_kerr_form`, `node_delayed_maps`) and its node chunk to `solprop.backends.node_chunk`
+(`general_node_chunk`, `general_planned_chunk`); the quadrature alarm is
+`solprop.translate.modal.QUADRATURE_ALARM`, logged on the `solprop.translate.modal`
+logger; the Adams call ledger is `solprop.backends.ledger.CallLedger`, and the
+reference's Adams module is `solprop.backends.numpy_ref.multistep`.
+`CompiledResponses.response_order` is derived from the compiled leaves and is no longer a
+constructor argument. `solprop_native` no longer exports the `*_FIELDS` seam tuples, and
+`check_build` no longer looks seam members up.

changelog.d/precision-resume-key.breaking.md

@@ -0,0 +1 @@
+A run's configuration no longer records a `precision`, which every run recorded since SEP 33, so the resume key of every run changes once ([ADR-077](docs/dev/decisions.md)): a run started on an earlier release is refused a resume on this one, naming the change. Finish in-flight runs, and resume stopped ones, on the release that started them before upgrading; their output still opens.

changelog.d/saved-plane-copies.changed.md

@@ -1 +1 @@
-A saved plane makes fewer field-sized copies, with the same stored bits. A field the backend made for the observation alone (the native backend's host copy, the reference's widened single-precision state) is converted to true-power amplitudes where it is, so a modal plane on `native` makes two field-sized arrays where it made three, and a unit-weight one no longer copies the field at all before storing it. The reference's single-precision observation scales its widened state in place, one array fewer, and a plane observer and a failure checkpoint at a plane that kept no field now share one fetch of it. This partly addresses [#346](https://github.com/LupoLab/solprop/issues/346), as SEP 47's early copy elisions; a large spatial plane on `native` still makes its host copy and its stored copy.
+A saved plane makes fewer field-sized copies, with the same stored bits. A field the backend made for the observation alone (the native backend's host copy) is converted to true-power amplitudes where it is, so a modal plane on `native` makes two field-sized arrays where it made three, and a unit-weight one no longer copies the field at all before storing it. A plane observer and a failure checkpoint at a plane that kept no field now share one fetch of it. This partly addresses [#346](https://github.com/LupoLab/solprop/issues/346), as SEP 47's early copy elisions; a large spatial plane on `native` still makes its host copy and its stored copy.

changelog.d/sep-0047-retire-mlx.removed.md

@@ -1 +1 @@
-The experimental `mlx` backend for Apple GPUs is retired ([SEP 47](docs/dev/seps/archive/sep-0047-run-ownership.md) §6.6): `backend="mlx"`, in a call or a recipe, raises `BackendError` and never runs on another backend, and output that records it still opens. The `solprop[mlx]` extra, the front end's MLX choice and the `metal` entry of the kernel's run options are gone; the front end shows a recipe's unavailable backend as it is named, and picking a binary64 backend for a single-precision recipe returns it to double precision. Single precision runs on `numpy_ref`, named explicitly; `precision="single"` with `backend="auto"` is refused. With MLX's transform costs gone, the `transforms` keyword of `FieldGrid.from_limits` and `EnvelopeGrid.from_limits` (a recipe grid that gives it is refused, naming SEP 47), the `library` argument of `solprop.grid.fft_cost`, `solprop.grid.TransformLibrary` and `TRANSFORM_LIBRARIES`, `solprop.backends.registry.metal_available` and `SINGLE_ONLY`, and the `mlx_*` and `single_precision_rows` sizes of `solprop.backends.memory` are removed.
+The experimental `mlx` backend for Apple GPUs is retired ([SEP 47](docs/dev/seps/archive/sep-0047-run-ownership.md) §6.6): `backend="mlx"`, in a call or a recipe, raises `BackendError` and never runs on another backend, and output that records it still opens. The `solprop[mlx]` extra, the front end's MLX choice and the `metal` entry of the kernel's run options are gone; the front end shows a recipe's unavailable backend as it is named. With MLX's transform costs gone, the `transforms` keyword of `FieldGrid.from_limits` and `EnvelopeGrid.from_limits` (a recipe grid that gives it is refused, naming SEP 47 and the fix, as are the keys ADR-077 retired), the `library` argument of `solprop.grid.fft_cost`, `solprop.grid.TransformLibrary` and `TRANSFORM_LIBRARIES`, `solprop.backends.registry.metal_available` and `SINGLE_ONLY`, and the `mlx_*` and `single_precision_rows` sizes of `solprop.backends.memory` are removed.

changelog.d/sep-0047-step-driver-removed.removed.md

@@ -3,8 +3,7 @@ The legacy step driver `solprop.backends.driver` (`StepDriver`), the Adams march
 are removed ([SEP 47](docs/dev/seps/archive/sep-0047-run-ownership.md) section 6.8): the native
 backend runs every run in its native session and inherits no Python step loop, and the
 NumPy reference marches with its own `solprop.backends.host` classes. `reached` and
-`replay_tolerance` are now in `solprop.stepper.schedule`, and `refuse_general_leaves` in
-`solprop.backends.numpy_ref.admission`. A native backend's direct stepping members
+`replay_tolerance` are now in `solprop.stepper.schedule`. A native backend's direct stepping members
 (`set_initial`, `propagate_to`, `observe`, `stats`, `attach_monitor` and the rest) are
 gone with them: start a run with `backend.prepare(problem, request).start(start)` or
 `solprop.backends.sessions.start_session`.

changelog.d/spectral-responses-leaf.removed.md

@@ -0,0 +1 @@
+Removed `CompiledResponses.spectral_responses` and `Flags.has_spectral_responses` from the kernel contract. The tuple could only repeat `envelope_plasma`, which carries the envelope plasma's post-transform assembly alone, and the refusals that read the flag could not be reached.

changelog.d/two-backends.removed.md

@@ -0,0 +1 @@
+solprop has exactly two backends, `native` and `numpy_ref`, with no tiers and no plugin backends ([ADR-077](docs/dev/decisions.md)). `solprop.backends.registry.BACKENDS`, `BackendEntry`, `REMOVED_BACKENDS` and `FAR_FIELD_BACKENDS` are removed; `BACKEND_NAMES` lists the two. A backend name that is neither, `numba_cpu` and `mlx` included, now raises `BackendError` naming both wherever it is requested, where `select` raised `ValueError` for an unknown one; output and snapshots that record a retired backend still load.

docs/auto_examples/index.rst

@@ -452,47 +452,6 @@ planar compressor.
     </div>
 
 
-.. thumbnail-parent-div-close
-
-.. raw:: html
-
-    </div>
-
-Performance
------------
-
-Running the same physics in less memory: single precision on the reference backend,
-compared with binary64.
-
-
-.. raw:: html
-
-  <div id='sg-tag-list' class='sphx-glr-tag-list'></div>
-
-
-.. raw:: html
-
-    <div class="sphx-glr-thumbnails">
-
-.. thumbnail-parent-div-open
-
-.. raw:: html
-
-    <div class="sphx-glr-thumbcontainer" tooltip="A run can hold its field and evaluate its nonlinear response in binary32 with precision=&quot;single&quot;, which halves the memory of every field-sized buffer. Whether a problem keeps its accuracy in binary32 is a property of the problem, so this example runs two of them both ways and compares: the photoionisation blue shift of /auto_examples/processes/plot_06_ionisation_blue_shift, here over its first 0.2 m, and a short radial argon filament, both on field grids with the field-grid plasma. Each runs in binary64 on the default backend, native, and in binary32 on the reference backend, numpy_ref, which is named explicitly: it is the backend that runs single precision.">
-
-.. only:: html
-
-  .. image:: /auto_examples/performance/images/thumb/sphx_glr_plot_01_single_precision_thumb.png
-    :alt:
-
-  :doc:`/auto_examples/performance/plot_01_single_precision`
-
-.. raw:: html
-
-      <div class="sphx-glr-thumbnail-title">Single precision</div>
-    </div>
-
-
 .. thumbnail-parent-div-close
 
 .. raw:: html
@@ -508,5 +467,4 @@ compared with binary64.
    /auto_examples/processes/index.rst
    /auto_examples/supercontinuum/index.rst
    /auto_examples/waveguides/index.rst
-   /auto_examples/performance/index.rst