Struct Graph 

pub struct Graph { /* private fields */ }

A captured graph produced by Client::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 Client::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 Graph

pub unsafe fn replay(&self) -> Result<(), ServerError>

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.

Blocking only on the enqueue: replay waits for the device thread to accept the dispatch and hands back what that enqueue said — an unknown or destroyed graph, a refusal — then returns without waiting for the device. A failure also leaves the graph’s write set carrying it, so a read of those buffers keeps failing until a replay lands.

The wait costs end-to-end throughput nothing: the device-thread work happens either way, and blocking here only stops deferring it to the next sync. What it does move is the caller-visible latency of this call, from the cost of posting to a channel to the real cost of enqueuing the pass — so a benchmark reading this column is reading latency, not throughput.

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 Clone for Graph

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Graph

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

Formats the value using the given formatter.