Struct DeviceBuffer 

pub struct DeviceBuffer<T: DeviceRepr> { /* private fields */ }

Owned, typed allocation of device memory (Runtime API).

Implementations

impl<T: DeviceRepr> DeviceBuffer<T>

pub fn new(len: usize) -> Result<Self>

Allocate an uninitialized buffer of len elements on the current device.

pub fn zeros(len: usize) -> Result<Self>

Allocate and zero-fill.

pub fn from_slice(src: &[T]) -> Result<Self>

Allocate and synchronously copy src from host memory.

pub fn copy_from_host(&self, src: &[T]) -> Result<()>

Synchronous H2D copy.

pub fn copy_to_host(&self, dst: &mut [T]) -> Result<()>

Synchronous D2H copy.

pub fn copy_from_host_async(&self, src: &[T], stream: &Stream) -> Result<()>

Asynchronous H2D copy on stream.

pub fn copy_to_host_async(&self, dst: &mut [T], stream: &Stream) -> Result<()>

Asynchronous D2H copy on stream.

pub fn len(&self) -> usize

Number of elements.

pub fn byte_size(&self) -> usize

Size in bytes.

pub fn is_empty(&self) -> bool

true if zero elements.

pub fn as_raw(&self) -> *mut c_void

Raw device pointer. Use with care.

pub fn as_device_ptr(&self) -> u64

Raw device pointer as the u64 value kernels expect. Convenience wrapper around as_raw.

impl<T: DeviceRepr> DeviceBuffer<T>

pub fn new_async(len: usize, stream: &Stream) -> Result<Self>

Asynchronously allocate len elements on stream from the device’s default memory pool (CUDA 11.2+).

The buffer retains stream (a cheap Arc clone), so it also frees stream-ordered: Drop enqueues cudaFreeAsync on stream, ordered by the driver after every operation already submitted to it — including a kernel still reading the buffer. That makes “launch on the stream, then let the buffer drop” safe by construction, with no host synchronize and no retention pool: the per-op stream.synchronize() that today keeps scratch / output buffers alive can be dropped. Freed blocks return to the device’s stream-ordered memory pool for reuse across a chain.

Precondition (single-stream): this ordering guarantee holds only for work submitted to this same stream. If the buffer is used on a different stream, the Drop free on the origin stream is not automatically ordered after that work — record an event on the other stream and have the origin stream wait on it before the buffer drops, or free explicitly with free_async on a suitably-ordered stream. Using the buffer only on its origin stream needs no such care.

free_async is still available if you want to free at an explicit point rather than at scope exit.

pub fn zeros_async(len: usize, stream: &Stream) -> Result<Self>

Stream-ordered allocate-and-zero: cudaMallocAsync on stream followed by cudaMemsetAsync on the same stream, so the buffer is zeroed in stream order before any subsequent op observes it.

This is the async counterpart of zeros, and the constructor to use for output buffers that should free stream-ordered: like new_async the buffer retains stream and reclaims via cudaFreeAsync on Drop, so an output written by a pipelined kernel can be evicted without a host synchronize or an executor-side lifetime guard.

Requires CUDA 11.2+.

pub fn free_async(self, stream: &Stream) -> Result<()>

Free this buffer asynchronously on stream. Consumes self so the sync Drop does not also free.

pub fn memset_async(&self, value: u8, stream: &Stream) -> Result<()>

Asynchronous memset of self to byte value value on stream.

Trait Implementations

impl<T: DeviceRepr> Debug for DeviceBuffer<T>

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

Formats the value using the given formatter.

impl<T: DeviceRepr> Drop for DeviceBuffer<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T: DeviceRepr + Send> Send for DeviceBuffer<T>