Struct CapturePool 

pub struct CapturePool { /* private fields */ }

A dedicated memory pool for CUDA graph capture.

Two responsibilities:

1. Sealed flag — gates begin_capture_with_pool so the caller can express “no more allocations after this point” semantically. Sealed pools cannot satisfy new allocations during capture.

2. Buffer lifetime tracking (CL-278) — registered buffers are kept alive by the pool itself, so they outlive any CapturedGraph that holds an Arc<CapturePool>. Dropping the graph drops the Arc, and dropping the last Arc drops every registered buffer in registration order.

Usage

use std::sync::Arc;
let pool = Arc::new(CapturePool::new());

// Allocate every buffer the captured kernels will read or
// write, and register each one with the pool so it stays alive
// for the graph's lifetime.
let mut buf_a = alloc_zeros_f32(1024, &device)?;
let mut buf_b = alloc_zeros_f32(1024, &device)?;
pool.record_buffer(buf_a.try_clone()?);
pool.record_buffer(buf_b.try_clone()?);

pool.seal();
begin_capture_with_pool(&pool, stream)?;
// ... launch kernels using buf_a and buf_b ...
let graph = end_capture_with_pool(stream, Arc::clone(&pool))?;
// Dropping `pool` here is safe — the graph holds its own Arc.

Implementations

impl CapturePool

pub fn new() -> Self

Create a new, unsealed capture pool.

pub fn seal(&self)

Seal the pool, preventing any further allocations.

pub fn unseal(&self)

Unseal the pool, allowing allocations again.

pub fn is_capture_pool_sealed(&self) -> bool

Check whether the pool is sealed.

pub fn record_buffer<B>(&self, buffer: B) -> usize

where B: Send + Sync + 'static,

Register a buffer with the pool so it stays alive for the lifetime of any CapturedGraph that holds this pool. CL-278.

buffer can be any type that owns GPU memory (typically CudaBuffer<f32>, CudaBuffer<f64>, or Arc<CudaBuffer<T>>). The pool stores it in a type-erased Box<dyn Any + Send + Sync> and drops it (in registration order) when the pool itself is dropped.

Returns the index of the registered buffer for diagnostic purposes.

pub fn buffer_count(&self) -> usize

Number of buffers currently registered with the pool. CL-278.

pub fn clear_buffers(&self)

Drop every registered buffer immediately, in registration order. The pool itself remains usable; new buffers can still be registered after this call. CL-278.

Use this when reusing a pool across multiple capture cycles. Calling clear while a CapturedGraph still holds an Arc to this pool is safe — the graph’s strong reference keeps the pool struct alive, but the buffer slots are reset.

Trait Implementations

impl Default for CapturePool

Available on crate feature cuda only.

fn default() -> Self

Returns the “default value” for a type.