Struct Graph 

pub struct Graph<R: Runtime> { /* private fields */ }

A captured graph produced by ComputeClient::stop_capture: a recorded launch sequence that replay re-runs against its original buffers, skipping the launch path it was recorded from. Cheap to clone (shares one backend graph).

The graph itself lives in the backend server, referenced here only by GraphId; this handle holds a reference-counted owner that releases the backend graph once the last clone drops. The graph replays against the exact device buffers used during capture. The caller keeps those input/output Handles alive and, each iteration, writes fresh inputs into the input handles (same device pointers) and reads the output handles after replaying — see ComputeClient::stop_capture.

Stream ordering. replay always dispatches on the stream the graph was captured on, but input writes and output reads go on the writing client’s current stream. They are ordered against the replay only when they land on that same stream, so keep the client pinned to the capture stream (via set_stream) — or issue all writes, replays, and reads from the same unpinned client — for the whole decode loop. Refreshing inputs from a client on a different stream races the replay and silently feeds it stale data.

Implementations

impl<R: Runtime> Graph<R>

pub unsafe fn replay(&self)

Replay the captured launch sequence — every recorded kernel re-run against the buffers it was captured with, on the stream it was captured on. Self-contained (the handle owns its device handle); no client needed.

How much of the launch path this skips depends on the backend: a hardware graph (CUDA, HIP) replays as one dispatch, while a software graph (wgpu) re-encodes the recorded dispatches from prebuilt state. Either way pipeline lookup, binding resolution and metadata upload happened once, at capture.

Non-blocking, like a kernel launch: this enqueues the dispatch and returns immediately. A replay failure is not reported here — it lands in the stream’s error queue and surfaces on the next sync/flush (e.g. when reading the output back).

Safety

The dispatch re-runs the recorded kernels against the raw device pointers captured with them; nothing validates those buffers still exist or are unshared. The caller must guarantee, until the replay’s work completes on the stream:

• Liveness — every Handle the captured kernels read or wrote is still allocated. Freeing one returns its memory to the pool, and a later replay reads or corrupts whatever the allocator has since placed there.
• No concurrent use — no other stream or thread touches buffers the graph reads or writes while the replay executes; the replay is ordered only against work on its capture stream.
• Same-stream refreshes — input writes and output reads are issued on the capture stream (keep the client pinned to it via set_stream, or do everything from the one client), so they order against the replay instead of racing it.

Trait Implementations

impl<R: Runtime> Clone for Graph<R>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Runtime> Debug for Graph<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.