Benchmark study · supporting material
Measurements and method
The evidence behind the Watershed benchmark, including what each timing measures, how the results were checked and how to reproduce the runs.
Machine and runs
One desktop: Ryzen 9 5950X (16 cores, 32 threads), 47 GB, one RTX 3090 (24 GB, driver 621.14), WSL2, CUDA 13.1, Rust 1.99.1, JAX 0.12.0.1. All arithmetic is double precision.
The benchmarks were run in two sessions on 13 November 2026.
- First session: one pass of every benchmark at watershed
b7587e9. - Repeat passes: five further passes at
8045417, the published revision, each benchmark in a fresh process (three passes for the nested simulation). The two revisions have the same engine code;8045417adds the JAX baseline, documentation and four lines of example output.
The tables give the median and range of the repeat passes, with the first session’s value beside them. The article quotes the medians. Measured means the full workload was run and timed. Extrapolated (marked ≈) means a sample of scenarios was timed and the time scaled linearly; the sample is given in the basis column.
The machine was a shared desktop and was not idle throughout: during the second repeat pass another job was using the CPU and some GPU memory. In that pass CPU-bound timings were two to three times the median (the hand-written loan loop took 68.8 s against a median of 19.8 s), while GPU execution times moved by a few per cent. A second job, using the GPU and then the CPU, also overlapped the end of the first pass and the start of the second. Both passes are included in every median, range and count, so the upper end of a range may reflect contention. No run was discarded.
Insurance: scenario evaluation
20,000 model points (1,009,152 policies, 1,916,579 policy-months), 10,000 market paths of 240 monthly returns, four outputs per path. The plan has 19,889,057 nodes in 967 levels with 34 shapes and needs 344,124 slots (2,752,992 bytes) per scenario.
| Figure | Median, range, runs | First session | Basis |
|---|---|---|---|
| GPU plan, first run of 10,000 scenarios | 10.2 s10.1 to 10.3 s 5 runs | 10.0 s | Measured in full. Host inputs to host outputs: kernel compilation, upload, execution in two parts (6,807 scenarios at a time), download |
| GPU plan, each of eight further runs under changed shared inputs | 9.6 s9.5 to 14.4 s 40 runs | 9.4 to 9.9 s | Measured in full. Includes set_shared and transfers; kernels already compiled. See the note on batch size below |
| Graph construction | 22.7 s21.3 to 28.4 s 5 runs | 22.6 s | Measured. Single-threaded |
| Plan compilation | 17.7 s17.6 to 34.1 s 5 runs | 18.0 s | Measured |
| Plan on 32 CPU threads, per scenario | 45 ms45 to 95 ms 5 runs | 44 ms | Measured on 128 scenarios; results asserted bit-identical to the GPU’s |
| Plan on 32 CPU threads, 10,000 scenarios | ≈ 7.5 minutes7.5 to 16 minutes 5 runs | 7.3 minutes | Extrapolated: the row above × 10,000 |
| Stage: kernel compilation | 18 ms18 to 133 ms 5 runs | 19 ms | Measured. NVRTC, 34 kernels. Smaller plans had already been compiled and run in the same process, so this is not a cold start. The 133 ms was the first pass of the session |
| Stage: host to device | 977 ms904 ms to 1.0 s 5 runs | 869 ms | Measured. Plan tables, working-table allocation and inputs |
| Stage: execution | 9.2 s9.1 to 9.2 s 5 runs | 9.1 s | Measured |
| Stage: device to host | 4 ms3 to 66 ms 5 runs | 5 ms | Measured. Four values per scenario |
Batch size: the first run of each process fitted 6,807 scenarios at a time, so it ran in two parts. The eight further runs of each process ran 1,161 to 5,676 scenarios at a time, in up to nine parts, and took 9.5 to 10.0 s (in the disturbed pass, 972 to 5,822 at a time). A run sizes its batch from the free device memory at that moment, and the pattern is consistent with the previous run’s table not yet having been released; that cause was not confirmed.
lifelib was timed once by its reference script: 17.6 s for 200 model points on 1,000 paths, on one core. Scaling that to 20,000 model points and 10,000 paths gives about 4.9 hours. It was not run at full size.
| Variant | Median, range, runs | First run, with compilation | Earlier session |
|---|---|---|---|
| Model points sorted by remaining term, 2,500 at a time | 6.20 s6.17 to 6.21 s 10 runs | 6.42 and 6.45 s | 6.10 to 6.32 s |
| Unsorted, 5,000 at a time | 13.11 s13.09 to 13.11 s 10 runs | 13.23 and 13.25 s | 13.11 to 13.12 s |
The JAX program is the same model, checked against lifelib to the same 3.1 × 10⁻¹³. It takes inputs of the same form, 10,000 paths of 240 monthly returns from its own random draws, and produces the same four outputs per path. It holds model points in batches of 2,500 (sorted) or 5,000 (unsorted). Unsorted, it steps 4,820,000 padded policy-months where the graph contains 1,916,579.
Two boundary differences favour JAX slightly. Its timed run excludes working out its constants and copying them to the device (0.3 s, once), where the plan’s time includes uploading its tables on every run (about 1 s). Tracing and XLA compilation add 0.1 to 0.2 s to its first run, which is shown separately.
At start-up XLA logged failed attempts to reserve its default memory pool, 18 GiB and then progressively less down to about 4 GiB, before proceeding. The timed runs were stable, with a range under 1%.
Nested simulation
| Figure | Median, range, runs | First session | Basis |
|---|---|---|---|
| GPU plan, 1,000,000 valuations | 3 minutes3 minutes 3 runs | 3 minutes | Measured in full. Plan and inner scenarios resident on the device; one set_shared and one run per outer scenario; the example reports whole minutes above two minutes |
The result (6,117,962,840 for the worst year in 200) was identical in every run. lifelib at its measured rate would take about 98 hours; that figure is extrapolated and was not run.
Insurance: incremental recomputation
| Figure | Median, range, runs | First session | Basis |
|---|---|---|---|
| One model point changes: mean of 1,000 changes | 58 µs56 to 94 µs 5 runs | 56 µs | Each iteration sets one guarantee, calls stabilize() and reads the total. A different model point each time. Mean of 570 nodes recomputed |
| Every input changes (a new market path) | 5.3 s5.1 to 15.3 s 5 runs | 5.2 s | One timed update |
| First valuation, including graph construction | 26.4 s26.0 to 42.8 s 5 runs | 27.7 s | One timed build and update |
| of which graph construction | 21.2 s20.8 to 27.6 s 5 runs | 22.5 s |
The CPU comparison with lifelib was measured by amendments_reference.py in the first session and not repeated: 3.6 s for a first valuation and for a new market path, 2.3 s after one model point changes (median of five), and 0.29 s to revalue one row alone (median of five).
Why two examples report different times for one change
The liabilities example also times one changed guarantee and reports a larger figure. Both examples build the same graph with the same code. They differ in what is timed.
amendments | liabilities | |
|---|---|---|
| Time reported | 58 µs (56 to 94 µs over five runs; 54 µs and 56 µs in earlier runs) | 137 µs (131 to 159 µs over five runs; 120 µs and 133 µs in earlier runs) |
| Samples behind the figure | Mean of 1,000 consecutive changes | One change, timed once |
| Model point changed | 1,000 different model points, spread across the portfolio | The first model point with more than 120 months remaining |
| Nodes recomputed | 570 on average | 952 |
| State of the graph | Inputs set to one of lifelib’s market paths | Inputs at their steady default; the process has just run the GPU benchmark |
| Timed region | set, stabilize(), read the total | set, stabilize() |
A separate probe, built on the same model code and run three times, timed both cases on one graph. Changing 1,000 different model points recomputed between 7 and 1,455 nodes, 570 on average, about six per remaining month; the portfolio averages 95 months remaining. Per change the mean was 54 to 57 µs, the median 50 to 52 µs, the 5th percentile 12 µs and the 95th 112 to 126 µs. The model point liabilities changes has 157 months remaining and recomputes 952 nodes. Timed once it took 112 to 144 µs; repeated 1,000 times its median was 66 to 68 µs. Whether the inputs held a market path or their defaults did not change the node counts.
So the two reported figures differ for two reasons: the single change touches 952 nodes where the average change touches 570, and a single first-time sample costs about twice what the same change costs when it is repeated. The article quotes the median of five runs, each averaging 1,000 changes.
The liabilities example times two larger changes the same way, once each: one late-month return changed, 62,221 nodes, 12 ms; and the fee changed for every policy, 19,927,802 nodes, 4.9 s (4.9 to 6.6 s).
Insurance: updating a batch after a change
Run of 13 November 2026 at watershed ba7b414, after the other measurements, with no other job on the machine. The rerun example was run five times in fresh processes. Each run amends five model points in turn and twice checks the kept values against compiling and running the whole plan again. The feature is experimental (Kept).
| Model point (months left) | Nodes in the small plan | Compile it | Run on CPU threads | Run on the GPU | Whole refresh, CPU |
|---|---|---|---|---|---|
| 12099 (9) | 9,327 | 13 ms | 207 ms (206–209) | 248 ms (227–255) | 222 ms (220–223) |
| 11073 (44) | 5,771 | 10 ms | 127 ms (127–129) | 220 ms (202–225) | 140 ms (137–146) |
| 17041 (88) | 7,151 | 9 ms | 160 ms (158–161) | 43 ms (41–45) | 170 ms (168–175) |
| 2770 (136) | 7,426 | 10 ms | 171 ms (171–173) | 32 ms (29–56) | 184 ms (182–191) |
| 19912 (240) | 8,559 | 10 ms | 192 ms (191–196) | 34 ms (34–55) | 203 ms (202–209) |
The whole refresh is compiling the small plan, running it on CPU threads and storing the results (1 to 2 ms). The first run, which returns the kept values, took 11.2 s (11.2–11.3); compiling the whole plan again took 17.8 s (17.6–18.1) and running it again 11.2 s (11.1–11.3). All ten checks found every kept value on every scenario identical to the last bit. The GPU timings of the small plan include compiling any kernel not already compiled in the process, which is the likely reason the first two rows are slow; that was not separated out. JAX was not given an update path: its comparable figure is the 6.2 s whole-batch run.
Reproduce with cargo run --release --features cuda -p watershed-gpu --example rerun -- export 20000 10000 1.
The same on the loan book, with the kept values chosen by the engine
To check the result is not particular to one model, the loan book (20,000 loans, 5.2 million nodes, 10,000 scenarios) was run the same way at watershed a8d2198. Here the engine chose what to keep from a budget of 12,000 values alone, taking the calculated values nearest the outputs: 8,577 per scenario, 686 MB. One loan’s house is revalued, five loans in turn, and the small plan runs on the GPU.
| Step | Time ↓ |
|---|---|
| Each refresh after the first | 29 to 36 ms (29–49) |
| First refresh in a process | 167 ms (157–249) |
| Compile the whole plan again | 5.3 s (5.2–5.4) |
| Run the whole plan again on the GPU | 7.2 s (7.1–7.5) |
In all five runs every kept value on every scenario was identical to the last bit to compiling and running the whole plan again. That depends on where the small plan runs. This model uses exp, whose last digits differ between a CPU and a GPU, so a refresh on CPU threads after a GPU batch gave values up to 1.3 × 10⁻¹⁵ away: correct, but not identical. The first refresh is slower, most likely from compiling kernels; that was not separated out.
Reproduce with cargo run --release --features cuda -p watershed-gpu --example loans -- 20000 10000.
Other workloads
| Figure | Median, range, runs | First session | Basis |
|---|---|---|---|
| Loans: GPU plan, 20,000 loans × 10,000 scenarios | 6.3 s6.2 to 6.7 s 5 runs | 6.4 s | Measured in full, host to host. 5,179,699 nodes, 206 levels |
| Loans: plan on 32 CPU threads | ≈ 2.7 minutes2.5 to 8.8 minutes 5 runs | 3 minutes | Extrapolated from 64 scenarios |
| Loans: hand-written Rust loop, 32 threads | ≈ 19.8 s18.2 to 68.8 s 5 runs | 22.7 s | Extrapolated from 32 scenarios |
| Loans: graph construction | 9.2 s9.0 to 14.6 s 5 runs | 9.6 s | Measured |
| Loans: plan compilation | 5.6 s5.3 to 8.2 s 5 runs | 6.2 s | Measured |
| Pensions: GPU plan, 50,000 member groups × 5,000 scenarios | 683 ms621 ms to 1.2 s 5 runs | 721 ms | Measured in full, host to host. 2,492,023 nodes, 85 levels |
| Pensions: plan on 32 CPU threads | ≈ 16.7 s14.3 to 17.0 s 5 runs | 16.3 s | Extrapolated from 128 scenarios |
| Pensions: hand-written Rust loop, 32 threads | ≈ 5.4 s4.9 to 5.7 s 5 runs | 5.2 s | Extrapolated from 128 scenarios |
| Pensions: 30 further runs under changed shared inputs | 12.4 s12.4 to 13.2 s 5 runs | 12.4 s | Measured in full; total for the 30 |
| Figure | Median, range, runs | First session | Basis |
|---|---|---|---|
| Workbook: GPU plan, 10 million trials | 457 ms449 to 467 ms 5 runs | 438 ms | Measured in full, host to host. 171 nodes |
| Workbook: plan on 32 CPU threads | 1.8 s1.8 s 5 runs | 1.9 s | Measured in full |
| Workbook: graph, one trial at a time | ≈ 105 s103 to 107 s 5 runs | 106 s | Extrapolated from 20,000 trials |
| Dosing: GPU plan, 5 million scenarios, per protocol | 60 ms59 to 61 ms 5 runs | 60 ms | Measured in full. Inputs resident on the device; counts reduced on the device; only totals return. 243 nodes, 85 levels, 40 shapes |
| Dosing: loading the 5 million scenarios onto the device | 186 ms182 to 343 ms 5 runs | 172 ms | Measured. Paid once, not per protocol |
| Dosing: 51 protocols | 3.0 s3.0 to 3.1 s 5 runs | 3.0 s | Measured in full |
| Dosing: plan on 32 CPU threads | ≈ 2.0 s2.0 to 4.7 s 5 runs | 2.0 s | Extrapolated from 1 million scenarios |
| Dosing: graph, one scenario at a time | ≈ 71.6 s71.2 s to 2 minutes 5 runs | 73.2 s | Extrapolated from 20,000 scenarios |
| Tax: GPU plan, 10 million households | 638 ms629 to 706 ms 5 runs | 627 ms | Measured in full, host to host; includes kernel compilation. 49 nodes, 14 levels; 11 inputs and 5 outputs per scenario |
| Tax: of which execution | 19 ms19 ms 5 runs | 19 ms | Measured |
| Tax: each later run under changed rules | 510 ms498 to 524 ms 20 runs | 479 to 544 ms | Measured in full, host to host; kernels already compiled |
| Tax: plan on 32 CPU threads | ≈ 632 ms618 to 652 ms 5 runs | 622 ms | Extrapolated from 1 million households |
| Tax: graph, one household at a time | ≈ 27.9 s27.3 to 28.9 s 5 runs | 28.9 s | Extrapolated from 20,000 households |
| Pricing: GPU plan, 5 million policies | 339 ms332 to 392 ms 5 runs | 339 ms | Measured in full, host to host; includes kernel compilation. 22 nodes, 8 levels; 13 inputs and 5 outputs per scenario |
| Pricing: of which execution | 5 ms5 to 6 ms 5 runs | 5 ms | Measured |
| Pricing: each later run under changed factors | 280 ms270 to 306 ms 20 runs | 261 to 267 ms | Measured in full, host to host; kernels already compiled |
| Pricing: plan on 32 CPU threads | ≈ 191 ms182 to 201 ms 5 runs | 219 ms | Extrapolated from 1 million policies |
| Pricing: graph, one policy at a time | ≈ 11.1 s10.8 to 11.6 s 5 runs | 11.2 s | Extrapolated from 20,000 policies |
| Pricing: 1,000 repricings, inputs resident, totals only | 5.0 s5.0 to 5.1 s 5 runs | 5.0 s | Measured in full |
The crate has further examples (monte_carlo, backtest, experts). Their figures are in the crate README.
What each comparison includes
GPU plan against JAX, insurance
- Timings. Both measured in full on the same GPU.
- Setup and compilation. Excluded on both sides: graph construction and plan compilation for the plan; tracing, XLA compilation and preparing constants for JAX. The plan’s first run includes kernel compilation.
- Transfers. Inputs and outputs are included on both sides. The plan also uploads its tables on every run.
- Equivalent work. The same model with the same sizes of input and output. Each side draws its own 10,000 paths. Unsorted JAX steps padded months that the graph does not contain.
- Precision and checks. Double precision. Both are checked against lifelib to 3.1 × 10⁻¹³.
GPU plan against the same plan on CPU threads
- Timings. GPU measured in full. CPU extrapolated from 64 or 128 scenarios on the large graphs and from 1 million on the small ones, and measured in full for the workbook.
- Setup and compilation. Plan compilation is excluded from both.
- Transfers. Included for the GPU unless a figure is stated as resident.
- Equivalent work. The same plan and the same inputs.
- Precision and checks. Double precision. Asserted bit-identical on the sample for insurance and pensions, and within 10⁻⁹ relative for loans, which uses
exp.
Plan against a hand-written Rust loop, loans and pensions
- Timings. The loop is extrapolated from 32 scenarios (loans) or 128 (pensions).
- Setup and transfers. None for the loop.
- Equivalent work. The same model and inputs, on 32 threads.
- Precision and checks. Double precision. The loop and the plan agree to 3.3 × 10⁻¹⁷ and 4.6 × 10⁻¹³.
GPU plan against lifelib
- Timings. lifelib is extrapolated from 200 model points × 1,000 scenarios and was not run at full size.
- Equivalent work. The same model. lifelib runs on one core and projects every policy to the longest term.
- Precision and checks. Double precision. They agree to 3.1 × 10⁻¹³.
Incremental recomputation against lifelib
- Timings. Both measured. Graph construction is reported separately.
- Equivalent work. The same portfolio, one market path and the same change. No GPU.
- Precision and checks. Double precision. Portfolio values agree to 4 × 10⁻¹⁵ before and after the change.
Incremental recomputation against GPU scenario evaluation
The two timings show how the same model serves different workloads. The incremental run updates an existing valuation after one small change. The GPU run evaluates 10,000 market paths. A hardware speedup requires timings for the same workload.
GPU utilisation was sampled once during a long run in an earlier session: 96 to 98%, about 335 W. Bytes moved were not measured, so the suggestion that the plan is bound by memory bandwidth is an inference.
Correctness
| Model | Reference | Compared | Largest difference |
|---|---|---|---|
| Insurance, as published by lifelib | lifelib, four configurations | 1,440,000 outputs | 9.7 × 10⁻¹⁵ |
| Insurance, mixed portfolio | lifelib, 200 model points × 1,000 scenarios, static and dynamic lapses | 1,600,000 outputs | 3.1 × 10⁻¹³ |
| Insurance, JAX baseline | The same lifelib run | 800,000 outputs | 3.1 × 10⁻¹³ |
| Insurance, incremental | lifelib portfolio value before and after one change | 2 values | 3.7 × 10⁻¹⁵ |
| Loan book | Hand-written Rust loop | 200 loans × 50 scenarios | 3.3 × 10⁻¹⁷ |
| Pension scheme | Hand-written Rust loop | 2,000 groups × 100 scenarios | 4.6 × 10⁻¹³ |
| Two-compartment dosing model | SciPy LSODA, tolerance 10⁻¹¹ | 300 scenarios | 1.7 × 10⁻¹⁰ |
| Excel workbook | Values stored in the file by Excel | 176 cells | all within 10⁻⁹ |
One formula differs from lifelib’s published model: where lapses depend on the fund, the monthly rate is scaled directly. The reference was changed in the same way for that check.
Between Watershed’s own strategies
- A property test builds 40 random graphs and requires the plan to equal the incremental engine bit for bit. It runs against the CPU interpreter, the GPU interpreter kernel and the generated GPU kernels.
- The workbook, dosing, tax and pricing examples assert that the plan equals the graph bit for bit on 20,000 scenarios each.
- The insurance and pension examples assert that the plan gives bit-identical results on the CPU and the GPU for 128 scenarios. The loan example, which uses
exp, asserts agreement within 10⁻⁹. - Exceptions on the GPU: NaN payloads may differ;
minandmaxof ±0 follow x86-64;exp,lnandpowmay differ from the CPU in the last one or two digits, tested to 10⁻¹⁴ relative. - A conditional is lazy in the graph and evaluates both branches in the plan. The two agree because no operation in the supported subset can fail.
These equalities are established by testing. Nothing is proved.
How the plan compiler works
A plan is compiled from the graph’s formulas and dependency edges, given the inputs that vary per scenario, the inputs shared by all scenarios, and the outputs.
let mut plan = Scenarios::with_shared(&g, &vary, &shared, &outputs)?;
let results = gpu.run(&plan, &inputs)?; // one row of inputs per scenario
let mut loaded = gpu.load(&plan, &inputs)?; // plan and inputs stay on the device
plan.set_shared(&stressed); // change shared inputs only
let totals = loaded.totals(&plan)?; // rerun and sum each output on the device
- Extraction. A walk back from the outputs collects the nodes they depend on. Nodes that depend on a varied input are evaluated per scenario, nodes that depend only on shared inputs once on the CPU, and the rest become constants.
- Execution levels. A node’s level is one more than the highest level it reads, so the nodes of a level are independent and can run in parallel. The insurance model has 967 levels.
- Kernel grouping. Nodes with the same operation sequence and different operands share a shape. The insurance model’s 19.9 million nodes have 34. For up to 256 shapes, one CUDA kernel is generated per shape and compiled with NVRTC; beyond that an interpreter kernel is used.
- Slot allocation. Each node gets a row of working memory, reused once its value is dead.
A kernel launch evaluates one shape’s nodes within one level for every scenario. Each GPU thread handles one node in one scenario, reading its operands from the working table and writing one value back. Kernels are not fused across nodes, so every intermediate value passes through device memory. Fused multiply-add is disabled so the GPU rounds as the CPU does. The same plan runs on CPU threads through an interpreter.
Value lifetimes and memory reuse
The working table has one row per slot and one column per scenario. With a slot per node, the insurance model would need 159 MB per scenario, and the 18.7 GB of working memory would hold about 118 scenarios. Instead the plan compiler runs a liveness analysis at level granularity (plan.rs):
- For each node, find the last level that reads it. Outputs are never dead.
- Visit nodes in level order. Before level L, release the slot of every value whose last reader is below L. Nodes of a level run concurrently, so a slot is never released mid-level.
- Give each node the lowest-numbered free slot, or a new one if none is free.
The insurance plan needs 344,124 slots for 19,889,057 nodes, 58 times fewer. That is 2.75 MB per scenario, so 6,807 scenarios fit at once and 10,000 run in two parts. Most values in a month-by-month projection are read only by the following month, so the live set, about 17 values per model point, does not grow with the length of the projection.
The saving has limits. It applies to the working table only: the plan’s operand tables are stored on the device in full, and every node is still evaluated for every scenario. Lifetimes are not optimised either. Levels are assigned as early as possible and never reordered, so a value computed early and read late holds its slot throughout. And a larger batch is not a faster one: runs split into as many as nine parts were no slower.
Reproduction
The code is the watershed-gpu crate. Each benchmark is an example that runs its correctness checks before timing anything. Without --features cuda an example runs the plan on CPU threads.
pip install lifelib pandas openpyxl scipy
mkdir export && python crates/watershed-gpu/examples/shared/liabilities_reference.py
cargo run --release --features cuda --example liabilities -- export # scenarios
cargo run --release --features cuda --example capital -- export # nested simulation
python crates/watershed-gpu/examples/shared/amendments_reference.py export
cargo run --release --example amendments -- export # incremental
pip install "jax[cuda12]" numpy # the JAX baseline
python crates/watershed-gpu/examples/shared/savings_jax.py export 20000 10000 2500 sorted
python crates/watershed-gpu/examples/shared/savings_jax.py export 20000 10000 5000
cargo run --release --features cuda --example loans
cargo run --release --features cuda --example pensions
cargo run --release --features cuda --example tax_benefit
cargo run --release --features cuda --example insurance # motor pricing
mkdir out && python crates/watershed-gpu/examples/shared/dosing_reference.py out
cargo run --release --features cuda --example dosing -- out
cargo run --release --features cuda --example spreadsheet -- \
fcffsimpleginzu.xlsx "'Input sheet'!B26=0.02:0.09" "'Input sheet'!B28=0.02:0.09" \
"'Input sheet'!B29=0.10:0.18" "'Input sheet'!B31=1.2:2.4" "'Input sheet'!B12=2500:3600" \
"'Input sheet'!B13=400:600" "'Input sheet'!B34=0.035:0.055" "'Input sheet'!B23=0.15:0.20" \
"'Valuation output'!B33" 10000000
Setting TIMING=1 makes the insurance examples print the per-stage timings. Sources: liabilities.rs, amendments.rs, capital.rs, the shared model, the JAX baseline, and the property tests.