Table of Contents

Class CuBlasNative

Namespace
NVMathNet.Interop
Assembly
NVMath.Net.dll

Raw P/Invoke bindings for cuBLAS and cuBLASLt.

public static class CuBlasNative

Inheritance

Inherited Members

Fields

HeuristicResultSize

Size in bytes of the opaque cublasLtMatmulHeuristicResult_t struct. Callers must pass a buffer of at least this size to NVMathNet.Interop.CuBlasNative.MatmulAlgoGetHeuristic(System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.Int32,System.Byte[]).

public const int HeuristicResultSize = 96

Field Value

int

Methods

Check(CuBlasStatus, string?)

Throws NVMathNet.Interop.CuBlasException if status is not NVMathNet.Interop.CuBlasStatus.Success. Optionally prefixes the message with context.

public static void Check(CuBlasStatus status, string? context = null)

Parameters

status CuBlasStatus
context string?

Create()

Creates a classic cuBLAS handle. Caller must call NVMathNet.Interop.CuBlasNative.Destroy(System.IntPtr) when done.

public static nint Create()

Returns

nint

Ddgmm(nint, CuBlasSideMode, int, int, double*, int, double*, int, double*, int)

Double-precision diagonal matrix multiply: C = diag(X) * A (side=Left) or C = A * diag(X) (side=Right).

public static void Ddgmm(nint handle, CuBlasSideMode mode, int m, int n, double* a, int lda, double* x, int incx, double* c, int ldc)

Parameters

handle nint
mode CuBlasSideMode
m int
n int
a double*
lda int
x double*
incx int
c double*
ldc int

Destroy(nint)

Destroys a classic cuBLAS handle.

public static void Destroy(nint handle)

Parameters

handle nint

Dgemm(nint, CuBlasOperation, CuBlasOperation, int, int, int, double*, double*, int, double*, int, double*, double*, int)

Double-precision GEMM: C = alpha * op(A) * op(B) + beta * C. All matrices must reside in device memory (column-major layout).

public static void Dgemm(nint handle, CuBlasOperation transa, CuBlasOperation transb, int m, int n, int k, double* alpha, double* a, int lda, double* b, int ldb, double* beta, double* c, int ldc)

Parameters

handle nint

Classic cuBLAS handle.

transa CuBlasOperation

Transpose operation for A.

transb CuBlasOperation

Transpose operation for B.

m int

Rows of op(A) and C.

n int

Columns of op(B) and C.

k int

Inner dimension.

alpha double*

Scalar multiplier for A*B.

a double*

Device pointer to A.

lda int

Leading dimension of A.

b double*

Device pointer to B.

ldb int

Leading dimension of B.

beta double*

Scalar multiplier for existing C.

c double*

Device pointer to C (in/out).

ldc int

Leading dimension of C.

DgetrfBatched(nint, int, double**, int, int*, int*, int)

Batched double-precision LU factorisation with partial pivoting.

public static void DgetrfBatched(nint handle, int n, double** aArray, int lda, int* p, int* info, int batchSize)

Parameters

handle nint

cuBLAS handle.

n int

Order of each matrix.

aArray double**

Device array of device pointers to the matrices.

lda int

Leading dimension.

p int*

Device array of n * batchSize pivot indices (output).

info int*

Device array of batchSize status values (output).

batchSize int

Number of matrices.

DgetrsBatched(nint, CuBlasOperation, int, int, double**, int, int*, double**, int, int*, int)

Batched double-precision solve from LU factors. info is a host int.

public static void DgetrsBatched(nint handle, CuBlasOperation trans, int n, int nrhs, double** aArray, int lda, int* devIpiv, double** bArray, int ldb, int* info, int batchSize)

Parameters

handle nint

cuBLAS handle.

trans CuBlasOperation

Operation applied to A.

n int

Order of each matrix.

nrhs int

Right-hand sides per matrix.

aArray double**

Device array of device pointers to the LU factors.

lda int

Leading dimension of A.

devIpiv int*

Device pivot array from the factorisation.

bArray double**

Device array of device pointers to the right-hand sides.

ldb int

Leading dimension of B.

info int*

Host status value.

batchSize int

Number of matrices.

Dscal(nint, long, double, double*)

Scales a double-precision vector in place: x = alpha * x (64-bit element count).

public static void Dscal(nint handle, long n, double alpha, double* x)

Parameters

handle nint
n long
alpha double
x double*

Dsymm(nint, CuBlasSideMode, CuBlasFillMode, int, int, double*, double*, int, double*, int, double*, double*, int)

Double-precision symmetric matrix-matrix multiply: C = alpha * A * B + beta * C (side=Left) or C = alpha * B * A + beta * C (side=Right) where A is symmetric.

public static void Dsymm(nint handle, CuBlasSideMode side, CuBlasFillMode uplo, int m, int n, double* alpha, double* a, int lda, double* b, int ldb, double* beta, double* c, int ldc)

Parameters

handle nint
side CuBlasSideMode
uplo CuBlasFillMode
m int
n int
alpha double*
a double*
lda int
b double*
ldb int
beta double*
c double*
ldc int

Dtrsm(nint, CuBlasSideMode, CuBlasFillMode, CuBlasOperation, CuBlasDiagType, int, int, double*, double*, int, double*, int)

Double-precision triangular solve: B = alpha * inv(op(A)) * B (side=Left) or B = alpha * B * inv(op(A)) (side=Right) where A is triangular.

public static void Dtrsm(nint handle, CuBlasSideMode side, CuBlasFillMode uplo, CuBlasOperation trans, CuBlasDiagType diag, int m, int n, double* alpha, double* a, int lda, double* b, int ldb)

Parameters

handle nint
side CuBlasSideMode
uplo CuBlasFillMode
trans CuBlasOperation
diag CuBlasDiagType
m int
n int
alpha double*
a double*
lda int
b double*
ldb int

Hgemm(nint, CuBlasOperation, CuBlasOperation, int, int, int, Half*, Half*, int, Half*, int, Half*, Half*, int)

Half-precision GEMM: C = alpha * op(A) * op(B) + beta * C. All matrices must reside in device memory (column-major layout).

public static void Hgemm(nint handle, CuBlasOperation transa, CuBlasOperation transb, int m, int n, int k, Half* alpha, Half* a, int lda, Half* b, int ldb, Half* beta, Half* c, int ldc)

Parameters

handle nint

Classic cuBLAS handle.

transa CuBlasOperation

Transpose operation for A.

transb CuBlasOperation

Transpose operation for B.

m int

Rows of op(A) and C.

n int

Columns of op(B) and C.

k int

Inner dimension.

alpha Half*

Scalar multiplier for A*B.

a Half*

Device pointer to A.

lda int

Leading dimension of A.

b Half*

Device pointer to B.

ldb int

Leading dimension of B.

beta Half*

Scalar multiplier for existing C.

c Half*

Device pointer to C (in/out).

ldc int

Leading dimension of C.

LtCreate()

Creates a cuBLASLt handle. Caller must call NVMathNet.Interop.CuBlasNative.LtDestroy(System.IntPtr) when done.

public static nint LtCreate()

Returns

nint

LtDestroy(nint)

Destroys a cuBLASLt handle created with NVMathNet.Interop.CuBlasNative.LtCreate.

public static void LtDestroy(nint handle)

Parameters

handle nint

Matmul(nint, nint, void*, void*, nint, void*, nint, void*, void*, nint, void*, nint, void*, void*, nuint, nint)

Executes D = alpha * op(A) * op(B) + beta * C on the GPU. All pointers must point to device memory except algo which is the opaque algorithm buffer returned by NVMathNet.Interop.CuBlasNative.MatmulAlgoGetHeuristic(System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.Int32,System.Byte[]).

public static void Matmul(nint ltHandle, nint opDesc, void* alpha, void* a, nint aDesc, void* b, nint bDesc, void* beta, void* c, nint cDesc, void* d, nint dDesc, void* algo, void* workspace, nuint workspaceSize, nint stream)

Parameters

ltHandle nint
opDesc nint
alpha void*
a void*
aDesc nint
b void*
bDesc nint
beta void*
c void*
cDesc nint
d void*
dDesc nint
algo void*
workspace void*
workspaceSize nuint
stream nint

MatmulAlgoGetHeuristic(nint, nint, nint, nint, nint, nint, nint, int, byte[])

Queries cuBLASLt for algorithm suggestions and writes them into resultsBuffer.

public static int MatmulAlgoGetHeuristic(nint ltHandle, nint opDesc, nint aDesc, nint bDesc, nint cDesc, nint dDesc, nint preference, int maxAlgos, byte[] resultsBuffer)

Parameters

ltHandle nint
opDesc nint
aDesc nint
bDesc nint
cDesc nint
dDesc nint
preference nint
maxAlgos int
resultsBuffer byte[]

Returns

int

Number of algorithms written (0 if none found).

MatmulDescCreate(CuBlasComputeType, CudaDataType)

Creates a matmul operation descriptor.

public static nint MatmulDescCreate(CuBlasComputeType computeType, CudaDataType scaleType)

Parameters

computeType CuBlasComputeType

Compute precision.

scaleType CudaDataType

Data type for alpha/beta scalars.

Returns

nint

MatmulDescDestroy(nint)

Destroys a matmul descriptor.

public static void MatmulDescDestroy(nint desc)

Parameters

desc nint

MatmulDescSetAttribute(nint, int, void*, nuint)

Sets an attribute on a matmul descriptor (e.g. transpose, epilog).

public static void MatmulDescSetAttribute(nint desc, int attr, void* buf, nuint size)

Parameters

desc nint
attr int
buf void*
size nuint

MatmulPreferenceCreate()

Creates a matmul algorithm preference descriptor.

public static nint MatmulPreferenceCreate()

Returns

nint

MatmulPreferenceDestroy(nint)

Destroys a matmul preference descriptor.

public static void MatmulPreferenceDestroy(nint pref)

Parameters

pref nint

MatmulPreferenceSetAttribute(nint, int, void*, nuint)

Sets an attribute on a matmul preference descriptor (e.g. max workspace bytes).

public static void MatmulPreferenceSetAttribute(nint pref, int attr, void* buf, nuint size)

Parameters

pref nint
attr int
buf void*
size nuint

MatrixLayoutCreate(CudaDataType, ulong, ulong, long)

Creates a matrix layout descriptor.

public static nint MatrixLayoutCreate(CudaDataType type, ulong rows, ulong cols, long ld)

Parameters

type CudaDataType
rows ulong
cols ulong
ld long

Returns

nint

MatrixLayoutDestroy(nint)

Destroys a matrix layout descriptor.

public static void MatrixLayoutDestroy(nint layout)

Parameters

layout nint

MatrixLayoutSetAttribute(nint, int, void*, nuint)

Sets an attribute on a matrix layout descriptor.

public static void MatrixLayoutSetAttribute(nint layout, int attr, void* buf, nuint size)

Parameters

layout nint
attr int
buf void*
size nuint

Sdgmm(nint, CuBlasSideMode, int, int, float*, int, float*, int, float*, int)

Single-precision diagonal matrix multiply: C = diag(X) * A (side=Left) or C = A * diag(X) (side=Right).

public static void Sdgmm(nint handle, CuBlasSideMode mode, int m, int n, float* a, int lda, float* x, int incx, float* c, int ldc)

Parameters

handle nint
mode CuBlasSideMode
m int
n int
a float*
lda int
x float*
incx int
c float*
ldc int

SetStream(nint, nint)

Associates a CUDA stream with the classic cuBLAS handle.

public static void SetStream(nint handle, nint stream)

Parameters

handle nint
stream nint

Sgemm(nint, CuBlasOperation, CuBlasOperation, int, int, int, float*, float*, int, float*, int, float*, float*, int)

Single-precision GEMM: C = alpha * op(A) * op(B) + beta * C. All matrices must reside in device memory (column-major layout).

public static void Sgemm(nint handle, CuBlasOperation transa, CuBlasOperation transb, int m, int n, int k, float* alpha, float* a, int lda, float* b, int ldb, float* beta, float* c, int ldc)

Parameters

handle nint

Classic cuBLAS handle.

transa CuBlasOperation

Transpose operation for A.

transb CuBlasOperation

Transpose operation for B.

m int

Rows of op(A) and C.

n int

Columns of op(B) and C.

k int

Inner dimension.

alpha float*

Scalar multiplier for A*B.

a float*

Device pointer to A.

lda int

Leading dimension of A.

b float*

Device pointer to B.

ldb int

Leading dimension of B.

beta float*

Scalar multiplier for existing C.

c float*

Device pointer to C (in/out).

ldc int

Leading dimension of C.

SgetrfBatched(nint, int, float**, int, int*, int*, int)

Batched single-precision LU factorisation with partial pivoting.

public static void SgetrfBatched(nint handle, int n, float** aArray, int lda, int* p, int* info, int batchSize)

Parameters

handle nint

cuBLAS handle.

n int

Order of each matrix.

aArray float**

Device array of device pointers to the matrices.

lda int

Leading dimension.

p int*

Device array of n * batchSize pivot indices (output).

info int*

Device array of batchSize status values (output).

batchSize int

Number of matrices.

SgetrsBatched(nint, CuBlasOperation, int, int, float**, int, int*, float**, int, int*, int)

Batched single-precision solve from LU factors. info is a host int.

public static void SgetrsBatched(nint handle, CuBlasOperation trans, int n, int nrhs, float** aArray, int lda, int* devIpiv, float** bArray, int ldb, int* info, int batchSize)

Parameters

handle nint

cuBLAS handle.

trans CuBlasOperation

Operation applied to A.

n int

Order of each matrix.

nrhs int

Right-hand sides per matrix.

aArray float**

Device array of device pointers to the LU factors.

lda int

Leading dimension of A.

devIpiv int*

Device pivot array from the factorisation.

bArray float**

Device array of device pointers to the right-hand sides.

ldb int

Leading dimension of B.

info int*

Host status value.

batchSize int

Number of matrices.

Sscal(nint, long, float, float*)

Scales a single-precision vector in place: x = alpha * x (64-bit element count).

public static void Sscal(nint handle, long n, float alpha, float* x)

Parameters

handle nint
n long
alpha float
x float*

Ssymm(nint, CuBlasSideMode, CuBlasFillMode, int, int, float*, float*, int, float*, int, float*, float*, int)

Single-precision symmetric matrix-matrix multiply: C = alpha * A * B + beta * C (side=Left) or C = alpha * B * A + beta * C (side=Right) where A is symmetric.

public static void Ssymm(nint handle, CuBlasSideMode side, CuBlasFillMode uplo, int m, int n, float* alpha, float* a, int lda, float* b, int ldb, float* beta, float* c, int ldc)

Parameters

handle nint
side CuBlasSideMode
uplo CuBlasFillMode
m int
n int
alpha float*
a float*
lda int
b float*
ldb int
beta float*
c float*
ldc int

Strsm(nint, CuBlasSideMode, CuBlasFillMode, CuBlasOperation, CuBlasDiagType, int, int, float*, float*, int, float*, int)

Single-precision triangular solve: B = alpha * inv(op(A)) * B (side=Left) or B = alpha * B * inv(op(A)) (side=Right) where A is triangular.

public static void Strsm(nint handle, CuBlasSideMode side, CuBlasFillMode uplo, CuBlasOperation trans, CuBlasDiagType diag, int m, int n, float* alpha, float* a, int lda, float* b, int ldb)

Parameters

handle nint
side CuBlasSideMode
uplo CuBlasFillMode
trans CuBlasOperation
diag CuBlasDiagType
m int
n int
alpha float*
a float*
lda int
b float*
ldb int

ZgetrfBatched(nint, int, Complex**, int, int*, int*, int)

Batched complex LU factorisation with partial pivoting.

public static void ZgetrfBatched(nint handle, int n, Complex** aArray, int lda, int* p, int* info, int batchSize)

Parameters

handle nint
n int
aArray Complex**
lda int
p int*
info int*
batchSize int

ZgetrsBatched(nint, CuBlasOperation, int, int, Complex**, int, int*, Complex**, int, int*, int)

Batched complex solve from LU factors. info is a host int.

public static void ZgetrsBatched(nint handle, CuBlasOperation trans, int n, int nrhs, Complex** aArray, int lda, int* devIpiv, Complex** bArray, int ldb, int* info, int batchSize)

Parameters

handle nint
trans CuBlasOperation
n int
nrhs int
aArray Complex**
lda int
devIpiv int*
bArray Complex**
ldb int
info int*
batchSize int

Ztrsm(nint, CuBlasSideMode, CuBlasFillMode, CuBlasOperation, CuBlasDiagType, int, int, Complex*, Complex*, int, Complex*, int)

Complex double-precision triangular solve: B = alpha * inv(op(A)) * B (side = Left) or B = alpha * B * inv(op(A)) (side = Right).

public static void Ztrsm(nint handle, CuBlasSideMode side, CuBlasFillMode uplo, CuBlasOperation trans, CuBlasDiagType diag, int m, int n, Complex* alpha, Complex* a, int lda, Complex* b, int ldb)

Parameters

handle nint
side CuBlasSideMode
uplo CuBlasFillMode
trans CuBlasOperation
diag CuBlasDiagType
m int
n int
alpha Complex*
a Complex*
lda int
b Complex*
ldb int