Suspension

Preview — Ranvier is pre-release; its APIs may change.

The pending channel is what lets a computation read an async source that has no value yet. On .NET, a transparent read of a Pending source aborts the reading body by throwing, and an exception is the most expensive single operation in the design. These benchmarks measure what that costs and how a boundary limits it. See Benchmarks for configuration, environment and caveats.

SuspensionBenchmarks

A chain of Depth frames (1, 4 or 16) between the suspending read and the reader. Each iteration writes a trigger that the chain's first memo reads, so every read re-runs the chain.

Recorded 2026-09-28. Source: Ranvier.Benchmarks.Suspension.SuspensionBenchmarks at commit d87920f.

BoundaryBenchmarks

A boundary catches the pending channel instead of letting it propagate, so the cost of a suspended subtree is bounded by where the boundary sits rather than by the depth of the whole graph. Each iteration writes a trigger both bodies read, so every read re-runs the body.

Recorded 2026-09-28. Source: Ranvier.Benchmarks.Suspension.BoundaryBenchmarks at commit d87920f.

SettleBenchmarks

Settling a source is where a pending subtree becomes live, and it is the only path in the library that can arrive from another thread.

Recorded 2026-09-28. Source: Ranvier.Benchmarks.Suspension.SettleBenchmarks at commit d87920f.

FlightPolicyBenchmarks

The price of cancellation per async-memo flight. Each iteration writes a trigger the body reads, then reads the memo, which launches one flight. The body ignores its token, so the cancel runs no callbacks. Flight is Completed when the body returns a completed task, and Superseded when it returns a task that never completes, so every launch supersedes a flight in progress.

Not yet recorded.

FlightBenchmarks

Repeated flight launches under each FlightPolicy, set by Policy. Writes applies to WritesDuringFlight only.

The counter scenario flight runs the same shape at one write during a flight, once per policy: two writes and reads, then a settle of every flight the writes started. Figures are retired instructions per operation at commit e13f159, .NET 10 with tiered compilation and PGO off (see Instruction counts):

CancelPrevious, KeepLatest and FinishCurrent cost the same within about 4 %. Queue costs about twice as much in instructions and bytes. The timing cases are in the suite for local runs (dotnet run --project bench/Ranvier.Benchmarks -c Release -- --filter "*FlightBenchmarks*") and have no published figure yet. The full report is e13f159.md.

FailureBenchmarks

The error channel's cost on a recomputation. Each iteration writes a trigger the memo reads, so every read re-runs the body.

The counter scenario fail-recompute measures the same recomputation with one reader, then reads the reader's ErrorOrigin. Figures are retired instructions per operation at commit e13f159, .NET 10 with tiered compilation and PGO off (see Instruction counts):

A failing recompute costs about 55 times a succeeding one, and the figure includes throwing a fresh .NET exception. The timing cases are in the suite for local runs (dotnet run --project bench/Ranvier.Benchmarks -c Release -- --filter "*FailureBenchmarks*") and have no published figure yet. The full report is e13f159.md.

FailureChainBenchmarks

A failure's cost per reader: a memo whose body throws a fresh exception, read through Depth memos (1, 4 or 16) that each read the one before with Value. Each reader adopts the upstream failure and its origin.

The failing row of fail-recompute above measures Depth 1. Depth 4 and 16 are in the suite for local runs (dotnet run --project bench/Ranvier.Benchmarks -c Release -- --filter "*FailureChainBenchmarks*") and have no published figure yet.

The Ratio and Alloc Ratio columns, where present, compare each method with the baseline method of the same class on the same run. They describe the relative cost of two operations inside Ranvier, not a comparison with any other library.