Is this page helpful?

cuSolverDx#

API reference: cuSolverDx C++ documentation.

Operators#

Operators are set with cusolverdxSetOperatorInt64() or cusolverdxSetOperatorInt64s():

CUSOLVERDX_OPERATOR_SIZE — 1, 2, or 3 int64s (problem size).
CUSOLVERDX_OPERATOR_BLOCK_DIM — 3 int64s.
CUSOLVERDX_OPERATOR_TYPE — CUSOLVERDX_TYPE_REAL, CUSOLVERDX_TYPE_COMPLEX.
CUSOLVERDX_OPERATOR_API — CUSOLVERDX_API_SMEM or CUSOLVERDX_API_SMEM_DYNAMIC_LD.
CUSOLVERDX_OPERATOR_FUNCTION_ABI — COMMONDX_FUNCTION_ABI_NATIVE (the default) or COMMONDX_FUNCTION_ABI_TILE.
CUSOLVERDX_OPERATOR_FUNCTION — see cusolverdxFunction_t for the full list, including CUSOLVERDX_FUNCTION_GETRF_NO_PIVOT, CUSOLVERDX_FUNCTION_GETRS_NO_PIVOT, CUSOLVERDX_FUNCTION_POTRF, CUSOLVERDX_FUNCTION_POTRS, CUSOLVERDX_FUNCTION_TRSM, CUSOLVERDX_FUNCTION_GETRF_PARTIAL_PIVOT, CUSOLVERDX_FUNCTION_GETRS_PARTIAL_PIVOT, CUSOLVERDX_FUNCTION_GEQRF, CUSOLVERDX_FUNCTION_UNMQR, CUSOLVERDX_FUNCTION_GELQF, CUSOLVERDX_FUNCTION_UNMLQ, CUSOLVERDX_FUNCTION_POSV, CUSOLVERDX_FUNCTION_GESV_NO_PIVOT, CUSOLVERDX_FUNCTION_GESV_PARTIAL_PIVOT, CUSOLVERDX_FUNCTION_GELS, CUSOLVERDX_FUNCTION_UNGQR, CUSOLVERDX_FUNCTION_UNGLQ, CUSOLVERDX_FUNCTION_GTSV_NO_PIVOT, CUSOLVERDX_FUNCTION_HTEV, CUSOLVERDX_FUNCTION_HEEV, CUSOLVERDX_FUNCTION_HEGST, CUSOLVERDX_FUNCTION_HEGV, CUSOLVERDX_FUNCTION_MODIFIED_LU, CUSOLVERDX_FUNCTION_BDSVD, CUSOLVERDX_FUNCTION_GESVD.
CUSOLVERDX_OPERATOR_EXECUTION — COMMONDX_EXECUTION_BLOCK or COMMONDX_EXECUTION_THREAD.
CUSOLVERDX_OPERATOR_PRECISION — COMMONDX_PRECISION_F32, COMMONDX_PRECISION_F64.
CUSOLVERDX_OPERATOR_SM — target SM.
CUSOLVERDX_OPERATOR_ARRANGEMENT — CUSOLVERDX_ARRANGEMENT_COL_MAJOR/ROW_MAJOR (optional).
CUSOLVERDX_OPERATOR_FILL_MODE — CUSOLVERDX_FILL_MODE_LOWER/UPPER (symmetric).
CUSOLVERDX_OPERATOR_SIDE — CUSOLVERDX_SIDE_LEFT/RIGHT.
CUSOLVERDX_OPERATOR_DIAG — CUSOLVERDX_DIAG_UNIT/NON_UNIT.
CUSOLVERDX_OPERATOR_TRANSPOSE_MODE — CUSOLVERDX_TRANSPOSE_MODE_NON_TRANSPOSED/TRANSPOSED/CONJ_TRANSPOSED (optional).
CUSOLVERDX_OPERATOR_LEADING_DIMENSION — leading dimensions (lda, ldb, …) (optional).
CUSOLVERDX_OPERATOR_BATCHES_PER_BLOCK — independent problems solved by one block (optional, defaults to 1, must be > 0, block execution only).
CUSOLVERDX_OPERATOR_JOB — CUSOLVERDX_JOB_NO_VECTORS, CUSOLVERDX_JOB_ALL_VECTORS, CUSOLVERDX_JOB_MULTIPLY_VECTORS, CUSOLVERDX_JOB_OVERWRITE_VECTORS, or CUSOLVERDX_JOB_SOME_VECTORS (optional, for eigensolvers and SVD; supported jobs depend on the function).
CUSOLVERDX_OPERATOR_EIG_TYPE — 1, 2 or 3, LAPACK’s itype (optional, defaults to 1).

Options#

Use cusolverdxSetOptionStr() to set COMMONDX_OPTION_SYMBOL_NAME for the device function name.

Traits#

cusolverdxGetTraitInt64() — CUSOLVERDX_TRAIT_SUGGESTED_BATCHES_PER_BLOCK, CUSOLVERDX_TRAIT_WORKSPACE_SIZE (number of workspace elements, not bytes).
cusolverdxGetTraitInt64s() — CUSOLVERDX_TRAIT_BLOCK_DIM, CUSOLVERDX_TRAIT_SUGGESTED_BLOCK_DIM.
cusolverdxGetTraitStrSize() + cusolverdxGetTraitStr() — CUSOLVERDX_TRAIT_SYMBOL_NAME.

Universal fatbin#

Use cusolverdxGetUniversalFATBINSize() and cusolverdxGetUniversalFATBIN() to get a fatbin containing the precompiled solver implementations. Link it together with the generated LTOIR using NVJITLINK_INPUT_FATBIN and NVJITLINK_INPUT_LTOIR, respectively.

Device function signatures#

Signatures depend on the selected cusolverdxApi_t. For CUSOLVERDX_API_SMEM, leading dimensions are fixed at compile time. For CUSOLVERDX_API_SMEM_DYNAMIC_LD, the native function ABI passes leading dimensions as const unsigned* at runtime. This API does not support COMMONDX_FUNCTION_ABI_TILE; finalization returns COMMONDX_INVALID_VALUE for that combination. Both function ABIs const-qualify read-only operands. The Tile ABI places input and input-output operands first in declaration order, then output operands in declaration order, and compiler-provided scratch last.

SMEM API signatures#
Function	Native function ABI	Tile function ABI
GETRF (no pivot)	`void symbol(A, info)`	Same as Native
GETRS (no pivot)	`void symbol(const A, B)`	Same as Native
POTRF	`void symbol(A, info)`	Same as Native
POTRS	`void symbol(const A, B)`	Same as Native
TRSM	`void symbol(const A, B)`	Same as Native
GETRF (partial pivot)	`void symbol(A, ipiv, info*)`	Same as Native
GETRS (partial pivot)	`void symbol(const A, const ipiv, B*)`	Same as Native
GEQRF / GELQF	`void symbol(A, tau)`	Same as Native
UNMQR / UNMLQ	`void symbol(const A, const tau, C*)`	Same as Native
POSV	`void symbol(A, B, info*)`	Same as Native
GESV (no pivot)	`void symbol(A, B, info*)`	Same as Native
GESV (partial pivot)	`void symbol(A, ipiv, B, info)`	`void symbol(A, B, ipiv, info)`
GELS	`void symbol(A, tau, B*)`	`void symbol(A, B, tau*)`
UNGQR / UNGLQ	`void symbol(A, const tau)`	Same as Native
GTSV (no pivot)	`void symbol(const dl, const d, const du, B, info*)`	Same as Native
HTEV	`void symbol(d, e, [v,] info)`	Same as Native
HEEV, Thread	`void symbol(A, lambda, workspace, info)`	`void symbol(A, lambda, info*)`
HEEV, Block	`void symbol(A, lambda, workspace, info)`	`void symbol(A, lambda, info, void workspace)`
HEGST, Thread	`void symbol(A, const B, workspace*)`	`void symbol(A, const B)`
HEGST, Block	`void symbol(A, const B, workspace*)`	`void symbol(A, const B, void* workspace)`
HEGV, Thread	`void symbol(A, B, lambda, workspace, info*)`	`void symbol(A, B, lambda, info)`
HEGV, Block	`void symbol(A, B, lambda, workspace, info*)`	`void symbol(A, B, lambda, info, void* workspace)`
Modified LU	`void symbol(A, S)`	Same as Native
BDSVD	`void symbol(d, e, [U, VT,] info*)`	Same as Native
GESVD, Thread	`void symbol(A, S, [U, VT,] workspace, info)`	`void symbol(A, S, [U, VT,] info*)`
GESVD, Block	`void symbol(A, S, [U, VT,] workspace, info)`	`void symbol(A, S, [U, VT,] info, void workspace)`

Square brackets indicate operands that are present only when the selected job computes vectors. For BDSVD and GESVD multiply-vector jobs, each vector operand is input-output and therefore precedes output-only operands in the Tile signature, while retaining declaration order within each access group. See the Doxygen reference for cusolverdxFunction_t for the complete signatures, including the dynamic-LD variants.

Examples#

cuSolverDx cholesky factorization example#

/*
 * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <libcusolverdx.h>
#include <nvrtc.h>

#include <vector>

#include "common_examples.hpp"
#include "macros.hpp"

using namespace examples;

int main() {

    long long int size[1] = { 64 };
    long long int block_dim[3] = { 256, 1, 1 };

    /**
     * Create a descriptor
     * This is equivalent to `using SOLVER = ...` in cuSOLVERDx C++
     */

    cusolverdxDescriptor h { 0 };
    LIBMATHDX_CHECK(cusolverdxCreateDescriptor(&h));
    // Sets problem size
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64s(h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_SIZE, 1, size));
    // CUSOLVERDX_OPERATOR_BLOCK_DIM indicates the block dimension
    LIBMATHDX_CHECK(
        cusolverdxSetOperatorInt64s(h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_BLOCK_DIM, 3, block_dim));
    // CUSOLVERDX_TYPE_REAL means the inputs contain real type data
    // CUSOLVERDX_TYPE_COMPLEX would be for inputs with complex type data
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_TYPE, cusolverdxType::CUSOLVERDX_TYPE_REAL));
    // CUSOLVERDX_API_SMEM means that inputs are in smem
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_API, cusolverdxApi::CUSOLVERDX_API_SMEM));
    // This means we generate a solver based on picked algorithm ("POTRF")
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_FUNCTION, cusolverdxFunction::CUSOLVERDX_FUNCTION_POTRF));
    // COMMONDX_EXECUTION_BLOCK means multiple threads in a block participate in the solver
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_EXECUTION, commondxExecution::COMMONDX_EXECUTION_BLOCK));
    // COMMONDX_PRECISION_F32 for single precision
    // COMMONDX_PRECISION_F64 for double precision
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_PRECISION, commondxPrecision::COMMONDX_PRECISION_F64));
    // Sets fill mode for symmetric matrices
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_FILL_MODE, cusolverdxFillMode::CUSOLVERDX_FILL_MODE_LOWER));
    // Compute capability to target
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_SM, 800));

    // COMMONDX_OPTION_SYMBOL_NAME indicates the required name for the device function.
    LIBMATHDX_CHECK(cusolverdxSetOptionStr(h, commondxOption::COMMONDX_OPTION_SYMBOL_NAME, "my_solver"));

    /**
     * Compile the device function
     */

    commondxCode code;
    LIBMATHDX_CHECK(commondxCreateCode(&code));
    // Specify arch to compile to
    LIBMATHDX_CHECK(commondxSetCodeOptionInt64(code, COMMONDX_OPTION_TARGET_SM, 800ll));
    LIBMATHDX_CHECK(cusolverdxFinalizeCode(code, h));
    size_t lto_size = 0;
    LIBMATHDX_CHECK(commondxGetCodeLTOIRSize(code, &lto_size));
    std::vector<char> lto(lto_size);
    LIBMATHDX_CHECK(commondxGetCodeLTOIR(code, lto.size(), lto.data()));
    LIBMATHDX_CHECK(commondxDestroyCode(code));

    /**
     * Query the universal cuSOLVERDx fatbin
     */

    size_t fatbin_size = 0;
    LIBMATHDX_CHECK(cusolverdxGetUniversalFATBINSize(h, &fatbin_size));
    std::vector<char> fatbin(fatbin_size);
    LIBMATHDX_CHECK(cusolverdxGetUniversalFATBIN(h, fatbin.size(), fatbin.data()));

    printf("Successfully generated LTOIR, %zu bytes for POTRF of size %d; universal fatbin %zu bytes\n",
           lto_size,
           (int)size[0],
           fatbin_size);

    LIBMATHDX_CHECK(cusolverdxDestroyDescriptor(h));
}

cuSolverDx cholesky solve example#

/*
 * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <libcusolverdx.h>
#include <nvrtc.h>

#include <vector>

#include "common_examples.hpp"
#include "macros.hpp"

using namespace examples;

int main() {

    long long int size[1] = { 64 };
    long long int block_dim[3] = { 256, 1, 1 };

    /**
     * Create a descriptor
     * This is equivalent to `using SOLVER = ...` in cuSOLVERDx C++
     */

    cusolverdxDescriptor h { 0 };
    LIBMATHDX_CHECK(cusolverdxCreateDescriptor(&h));
    // Sets problem size
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64s(h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_SIZE, 1, size));
    // CUSOLVERDX_OPERATOR_BLOCK_DIM indicates the block dimension
    LIBMATHDX_CHECK(
        cusolverdxSetOperatorInt64s(h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_BLOCK_DIM, 3, block_dim));
    // CUSOLVERDX_TYPE_REAL means the inputs contain real type data
    // CUSOLVERDX_TYPE_COMPLEX would be for inputs with complex type data
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_TYPE, cusolverdxType::CUSOLVERDX_TYPE_REAL));
    // CUSOLVERDX_API_SMEM means that inputs are in smem
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_API, cusolverdxApi::CUSOLVERDX_API_SMEM));
    // Location of the non zeroes
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_FILL_MODE, cusolverdxFillMode::CUSOLVERDX_FILL_MODE_LOWER));
    // This means we generate a solver based on picked algorithm ("POTRS")
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_FUNCTION, cusolverdxFunction::CUSOLVERDX_FUNCTION_POTRS));
    // COMMONDX_EXECUTION_BLOCK means multiple threads in a block participate in the solver
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_EXECUTION, commondxExecution::COMMONDX_EXECUTION_BLOCK));
    // COMMONDX_PRECISION_F32 for single precision
    // COMMONDX_PRECISION_F64 for double precision
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_PRECISION, commondxPrecision::COMMONDX_PRECISION_F32));
    // Compute capability to target
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_SM, 800));

    // COMMONDX_OPTION_SYMBOL_NAME indicates the required name for the device function.
    LIBMATHDX_CHECK(cusolverdxSetOptionStr(h, commondxOption::COMMONDX_OPTION_SYMBOL_NAME, "my_potrs"));

    /**
     * Compile the device function
     */

    commondxCode code;
    LIBMATHDX_CHECK(commondxCreateCode(&code));
    // Specify arch to compile to
    LIBMATHDX_CHECK(commondxSetCodeOptionInt64(code, COMMONDX_OPTION_TARGET_SM, 800ll));
    LIBMATHDX_CHECK(cusolverdxFinalizeCode(code, h));
    size_t lto_size = 0;
    LIBMATHDX_CHECK(commondxGetCodeLTOIRSize(code, &lto_size));
    std::vector<char> lto(lto_size);
    LIBMATHDX_CHECK(commondxGetCodeLTOIR(code, lto.size(), lto.data()));
    LIBMATHDX_CHECK(commondxDestroyCode(code));

    /**
     * Query the universal cuSOLVERDx fatbin
     */

    size_t fatbin_size = 0;
    LIBMATHDX_CHECK(cusolverdxGetUniversalFATBINSize(h, &fatbin_size));

    std::vector<char> fatbin(fatbin_size);
    LIBMATHDX_CHECK(cusolverdxGetUniversalFATBIN(h, fatbin.size(), fatbin.data()));

    printf("Successfully generated LTOIR, %zu bytes for POTRS of size %d; universal fatbin %zu bytes\n",
           lto_size,
           (int)size[0],
           fatbin_size);

    // How much workspace (in scalar elements) does the function need?
    long long int workspace_size = 0;
    LIBMATHDX_CHECK(cusolverdxGetTraitInt64(h, cusolverdxTraitType::CUSOLVERDX_TRAIT_WORKSPACE_SIZE, &workspace_size));

    printf("Function requires %lld workspace elements\n", workspace_size);

    LIBMATHDX_CHECK(cusolverdxDestroyDescriptor(h));
}

cuSolverDx triangular solve example#

/*
 * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <libcusolverdx.h>
#include <nvrtc.h>

#include <vector>

#include "common_examples.hpp"
#include "macros.hpp"

using namespace examples;

int main() {

    long long int size[3] = { 64, 64, 32 };
    long long int block_dim[3] = { 256, 1, 1 };

    /**
     * Create a descriptor
     * This is equivalent to `using SOLVER = ...` in cuSOLVERDx C++
     */

    cusolverdxDescriptor h { 0 };
    LIBMATHDX_CHECK(cusolverdxCreateDescriptor(&h));
    // Sets problem size
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64s(h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_SIZE, 3, size));
    // CUSOLVERDX_OPERATOR_BLOCK_DIM indicates the block dimension
    LIBMATHDX_CHECK(
        cusolverdxSetOperatorInt64s(h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_BLOCK_DIM, 3, block_dim));
    // CUSOLVERDX_TYPE_REAL means the inputs contain real type data
    // CUSOLVERDX_TYPE_COMPLEX would be for inputs with complex type data
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_TYPE, cusolverdxType::CUSOLVERDX_TYPE_REAL));
    // CUSOLVERDX_API_SMEM means that inputs are in smem
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_API, cusolverdxApi::CUSOLVERDX_API_SMEM));
    // Location of the non zeroes
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_FILL_MODE, cusolverdxFillMode::CUSOLVERDX_FILL_MODE_LOWER));
    // Location of the triangular matrix
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_SIDE, cusolverdxSide::CUSOLVERDX_SIDE_LEFT));
    // Diagonal of the triangular matrix
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_DIAG, cusolverdxDiag::CUSOLVERDX_DIAG_NON_UNIT));
    // This means we generate a triangular-solve matrix, aka L^1 A or U^1 A, where A is a matrix and L/U are triangular
    // matrices ("TRSM")
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_FUNCTION, cusolverdxFunction::CUSOLVERDX_FUNCTION_TRSM));
    // COMMONDX_EXECUTION_BLOCK means multiple threads in a block participate in the solver
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_EXECUTION, commondxExecution::COMMONDX_EXECUTION_BLOCK));
    // COMMONDX_PRECISION_F32 for single precision
    // COMMONDX_PRECISION_F64 for double precision
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(
        h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_PRECISION, commondxPrecision::COMMONDX_PRECISION_F32));
    // Compute capability to target
    LIBMATHDX_CHECK(cusolverdxSetOperatorInt64(h, cusolverdxOperatorType::CUSOLVERDX_OPERATOR_SM, 900));

    // COMMONDX_OPTION_SYMBOL_NAME indicates the required name for the device function.
    LIBMATHDX_CHECK(cusolverdxSetOptionStr(h, commondxOption::COMMONDX_OPTION_SYMBOL_NAME, "my_trsm"));

    /**
     * Compile the device function
     */

    commondxCode code;
    LIBMATHDX_CHECK(commondxCreateCode(&code));
    // Specify arch to compile to
    LIBMATHDX_CHECK(commondxSetCodeOptionInt64(code, COMMONDX_OPTION_TARGET_SM, 900));
    LIBMATHDX_CHECK(cusolverdxFinalizeCode(code, h));
    size_t lto_size = 0;
    LIBMATHDX_CHECK(commondxGetCodeLTOIRSize(code, &lto_size));
    std::vector<char> lto(lto_size);
    LIBMATHDX_CHECK(commondxGetCodeLTOIR(code, lto.size(), lto.data()));
    LIBMATHDX_CHECK(commondxDestroyCode(code));

    /**
     * Query the universal cuSOLVERDx fatbin
     */

    size_t fatbin_size = 0;
    LIBMATHDX_CHECK(cusolverdxGetUniversalFATBINSize(h, &fatbin_size));

    std::vector<char> fatbin(fatbin_size);
    LIBMATHDX_CHECK(cusolverdxGetUniversalFATBIN(h, fatbin.size(), fatbin.data()));

    printf("Successfully generated LTOIR, %zu bytes for TRSM %dx%dx%d; universal fatbin %zu bytes\n",
           lto_size,
           (int)size[0],
           (int)size[1],
           (int)size[2],
           fatbin_size);

    // How much workspace (in scalar elements) does the function need?
    long long int workspace_size = 0;
    LIBMATHDX_CHECK(cusolverdxGetTraitInt64(h, cusolverdxTraitType::CUSOLVERDX_TRAIT_WORKSPACE_SIZE, &workspace_size));

    printf("Function requires %lld workspace elements\n", workspace_size);

    LIBMATHDX_CHECK(cusolverdxDestroyDescriptor(h));
}

API reference#

typedef long long int cusolverdxDescriptor#

A cuSOLVERDx descriptor.

Equivalent to using SOLVER = ... in cuSOLVERDx C++.

enum cusolverdxApi_t#

Type of cusolverdx API.

Values:

enumerator CUSOLVERDX_API_SMEM#: Input-output is in shared memory. Function signatures are defined by cusolverdxFunction_t. Leading dimensions are fixed at compile time based on problem size or provided operator. Functions are extern "C" and the symbol name can be queried using CUSOLVERDX_TRAIT_SYMBOL_NAME.

enumerator CUSOLVERDX_API_SMEM_DYNAMIC_LD#: Input-output is in shared memory with dynamic leading dimensions. Function signatures are defined by cusolverdxFunction_t. Leading dimensions are passed as pointers to const unsigned 32b integers (const unsigned*) at runtime. Functions are extern "C" and the symbol name can be queried using CUSOLVERDX_TRAIT_SYMBOL_NAME.

enum cusolverdxType_t#

Type of input values.

Values:

enumerator CUSOLVERDX_TYPE_REAL#: Input and output is real

enumerator CUSOLVERDX_TYPE_COMPLEX#: Input and output are complex

enum cusolverdxFunction_t#

Type of device function.

The function signatures depend on the selected cusolverdxApi_t :

For CUSOLVERDX_API_SMEM : Leading dimensions are fixed at compile time.
For CUSOLVERDX_API_SMEM_DYNAMIC_LD : Leading dimensions are passed as pointers to const unsigned at runtime.

Generated signatures const-qualify operands that the selected function treats as read-only for both function ABIs. COMMONDX_FUNCTION_ABI_TILE supports only CUSOLVERDX_API_SMEM. Finalization returns COMMONDX_INVALID_VALUE when it is combined with CUSOLVERDX_API_SMEM_DYNAMIC_LD.

The individual function descriptions below list signatures when the function ABIs differ.

Type definitions used in function signatures:

value_type: The value type determined by CUSOLVERDX_OPERATOR_TYPE and CUSOLVERDX_OPERATOR_PRECISION. For real types: float or double. For complex types: cuFloatComplex or cuDoubleComplex.
precision_type: The real-valued type determined by CUSOLVERDX_OPERATOR_PRECISION : float or double.
status_type: A signed 32b integer (int) used to return status information.

All functions are extern "C" and the symbol name can be queried using CUSOLVERDX_TRAIT_SYMBOL_NAME.

Values:

enumerator CUSOLVERDX_FUNCTION_GETRF_NO_PIVOT#

LU without pivoting factorization See cuSOLVERDx LU factorization for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/getrf.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (value_type* A, status_type* info)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, status_type* info)

enumerator CUSOLVERDX_FUNCTION_GETRS_NO_PIVOT#

LU without pivoting solve See cuSOLVERDx LU solve for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/getrs.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (const value_type* A, value_type* B)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (const value_type* A, const unsigned* lda, value_type* B, const unsigned* ldb)

enumerator CUSOLVERDX_FUNCTION_POTRF#

Cholesky factorization See cuSOLVERDx Cholesky factorization for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/potrf.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (value_type* A, status_type* info)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, status_type* info)

enumerator CUSOLVERDX_FUNCTION_POTRS#

Cholesky solve See cuSOLVERDx Cholesky solve for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/potrs.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (const value_type* A, value_type* B)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (const value_type* A, const unsigned* lda, value_type* B, const unsigned* ldb)

enumerator CUSOLVERDX_FUNCTION_TRSM#

Triangular-solve with matrix right hand side See cuSOLVERDx TRiangular Solve with Matrix right hand side for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/trsm.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (const value_type* A, value_type* B)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (const value_type* A, const unsigned* lda, value_type* B, const unsigned* ldb)

enumerator CUSOLVERDX_FUNCTION_GETRF_PARTIAL_PIVOT#

LU with partial pivoting factorization See cuSOLVERDx LU factorization for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/getrf.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (value_type* A, int* ipiv, status_type* info)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, int* ipiv, status_type* info)

enumerator CUSOLVERDX_FUNCTION_GETRS_PARTIAL_PIVOT#

LU with partial pivoting solve See cuSOLVERDx LU solve for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/getrs.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (const value_type* A, const int* ipiv, value_type* B)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (const value_type* A, const unsigned* lda, const int* ipiv, value_type* B, const unsigned* ldb)

enumerator CUSOLVERDX_FUNCTION_GEQRF#

QR Factorization See cuSOLVERDx QR factorize for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/geqrf.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (value_type* A, value_type* tau)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, value_type* tau)

enumerator CUSOLVERDX_FUNCTION_UNMQR#

Multiplication of Q From QR Factorization See cuSOLVERDx QR multiplication for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/unmqr.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (const value_type* A, const value_type* tau, value_type* C)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (const value_type* A, const unsigned* lda, const value_type* tau, value_type* C, const unsigned* ldc)

enumerator CUSOLVERDX_FUNCTION_GELQF#

LQ Factorization See cuSOLVERDx LQ factorize for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/gelqf.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (value_type* A, value_type* tau)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, value_type* tau)

enumerator CUSOLVERDX_FUNCTION_UNMLQ#

Multiplication of Q From LQ Factorization See cuSOLVERDx LQ multiplication for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/unmlq.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (const value_type* A, const value_type* tau, value_type* C)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (const value_type* A, const unsigned* lda, const value_type* tau, value_type* C, const unsigned* ldc)

enumerator CUSOLVERDX_FUNCTION_POSV#

Cholesky factorize and solve See cuSOLVERDx Cholesky solve for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/posv.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (value_type* A, value_type* B, status_type* info)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, value_type* B, const unsigned* ldb, status_type* info)

enumerator CUSOLVERDX_FUNCTION_GESV_NO_PIVOT#

LU without pivoting factorize and solve See cuSOLVERDx LU solve for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/gesv.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (value_type* A, value_type* B, status_type* info)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, value_type* B, const unsigned* ldb, status_type* info)

enumerator CUSOLVERDX_FUNCTION_GESV_PARTIAL_PIVOT#

LU with partial pivoting factorize and solve See cuSOLVERDx LU solve for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/gesv.html)

Function signature for CUSOLVERDX_API_SMEM with COMMONDX_FUNCTION_ABI_NATIVE: void (value_type* A, int* ipiv, value_type* B, status_type* info)

Function signature for CUSOLVERDX_API_SMEM with COMMONDX_FUNCTION_ABI_TILE: void (value_type* A, value_type* B, int* ipiv, status_type* info)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, int* ipiv, value_type* B, const unsigned* ldb, status_type* info)

enumerator CUSOLVERDX_FUNCTION_GELS#

Generalized Linear System Solver See cuSOLVERDx Generalized Linear System Solver for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/gels.html)

Function signature for CUSOLVERDX_API_SMEM with COMMONDX_FUNCTION_ABI_NATIVE: void (value_type* A, value_type* tau, value_type* B)

Function signature for CUSOLVERDX_API_SMEM with COMMONDX_FUNCTION_ABI_TILE: void (value_type* A, value_type* B, value_type* tau)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, value_type* tau, value_type* B, const unsigned* ldb)

enumerator CUSOLVERDX_FUNCTION_UNGQR#

Matrix Q Generation from QR Factorization See cuSOLVERDx Generalized Linear System Solver for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/ungqr.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (value_type* A, const value_type* tau)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, const value_type* tau)

enumerator CUSOLVERDX_FUNCTION_UNGLQ#

Matrix Q Generation from LQ Factorization See cuSOLVERDx UNitary matrix Generation after LQ factorization for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/unglq.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (value_type* A, const value_type* tau)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* A, const unsigned* lda, const value_type* tau)

enumerator CUSOLVERDX_FUNCTION_GTSV_NO_PIVOT#

Solve General Tridiagonal System of Equations See cuSOLVERDx General Tridiagonal system SolVe for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/gtsv.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): void (const value_type* dl, const value_type* d, const value_type* du, value_type* B, status_type* info)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (const value_type* dl, const value_type* d, const value_type* du, value_type* B, const unsigned* ldb, status_type* info)

enumerator CUSOLVERDX_FUNCTION_HTEV#

Eigenvalue Solver for Symmetric or Hermitian Tridiagonal Matrix See cuSOLVERDx symmetric or Hermitian Tridiagonal EigenValues Solver for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/htev.html)

Function signature for CUSOLVERDX_API_SMEM (both function ABIs): When CUSOLVERDX_OPERATOR_JOB is CUSOLVERDX_JOB_NO_VECTORS : void (value_type* smem_d, value_type* smem_e, status_type* info) Otherwise: void (value_type* smem_d, value_type* smem_e, value_type* smem_v, status_type* info)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* smem_d, value_type* smem_e, value_type* smem_v, unsigned int* ldv, status_type* info) Note: Dynamic LD is supported only for eigenvector calculation (CUSOLVERDX_OPERATOR_JOB in {CUSOLVERDX_JOB_ALL_VECTORS, CUSOLVERDX_JOB_MULTIPLY_VECTORS}).

enumerator CUSOLVERDX_FUNCTION_HEEV#

Eigenvalue Solver for Symmetric or Hermitian Matrix See cuSOLVERDx symmetric or HErmitian EigenValue Solver for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/heev.html)

Function signatures for CUSOLVERDX_API_SMEM :

COMMONDX_FUNCTION_ABI_NATIVE : void (value_type* smem_a, precision_type* smem_lambda, value_type* workspace, status_type* info)
COMMONDX_FUNCTION_ABI_TILE :
- COMMONDX_EXECUTION_THREAD : void (value_type* smem_a, precision_type* smem_lambda, status_type* info)
- COMMONDX_EXECUTION_BLOCK : void (value_type* smem_a, precision_type* smem_lambda, status_type* info, void* workspace)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* smem_a, unsigned int* lda, precision_type* smem_lambda, value_type* workspace, status_type* info)

enumerator CUSOLVERDX_FUNCTION_MODIFIED_LU#

Modified LU factorization without pivoting for an orthonormal matrix See cuSOLVERDx Modified LU factorization for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/modified_lu.html)

Function signature for CUSOLVERDX_API_SMEM : void (value_type* smem_a, value_type* smem_s)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD : void (value_type* smem_a, const unsigned* lda, value_type* smem_s)

enumerator CUSOLVERDX_FUNCTION_BDSVD#

Singular Value Decomposition of a Bidiagonal Matrix See cuSOLVERDx BiDiagonal Singular Value Decomposition for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/bdsvd.html)

Note: only CUSOLVERDX_TYPE_REAL is supported.

Function signature for CUSOLVERDX_API_SMEM : When CUSOLVERDX_OPERATOR_JOB is CUSOLVERDX_JOB_NO_VECTORS (singular values only): void (value_type* smem_d, value_type* smem_e, status_type* info) Otherwise: void (value_type* smem_d, value_type* smem_e, value_type* smem_u, value_type* smem_vt, status_type* info)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD : void (value_type* smem_d, value_type* smem_e, value_type* smem_u, const unsigned* ldu, value_type* smem_vt, const unsigned* ldvt, status_type* info) Note: Dynamic LD is supported only when singular vectors are requested (CUSOLVERDX_OPERATOR_JOB not CUSOLVERDX_JOB_NO_VECTORS ).

enumerator CUSOLVERDX_FUNCTION_GESVD#

Singular Value Decomposition of a General Matrix See cuSOLVERDx GEneral matrix Singular Value Decomposition for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/gesvd.html)

Function signature for CUSOLVERDX_API_SMEM : COMMONDX_FUNCTION_ABI_NATIVE : When CUSOLVERDX_OPERATOR_JOB is CUSOLVERDX_JOB_NO_VECTORS (singular values only): void (value_type* smem_a, precision_type* smem_s, value_type* workspace, status_type* info) Otherwise: void (value_type* smem_a, precision_type* smem_s, value_type* smem_u, value_type* smem_vt, value_type* workspace, status_type* info) COMMONDX_FUNCTION_ABI_TILE omits workspace for COMMONDX_EXECUTION_THREAD. For COMMONDX_EXECUTION_BLOCK, it moves status_type* info before a final void* workspace.

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD : When CUSOLVERDX_OPERATOR_JOB is CUSOLVERDX_JOB_NO_VECTORS (singular values only): void (value_type* smem_a, const unsigned* lda, precision_type* smem_s, value_type* workspace, status_type* info) Otherwise: void (value_type* smem_a, const unsigned* lda, precision_type* smem_s, value_type* smem_u, const unsigned* ldu, value_type* smem_vt, const unsigned* ldvt, value_type* workspace, status_type* info)

enumerator CUSOLVERDX_FUNCTION_HEGST#

Reduction of a Hermitian-definite generalized eigenproblem to standard form See cuSOLVERDx symmetric or HErmitian Generalized eigenproblem to STandard form for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/hegst.html)

Function signatures for CUSOLVERDX_API_SMEM :

COMMONDX_FUNCTION_ABI_NATIVE : void (value_type* smem_a, const value_type* smem_b, value_type* workspace)
COMMONDX_FUNCTION_ABI_TILE :
- COMMONDX_EXECUTION_THREAD : void (value_type* smem_a, const value_type* smem_b)
- COMMONDX_EXECUTION_BLOCK : void (value_type* smem_a, const value_type* smem_b, void* workspace)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* smem_a, const unsigned* lda, const value_type* smem_b, const unsigned* ldb, value_type* workspace)

enumerator CUSOLVERDX_FUNCTION_HEGV#

Generalized Eigenvalue Solver for a Symmetric or Hermitian Matrix See cuSOLVERDx symmetric or HErmitian Generalized eigenValue solver for more details (https://docs.nvidia.com/cuda/cusolverdx/get_started/functions/hegv.html)

Function signatures for CUSOLVERDX_API_SMEM :

COMMONDX_FUNCTION_ABI_NATIVE : void (value_type* smem_a, value_type* smem_b, precision_type* smem_lambda, value_type* workspace, status_type* info)
COMMONDX_FUNCTION_ABI_TILE :
- COMMONDX_EXECUTION_THREAD : void (value_type* smem_a, value_type* smem_b, precision_type* smem_lambda, status_type* info)
- COMMONDX_EXECUTION_BLOCK : void (value_type* smem_a, value_type* smem_b, precision_type* smem_lambda, status_type* info, void* workspace)

Function signature for CUSOLVERDX_API_SMEM_DYNAMIC_LD (COMMONDX_FUNCTION_ABI_NATIVE only): void (value_type* smem_a, const unsigned* lda, value_type* smem_b, const unsigned* ldb, precision_type* smem_lambda, value_type* workspace, status_type* info)

enum cusolverdxArrangement_t#

Data arrangement mode.

Defines data arrangements in tensors’ taking part in the calculation.

Values:

enumerator CUSOLVERDX_ARRANGEMENT_COL_MAJOR#: Input and output are column major

enumerator CUSOLVERDX_ARRANGEMENT_ROW_MAJOR#: Input and output are row major

enum cusolverdxFillMode_t#

Tensor fill mode.

For symmetric matrix the fill mode can be upper or lower triangular

Values:

enumerator CUSOLVERDX_FILL_MODE_UPPER#: Upper-triangular

enumerator CUSOLVERDX_FILL_MODE_LOWER#: Lower-triangular

enum cusolverdxDiag_t#

Diag operator.

Indicates whether the matrix diagonal is unit (all ones) or non-unit.

Values:

enumerator CUSOLVERDX_DIAG_UNIT#: Unit diagonal

enumerator CUSOLVERDX_DIAG_NON_UNIT#: Non unit diagonal

enum cusolverdxSide_t#

Side operator.

Indicates which side an operator is applied from in operations such as matrix multiplication.

Values:

enumerator CUSOLVERDX_SIDE_LEFT#: Left side

enumerator CUSOLVERDX_SIDE_RIGHT#: Right side

enum cusolverdxTransposeMode_t#

Transpose mode.

Indicates inputs or outputs must be considered transposed.

Values:

enumerator CUSOLVERDX_TRANSPOSE_MODE_NON_TRANSPOSED#: Use matrix as-is in the operation

enumerator CUSOLVERDX_TRANSPOSE_MODE_TRANSPOSED#: Use transposed matrix in the operation

enumerator CUSOLVERDX_TRANSPOSE_MODE_CONJ_TRANSPOSED#: Use transposed and conjugate matrix in the operation

enum cusolverdxJob_t#

Job operator.

Specifies whether and how eigenvectors or singular vectors are computed and stored in eigenvalue and singular value operations.

Values:

enumerator CUSOLVERDX_JOB_NO_VECTORS#: Don’t compute any vectors

enumerator CUSOLVERDX_JOB_ALL_VECTORS#: Compute all vectors in a separate storage array

enumerator CUSOLVERDX_JOB_MULTIPLY_VECTORS#: Compute all vectors and multiply them to the existing array content

enumerator CUSOLVERDX_JOB_OVERWRITE_VECTORS#: Compute vectors and overwrite the input A matrix

enumerator CUSOLVERDX_JOB_SOME_VECTORS#: Compute min(M, N) vectors in a separate storage array

enum cusolverdxOperatorType_t#

Operators.

The set of supported cusolverDx operators.

Values:

enumerator CUSOLVERDX_OPERATOR_SIZE#: Operator data type: long long int * 1 or long long int * 2 or long long int * 3. See https://docs.nvidia.com/cuda/cusolverdx/api/description_ops.html#size-operator. Expected content: <M> or <M, N> or <M, N, K> problem sizes. Operator definition: required

enumerator CUSOLVERDX_OPERATOR_TYPE#: Operator data type: cusolverdxType_t. Operator definition: required

enumerator CUSOLVERDX_OPERATOR_PRECISION#: Operator data type: commondxPrecision_t. Operator definition: required

enumerator CUSOLVERDX_OPERATOR_SM#: Operator data type: long long int. Expected content: 700 (Volta), 800 (Ampere), …, Operator definition: required

enumerator CUSOLVERDX_OPERATOR_EXECUTION#: Operator data type: commondxExecution_t. Operator definition: required

enumerator CUSOLVERDX_OPERATOR_BLOCK_DIM#: Operator data type: long long * 3. Expected content: <x, y, z> block dimensions. Operator definition: optional

enumerator CUSOLVERDX_OPERATOR_API#: Operator data type: cusolverdxApi_t. Operator definition: required

enumerator CUSOLVERDX_OPERATOR_FUNCTION#: Operator data type: cusolverdxFunction_t. Operator definition: required

enumerator CUSOLVERDX_OPERATOR_ARRANGEMENT#: Operator data type: cusolverdxArrangement_t * 1, 2 or 3. Expected content: <a>, <a, b> or <a, b, c> arrangements. The entries map to the matrices of the function: <A> or <A, B> for most functions, <U, VT> for CUSOLVERDX_FUNCTION_BDSVD and <A, U, VT> for CUSOLVERDX_FUNCTION_GESVD (the third entry is only used by CUSOLVERDX_FUNCTION_GESVD with singular vectors). Operator definition: optional

enumerator CUSOLVERDX_OPERATOR_FILL_MODE#: Operator data type: cusolverdxFillMode_t. Operator definition: optional

enumerator CUSOLVERDX_OPERATOR_SIDE#: Operator data type: cusolverdxSide_t. Operator definition: optional

enumerator CUSOLVERDX_OPERATOR_DIAG#: Operator data type: cusolverdxDiag_t. Operator definition: optional

enumerator CUSOLVERDX_OPERATOR_TRANSPOSE_MODE#: Operator data type: cusolverdxTransposeMode_t. Operator definition: optional

enumerator CUSOLVERDX_OPERATOR_LEADING_DIMENSION#: Operator data type: long long. Expected content: <lda, ldb, …>. Operator definition: optional

enumerator CUSOLVERDX_OPERATOR_BATCHES_PER_BLOCK#: Operator data type: long long. Expected content: the number of independent problems solved by one block. Must be > 0. Block execution only; every device function pointer then addresses that many tightly packed problems (see the Batching section of the documentation for the strides). Operator definition: optional. Defaults to 1.

enumerator CUSOLVERDX_OPERATOR_JOB#: Operator data type: cusolverdxJob_t * 1 or 2. Expected content: <job> or <jobu, jobvt>. The two-value form specifies the left (jobu) and right (jobvt) singular vector jobs for CUSOLVERDX_FUNCTION_BDSVD and CUSOLVERDX_FUNCTION_GESVD ; the single-value form applies the same job to both. Operator definition: optional

enumerator CUSOLVERDX_OPERATOR_FUNCTION_ABI#: Operator data type: commondxFunctionAbi_t. Operator definition: optional. Defaults to COMMONDX_FUNCTION_ABI_NATIVE.

enumerator CUSOLVERDX_OPERATOR_EIG_TYPE#: Operator data type: long long int. Expected content: 1, 2 or 3, matching LAPACK’s itype argument Only used by CUSOLVERDX_FUNCTION_HEGST and CUSOLVERDX_FUNCTION_HEGV . Operator definition: optional. Defaults to 1.

enum cusolverdxTraitType_t#

Traits.

The set of supported types of traits that can be accessed from finalized sources that use cusolverdx.

Values:

enumerator CUSOLVERDX_TRAIT_SYMBOL_NAME#: Trait data type: C-string Value: symbol (device function) name.

enumerator CUSOLVERDX_TRAIT_BLOCK_DIM#: Trait data type: long long int * 3. Expected content: <x, y, z> block dimensions

enumerator CUSOLVERDX_TRAIT_SUGGESTED_BLOCK_DIM#: Trait data type: long long int * 3. Expected content: <x, y, z> suggested block dimension

enumerator CUSOLVERDX_TRAIT_SUGGESTED_BATCHES_PER_BLOCK#: Trait data type: long long int. Value: suggested batches per block

enumerator CUSOLVERDX_TRAIT_WORKSPACE_SIZE#: Trait data type: long long int. Value: workspace memory size, in number of elements.

commondxStatusType cusolverdxGetVersion( int *major, int *minor, int *patch, )#

Returns the major.minor.patch version of cuSolverDx.

Parameters:

major – [out] The major version
minor – [out] The minor version
patch – [out] The patch version

Returns:

COMMONDX_SUCCESS

commondxStatusType cusolverdxCreateDescriptor( cusolverdxDescriptor *handle, )#

Creates a cuSOLVERDx descriptor.

Parameters:: handle – [inout] A pointer to a descriptor handle. As output, an initialized cuSOLVERDx descriptor
Returns:: COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxSetOptionStr( cusolverdxDescriptor handle, commondxOption opt, const char *value, )#

Sets a C-string option on a cuSOLVERDx descriptor.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
opt – [in] The option to set
value – [in] The value for the option

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxSetOptionStrs(

cusolverdxDescriptor handle,

commondxOption opt,

size_t count,

const char **values,

)#

Sets one or more C-string option on a cuSOLVERDx descriptor.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor .
opt – [in] The option to set.
count – [in] The number of options.
values – [in] An array of count C-strings.

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxSetOperatorInt64( cusolverdxDescriptor handle, cusolverdxOperatorType op, long long int value, )#

Sets an integer operator on a cuSOLVERDx descriptor.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
op – [in] The operator to set.
value – [in] A value for the operator

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxSetOperatorInt64s( cusolverdxDescriptor handle, cusolverdxOperatorType op, size_t count, const long long int *array, )#

Sets a integer array operator on a cuSOLVERDx descriptor.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
op – [in] The operator to set
count – [in] The number of entries in the array value, as indicated in the cusolverdxOperatorType_t documentation.
array – [in] A pointer to at least count integers, the array operator to set

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxGetLTOIRSize( cusolverdxDescriptor handle, size_t *lto_size, )#

Extract the size of the LTOIR for a cuSOLVERDx descriptor.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
lto_size – [out] As output, the size of the LTOIR

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxGetLTOIR( cusolverdxDescriptor handle, size_t size, void *lto, )#

Extract the LTOIR from a cuSOLVERDx descriptor.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
size – [in] The LTOIR size, output of cusolverdxGetLTOIRSize
lto – [out] The buffer contains the LTOIR

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxGetUniversalFATBINSize( cusolverdxDescriptor handle, size_t *fatbin_size, )#

Returns the size of the universal fatbin for cuSOLVERDx.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
fatbin_size – [out] The size of the fatbin, in bytes

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxGetUniversalFATBIN( cusolverdxDescriptor handle, size_t fatbin_size, void *fatbin, )#

Returns a universal fatbin for cuSOLVERDx.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
fatbin_size – [in] The size of the fatbin, output from cusolverdxGetUniversalFATBINSize
fatbin – [out] The universal fatbin. Must pointer to at least fatbin_size bytes.

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxGetTraitStrSize( cusolverdxDescriptor handle, cusolverdxTraitType trait, size_t *size, )#

Returns the size of a C-string trait value.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
trait – [in] A trait to query the descriptor for
size – [out] The size of the C-string value for the trait (including the \0)

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxGetTraitStr( cusolverdxDescriptor handle, cusolverdxTraitType trait, size_t size, char *value, )#

Returns a C-string trait value.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
trait – [in] A trait to query the descriptor for
size – [in] The size of the C-string, output from cusolverdxGetTraitStrSize
value – [out] The C-string trait value

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxGetTraitInt64( cusolverdxDescriptor handle, cusolverdxTraitType trait, long long int *value, )#

Returns an integer trait value.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
trait – [in] A trait to query the descriptor for
value – [out] The trait value

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxGetTraitInt64s( cusolverdxDescriptor handle, cusolverdxTraitType trait, size_t count, long long int *values, )#

Returns an integer array trait value.

Parameters:

handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor .
trait – [in] A trait to query the descriptor for.
count – [in] The size of the array to retrieve.
values – [out] The trait values. Must point to an array of count values.

Returns:

COMMONDX_SUCCESS on success, or an error code.

const char *cusolverdxOperatorTypeToStr(cusolverdxOperatorType op)#

Converts an operator enum to a human readable C-string.

Parameters:: op – [in] An operator enum
Returns:: A human readable C-string

const char *cusolverdxTraitTypeToStr(cusolverdxTraitType trait)#

Converts a trait enum to a human readable C-string.

Parameters:: trait – [in] A trait enum
Returns:: A human readable C-string

commondxStatusType cusolverdxFinalizeCode( commondxCode code, cusolverdxDescriptor handle, )#

Fills a code handle with the descriptor’s device function code.

Parameters:

code – [out] A code handle
handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxFinalizeCodes( commondxCode code, size_t count, const cusolverdxDescriptor *handles, )#

Generate code from multiple cuSOLVERDx descriptors and store it in code.

Parameters:

code – [out] A commondxCode instance, output of commondxCreateCode.
count – [in] The number of descriptors.
handles – [in] An array of cuSOLVERDx descriptors.

Returns:

COMMONDX_SUCCESS on success, or an error code.

commondxStatusType cusolverdxDestroyDescriptor( cusolverdxDescriptor handle, )#

Destroys a cuSOLVERDx descriptor.

Parameters:: handle – [in] A cuSOLVERDx descriptor, output of cusolverdxCreateDescriptor
Returns:: COMMONDX_SUCCESS on success, or an error code.

const char *cusolverdxFunctionToStr(cusolverdxFunction function)#

Convert a function enum to a human readable C-string.

Parameters:: function – [in] The function enum to convert
Returns:: The C-string

const char *cusolverdxFillModeToStr(cusolverdxFillMode mode)#

Convert a fill mode enum to a human readable C-string.

Parameters:: mode – [in] The fill mode enum to convert
Returns:: The C-string

const char *cusolverdxApiToStr(cusolverdxApi api)#

Convert an api enum to a human readable C-string.

Parameters:: api – [in] The api enum to convert
Returns:: A human readable The C-string

const char *cusolverdxTypeToStr(cusolverdxType type)#

Convert a type enum to a human readable C-string.

Parameters:: type – [in] The type enum to convert
Returns:: The C-string

const char *cusolverdxArrangementToStr( cusolverdxArrangement arrangement, )#

Convert an arrangement enum to a human readable C-string.

Parameters:: arrangement – [in] The arrangement enum to convert
Returns:: The C-string

const char *cusolverdxDiagToStr(cusolverdxDiag diag)#

Convert a diag enum to a human readable C-string.

Parameters:: diag – [in] The diag enum to convert
Returns:: A human readable The C-string

const char *cusolverdxSideToStr(cusolverdxSide side)#

Convert a side enum to a human readable C-string.

Parameters:: side – [in] The side enum to convert
Returns:: A human readable The C-string

const char *cusolverdxTransposeModeToStr( cusolverdxTransposeMode transpose_mode, )#

Convert a transpose_mode enum to a human readable C-string.

Parameters:: transpose_mode – [in] The transpose_mode enum to convert
Returns:: The C-string

const char *cusolverdxJobToStr(cusolverdxJob job)#

Convert a job enum to a human readable C-string.

Parameters:: job – [in] The job enum to convert
Returns:: A human readable C-string