Struct Device 

pub struct Device {
    pub name: String,
    pub cc: String,
    pub driver_version: String,
    /* private fields */
}

An initialized CUDA device with a primary context retained.

Opening one is what a machine without a GPU cannot do; every other type here borrows from it, so nothing can outlive the context it was allocated in.

Fields

name: String

Product name as the driver reports it, e.g. NVIDIA A10G.

cc: String

Compute capability as "<major>.<minor>".

driver_version: String

Driver version, recorded in results.v1 for provenance.

Implementations

impl Device

pub fn open() -> Result<Self, String>

Load the driver, initialize it, and retain a primary context on device 0.

Fails with a readable message rather than a panic when there is no driver to load — which is the normal state on CI and on the Mac.

pub fn load_module(&self, ptx: &str, entry: &str) -> Result<Module<'_>, String>

Load PTX and resolve one entry function by name.

pub fn alloc(&self, bytes: usize) -> Result<Buffer<'_>, String>

Allocate bytes of device memory.

pub fn copy_in(&self, buffer: &Buffer<'_>, data: &[u8]) -> Result<(), String>

Copy host bytes into a device buffer. data must fit.

pub fn copy_out( &self, buffer: &Buffer<'_>, out: &mut [u8], ) -> Result<(), String>

Copy device bytes back into a host slice. out must fit.

pub fn synchronize(&self) -> Result<(), String>

Block until the context’s queued work has finished.

Timings come from CUDA events rather than from wrapping this, so a measurement excludes launch and transfer overhead that a real application pays (docs/LIMITATIONS.md).

pub fn timed_launch( &self, module: &Module<'_>, grid: [u32; 3], block: [u32; 3], params: &mut [*mut c_void], ) -> Result<f64, String>

Launch once and return the kernel-only elapsed milliseconds, measured with a cuEvent pair on the default stream.

Trait Implementations

impl Drop for Device

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.