Struct CudaBackend 

pub struct CudaBackend {
    pub device_info: CudaDeviceInfo,
    /* private fields */
}

CUDA compute backend.

Without cuda-backend feature: no-op stub; Self::try_new always returns CudaInitError::FeatureNotEnabled. All buffer and kernel methods operate on CPU shadows so unit tests compile and run on any platform.

With cuda-backend feature: real cudarc device context; Self::try_new calls CudaContext::new(ordinal) and returns an error if the CUDA driver is absent (e.g. on macOS or a Linux machine without an NVIDIA driver). Buffer methods perform actual host↔device memcpy via the default stream.

Fields

device_info: CudaDeviceInfo

Device information (filled from driver attributes when a real context is active).

Implementations

impl CudaBackend

pub fn try_new(ordinal: u32) -> Result<Self, CudaInitError>

Attempt to create a CUDA backend on device ordinal.

• Without cuda-backend feature: always returns Err(CudaInitError::FeatureNotEnabled).
• With cuda-backend feature: calls CudaContext::new(ordinal). Returns Err(CudaInitError::DeviceError(...)) if the CUDA driver is absent or the ordinal is invalid.

pub fn new_stub() -> Self

Create a CPU-fallback stub (useful for unit testing without a GPU).

pub fn is_available(&self) -> bool

True if a real CUDA device context is active.

pub fn device_info(&self) -> &CudaDeviceInfo

Device information.

pub fn create_buffer(&mut self, len: usize) -> CudaBufferHandle

Allocate a device buffer that can hold len f64 values.

Real path: calls CudaStream::alloc_zeros::<u8>(len * 8) and stores the returned CudaSlice<u8>. Falls back to a CPU-shadow buffer when no real context is active.

pub fn alloc_unified(&mut self, len: usize) -> CudaBufferHandle

Allocate a unified memory buffer (accessible from both CPU and GPU).

In the current implementation unified memory is backed by the same CudaSlice<u8> path as a regular buffer; true UM page migration would require UnifiedSlice from cudarc which is gated on additional CUDA driver capabilities. Falls back to a CPU-shadow buffer in the stub.

pub fn write_buffer(&mut self, handle: CudaBufferHandle, data: &[f64])

Upload data to the device buffer at handle.

Real path: CudaStream::memcpy_htod — synchronous on the default stream. Stub path: copies into the CPU shadow.

pub fn read_buffer(&self, handle: CudaBufferHandle) -> Vec<f64>

Download data from the device buffer at handle.

Real path: CudaStream::clone_dtoh — synchronous copy to a new Vec<f64>. Stub path: returns a clone of the CPU shadow.

pub fn register_kernel(&mut self, name: &str, ptx_source: &str)

Register a PTX kernel source and associate it with name.

Real path: loads the module via CudaContext::load_module and retrieves the named function. Stub path: records the name only.

pub fn compile_and_register( &mut self, name: &str, cuda_c_source: &str, ) -> Result<(), CudaInitError>

Compile a CUDA C kernel at runtime via NVRTC and register it.

Real path: calls cudarc::nvrtc::compile_ptx then loads the module. Stub path: records the name and returns Ok(()).

pub fn launch( &mut self, name: &str, buffers: &[CudaBufferHandle], grid_x: u32, block_x: u32, )

Launch a registered kernel with buffer arguments only.

Parameters

• name — kernel name as passed to Self::register_kernel or Self::compile_and_register
• buffers — buffer handles bound as kernel arguments (in order)
• grid_x — number of thread blocks in X dimension
• block_x — number of threads per block in X dimension

For kernels that take scalar arguments (e.g. an integer particle count or floating-point smoothing length), use Self::launch_with_scalars instead — calling launch against a kernel whose signature includes scalar parameters will pass uninitialised registers to those slots and is undefined behaviour.

Real path: retrieves the stored CudaFunction and dispatches via CudaStream::launch_builder. Currently up to two buffer arguments are forwarded; extend as needed for higher-arity kernels.

Stub path: no-op.

pub fn launch_with_scalars( &mut self, name: &str, buffers: &[CudaBufferHandle], scalars_i32: &[i32], scalars_f64: &[f64], grid_x: u32, block_x: u32, )

Launch a registered kernel passing buffer and scalar arguments.

Scalars are appended to the kernel argument list after the buffer arguments in the order i32 scalars then f64 scalars; the kernel signature must match that ordering exactly.

Parameters

• name — kernel name as passed to Self::register_kernel or Self::compile_and_register
• buffers — buffer handles bound as the leading kernel arguments
• scalars_i32 — i32 scalars appended after the buffers
• scalars_f64 — f64 scalars appended after the i32 scalars
• grid_x — number of thread blocks in X dimension
• block_x — number of threads per block in X dimension

Stub path: no-op.

pub fn synchronize(&mut self)

Synchronise the device (blocks until all submitted work completes).

Real path: CudaStream::synchronize(). Stub path: immediate return.

pub fn device_count() -> u32

Return the number of CUDA devices available on this system.

Real path: calls cudarc::driver::result::device::get_count(). Stub path: always returns 0.

pub fn query_device_info(ordinal: u32) -> Result<CudaDeviceInfo, CudaInitError>

Query device attributes for device ordinal without creating a backend.

Stub path: always returns Err(CudaInitError::NotAvailable). Real path: returns basic info derived from the driver (name, total mem, CC).

Trait Implementations

impl Debug for CudaBackend

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

Formats the value using the given formatter.