Enum StreamCaptureState 

pub enum StreamCaptureState {
    NoCapture,
    Prepare,
    Capture,
}

Where a stream sits in the graph-capture lifecycle, and the only thing allowed to move it. Capture is a strict NoCapture → Prepare → Capture → NoCapture progression, driven by prepare, begin and end; each rejects an out-of-order call, so a capture can never start unprepared and two captures can never overlap on one stream.

The transitions live here rather than in each backend server because the rule is the same on every one of them — a backend supplies only the work a transition brackets (arming its pools, opening the driver’s capture), never the ordering rule itself.

Variants

NoCapture

No capture is prepared or recording.

Prepare

graph_prepare has armed the persistent pools for the warmup run; begin_capture may now open the window. Slices the warmup run reserves are retained by the memory manager’s priming until begin_capture calls capture_priming_end, so the pool ends up owning the capture run’s full working set.

Capture

Launches are being recorded into a graph instead of executing. On a hardware-graph backend (CUDA, HIP) a host sync issued now aborts the driver capture, so the execution path defers fenced flushes until end_capture. A software-graph backend (wgpu) has no driver capture to abort and instead refuses the operations it cannot record: a read, sync or profile fails on the spot, while a write is rejected lazily — queued as an error that fails end_capture, since a graph missing an operation is worse than a late diagnostic.

Implementations

impl StreamCaptureState

pub fn is_recording(&self) -> bool

Whether launches on the stream are being recorded into a graph right now — the window during which a host sync would abort (or is rejected by) the capture.

pub fn cache_mode(&self) -> CacheMode

The CacheMode the metadata info cache should run in at this lifecycle position. Both while a graph is being prepared (warmup, which primes the cache) and while it is being recorded the cache runs in CacheMode::Capture — caching every buffer and invalidating none — so the capture window finds every info buffer warm and drops none out from under a recorded launch. Normal operation uses CacheMode::Normal.

pub fn prepare(&mut self) -> Result<(), ServerError>

NoCapture → Prepare, for graph_prepare. Call before arming the pools; the caller owns the arming, this owns the rule that it happens exactly once per capture.

Errors

Fails when a capture is already prepared or already recording on this stream, leaving the state untouched — two captures may never overlap on one stream. The caller can retry after end_capture.

pub fn begin(&mut self) -> Result<(), ServerError>

Prepare → Capture, for begin_capture. Call before the work that opens the window (ending the priming phase, starting the driver’s capture) so a rejected call cannot run any of it: on a stream that is already recording, a drop-queue flush issued on the way to the rejection would abort the live capture.

Since the state moves before that work, a backend whose window fails to open must undo it with abort.

Errors

Fails when prepare has not run — the persistent pools have to be primed by a warmup run first — or when a capture is already recording. The state is left untouched.

pub fn end(&mut self) -> Result<(), ServerError>

Capture → NoCapture, for end_capture. Call before closing the window, so the stream leaves capture state even if sealing the graph then fails — a backend that returned an error with the state still set would wedge the stream in capture mode forever.

Errors

Fails when no capture is recording (nothing prepared or started, or the capture already ended), leaving the state untouched — a stray end_capture must not close a window that was never opened.

pub fn abort(&mut self)

Return to NoCapture from anywhere, for the failure path of a transition’s own work: the window never opened, so the stream must be left fully usable and re-capturable rather than stuck arming its persistent pools forever. Unlike end this asserts nothing, because the state it is recovering from is precisely the one that could not be completed.

Trait Implementations

impl Clone for StreamCaptureState

fn clone(&self) -> StreamCaptureState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StreamCaptureState

impl Debug for StreamCaptureState

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

Formats the value using the given formatter.

impl Eq for StreamCaptureState

impl PartialEq for StreamCaptureState

fn eq(&self, other: &StreamCaptureState) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for StreamCaptureState