Struct CuBlas 

pub struct CuBlas { /* private fields */ }

cuBLAS handle wrapper

Implementations

impl CuBlas

pub fn new() -> CudaResult<Self>

Create new cuBLAS handle

pub fn set_stream(&self, stream: &CudaStream) -> CudaResult<()>

Set stream for cuBLAS operations

pub fn sgemm( &self, trans_a: bool, trans_b: bool, m: i32, n: i32, k: i32, alpha: f32, a: *const f32, lda: i32, b: *const f32, ldb: i32, beta: f32, c: *mut f32, ldc: i32, ) -> CudaResult<()>

SGEMM: C = alpha * op(A) * op(B) + beta * C

This is the core matrix multiplication operation.

Arguments

• trans_a - Whether to transpose A
• trans_b - Whether to transpose B
• m - Number of rows of op(A) and C
• n - Number of columns of op(B) and C
• k - Number of columns of op(A) and rows of op(B)
• alpha - Scalar multiplier for A*B
• a - Matrix A
• lda - Leading dimension of A
• b - Matrix B
• ldb - Leading dimension of B
• beta - Scalar multiplier for C
• c - Matrix C (output)
• ldc - Leading dimension of C

pub fn saxpy( &self, n: i32, alpha: f32, x: *const f32, incx: i32, y: *mut f32, incy: i32, ) -> CudaResult<()>

SAXPY: y = alpha * x + y

pub fn sdot( &self, n: i32, x: *const f32, incx: i32, y: *const f32, incy: i32, ) -> CudaResult<f32>

SDOT: result = x . y

pub fn snrm2(&self, n: i32, x: *const f32, incx: i32) -> CudaResult<f32>

SNRM2: result = ||x||_2

pub fn sscal( &self, n: i32, alpha: f32, x: *mut f32, incx: i32, ) -> CudaResult<()>

SSCAL: x = alpha * x

pub fn matmul(&self, a: &CudaTensor, b: &CudaTensor) -> CudaResult<CudaTensor>

Matrix multiplication for CudaTensors

Trait Implementations

impl Drop for CuBlas

fn drop(&mut self)

Executes the destructor for this type.

impl Send for CuBlas

impl Sync for CuBlas