/*

* Copyright 2023-2025 NVIDIA Corporation. All rights reserved.

*

* NOTICE TO LICENSEE:

*

* This source code and/or documentation ("Licensed Deliverables") are

* subject to NVIDIA intellectual property rights under U.S. and

* international Copyright laws.

*

* These Licensed Deliverables contained herein is PROPRIETARY and

* CONFIDENTIAL to NVIDIA and is being provided under the terms and

* conditions of a form of NVIDIA software license agreement by and

* between NVIDIA and Licensee ("License Agreement") or electronically

* accepted by Licensee. Notwithstanding any terms or conditions to

* the contrary in the License Agreement, reproduction or disclosure

* of the Licensed Deliverables to any third party without the express

* written consent of NVIDIA is prohibited.

*

* NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE

* LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE

* SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE. IT IS

* PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.

* NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED

* DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,

* NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.

* NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE

* LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY

* SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY

* DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS

* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

* OF THESE LICENSED DELIVERABLES.

*

* U.S. Government End Users. These Licensed Deliverables are a

* "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT

* 1995), consisting of "commercial computer software" and "commercial

* computer software documentation" as such terms are used in 48

* C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government

* only as a commercial end item. Consistent with 48 C.F.R.12.212 and

* 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all

* U.S. Government End Users acquire the Licensed Deliverables with

* only those rights set forth herein.

*

* Any use of the Licensed Deliverables in individual and commercial

* software must include, in the user documentation and internal

* comments to the code, the above Disclaimer and U.S. Government End

* Users Notice.

*/

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <assert.h>

#include <cuda_runtime.h>

#include <cuComplex.h>

#include "cudss.h"

/*

This example demonstrates basic usage of cuDSS APIs for solving

a system of linear algebraic equations with a sparse matrix:

Ax = b,

where:

A is the sparse input matrix,

b is the (dense) right-hand side vector (or a matrix),

x is the (dense) solution vector (or a matrix).

*/

#define CUDSS_EXAMPLE_FREE \

do { \

free(csr_offsets_h); \

free(csr_columns_h); \

free(csr_values_h); \

free(x_values_h); \

free(b_values_h); \

cudaFree(csr_offsets_d); \

cudaFree(csr_columns_d); \

cudaFree(csr_values_d); \

cudaFree(x_values_d); \

cudaFree(b_values_d); \

} while(0);

#define CUDA_CALL_AND_CHECK(call, msg) \

do { \

cuda_error = call; \

if (cuda_error != cudaSuccess) { \

printf("Example FAILED: CUDA API returned error = %d, details: " #msg "\n", cuda_error); \

CUDSS_EXAMPLE_FREE; \

return -1; \

} \

} while(0);

#define CUDSS_CALL_AND_CHECK(call, status, msg) \

do { \

status = call; \

if (status != CUDSS_STATUS_SUCCESS) { \

printf("Example FAILED: CUDSS call ended unsuccessfully with status = %d, details: " #msg "\n", status); \

CUDSS_EXAMPLE_FREE; \

return -2; \

} \

} while(0);

int main (int argc, char *argv[]) {

printf("---------------------------------------------------------\n");

printf("cuDSS example: solving a complex linear 5x5 system\n"

"with a symmetric positive-definite matrix \n");

printf("---------------------------------------------------------\n");

cudaError_t cuda_error = cudaSuccess;

cudssStatus_t status = CUDSS_STATUS_SUCCESS;

int n = 5;

int nnz = 8;

int nrhs = 1;

int *csr_offsets_h = NULL;

int *csr_columns_h = NULL;

cuComplex *csr_values_h = NULL;

cuComplex *x_values_h = NULL, *b_values_h = NULL;

int *csr_offsets_d = NULL;

int *csr_columns_d = NULL;

cuComplex *csr_values_d = NULL;

cuComplex *x_values_d = NULL, *b_values_d = NULL;

/* Allocate host memory for the sparse input matrix A,

right-hand side x and solution b*/

csr_offsets_h = (int*)malloc((n + 1) * sizeof(int));

csr_columns_h = (int*)malloc(nnz * sizeof(int));

csr_values_h = (cuComplex*)malloc(nnz * sizeof(cuComplex));

x_values_h = (cuComplex*)malloc(nrhs * n * sizeof(cuComplex));

b_values_h = (cuComplex*)malloc(nrhs * n * sizeof(cuComplex));

if (!csr_offsets_h || ! csr_columns_h || !csr_values_h ||

!x_values_h || !b_values_h) {

printf("Error: host memory allocation failed\n");

return -1;

}

/* Initialize host memory for A and b */

int i = 0;

csr_offsets_h[i++] = 0;

csr_offsets_h[i++] = 2;

csr_offsets_h[i++] = 4;

csr_offsets_h[i++] = 6;

csr_offsets_h[i++] = 7;

csr_offsets_h[i++] = 8;

i = 0;

csr_columns_h[i++] = 0; csr_columns_h[i++] = 2;

csr_columns_h[i++] = 1; csr_columns_h[i++] = 2;

csr_columns_h[i++] = 2; csr_columns_h[i++] = 4;

csr_columns_h[i++] = 3;

csr_columns_h[i++] = 4;

i = 0;

csr_values_h[i++].x = 4.0; csr_values_h[i++].x = 1.0;

csr_values_h[i++].x = 3.0; csr_values_h[i++].x = 2.0;

csr_values_h[i++].x = 5.0; csr_values_h[i++].x = 1.0;

csr_values_h[i++].x = 1.0;

csr_values_h[i++].x = 2.0;

i = 0;

csr_values_h[i++].y = 0.0; csr_values_h[i++].y = 0.0;

csr_values_h[i++].y = 0.0; csr_values_h[i++].y = 0.0;

csr_values_h[i++].y = 0.0; csr_values_h[i++].y = 0.0;

csr_values_h[i++].y = 0.0;

csr_values_h[i++].y = 0.0;

/* Note: Right-hand side b is initialized with values which correspond

to the exact solution vector {1, 2, 3, 4, 5} */

i = 0;

b_values_h[i++].x = 7.0;

b_values_h[i++].x = 12.0;

b_values_h[i++].x = 25.0;

b_values_h[i++].x = 4.0;

b_values_h[i++].x = 13.0;

i = 0;

b_values_h[i++].y = 0.0;

b_values_h[i++].y = 0.0;

b_values_h[i++].y = 0.0;

b_values_h[i++].y = 0.0;

b_values_h[i++].y = 0.0;

/* Allocate device memory for A, x and b */

CUDA_CALL_AND_CHECK(cudaMalloc(&csr_offsets_d, (n + 1) * sizeof(int)),

"cudaMalloc for csr_offsets");

CUDA_CALL_AND_CHECK(cudaMalloc(&csr_columns_d, nnz * sizeof(int)),

"cudaMalloc for csr_columns");

CUDA_CALL_AND_CHECK(cudaMalloc(&csr_values_d, nnz * sizeof(cuComplex)),

"cudaMalloc for csr_values");

CUDA_CALL_AND_CHECK(cudaMalloc(&b_values_d, nrhs * n * sizeof(cuComplex)),

"cudaMalloc for b_values");

CUDA_CALL_AND_CHECK(cudaMalloc(&x_values_d, nrhs * n * sizeof(cuComplex)),

"cudaMalloc for x_values");

/* Copy host memory to device for A and b */

CUDA_CALL_AND_CHECK(cudaMemcpy(csr_offsets_d, csr_offsets_h, (n + 1) * sizeof(int),

cudaMemcpyHostToDevice), "cudaMemcpy for csr_offsets");

CUDA_CALL_AND_CHECK(cudaMemcpy(csr_columns_d, csr_columns_h, nnz * sizeof(int),

cudaMemcpyHostToDevice), "cudaMemcpy for csr_columns");

CUDA_CALL_AND_CHECK(cudaMemcpy(csr_values_d, csr_values_h, nnz * sizeof(cuComplex),

cudaMemcpyHostToDevice), "cudaMemcpy for csr_values");

CUDA_CALL_AND_CHECK(cudaMemcpy(b_values_d, b_values_h, nrhs * n * sizeof(cuComplex),

cudaMemcpyHostToDevice), "cudaMemcpy for b_values");

/* Create a CUDA stream */

cudaStream_t stream = NULL;

CUDA_CALL_AND_CHECK(cudaStreamCreate(&stream), "cudaStreamCreate");

/* Creating the cuDSS library handle */

cudssHandle_t handle;

CUDSS_CALL_AND_CHECK(cudssCreate(&handle), status, "cudssCreate");

/* (optional) Setting the custom stream for the library handle */

CUDSS_CALL_AND_CHECK(cudssSetStream(handle, stream), status, "cudssSetStream");

/* Creating cuDSS solver configuration and data objects */

cudssConfig_t solverConfig;

cudssData_t solverData;

CUDSS_CALL_AND_CHECK(cudssConfigCreate(&solverConfig), status, "cudssConfigCreate");

CUDSS_CALL_AND_CHECK(cudssDataCreate(handle, &solverData), status, "cudssDataCreate");

/* Create matrix objects for the right-hand side b and solution x (as dense matrices). */

cudssMatrix_t x, b;

int64_t nrows = n, ncols = n;

int ldb = ncols, ldx = nrows;

CUDSS_CALL_AND_CHECK(cudssMatrixCreateDn(&b, ncols, nrhs, ldb, b_values_d, CUDA_C_32F,

CUDSS_LAYOUT_COL_MAJOR), status, "cudssMatrixCreateDn for b");

CUDSS_CALL_AND_CHECK(cudssMatrixCreateDn(&x, nrows, nrhs, ldx, x_values_d, CUDA_C_32F,

CUDSS_LAYOUT_COL_MAJOR), status, "cudssMatrixCreateDn for x");

/* Create a matrix object for the sparse input matrix. */

cudssMatrix_t A;

cudssMatrixType_t mtype = CUDSS_MTYPE_SPD;

cudssMatrixViewType_t mview = CUDSS_MVIEW_UPPER;

cudssIndexBase_t base = CUDSS_BASE_ZERO;

CUDSS_CALL_AND_CHECK(cudssMatrixCreateCsr(&A, nrows, ncols, nnz, csr_offsets_d, NULL,

csr_columns_d, csr_values_d, CUDA_R_32I, CUDA_C_32F, mtype, mview,

base), status, "cudssMatrixCreateCsr");

/* Symbolic factorization */

CUDSS_CALL_AND_CHECK(cudssExecute(handle, CUDSS_PHASE_ANALYSIS, solverConfig, solverData,

A, x, b), status, "cudssExecute for analysis");

/* Factorization */

CUDSS_CALL_AND_CHECK(cudssExecute(handle, CUDSS_PHASE_FACTORIZATION, solverConfig,

solverData, A, x, b), status, "cudssExecute for factor");

/* Solving */

CUDSS_CALL_AND_CHECK(cudssExecute(handle, CUDSS_PHASE_SOLVE, solverConfig, solverData,

A, x, b), status, "cudssExecute for solve");

/* Destroying opaque objects, matrix wrappers and the cuDSS library handle */

CUDSS_CALL_AND_CHECK(cudssMatrixDestroy(A), status, "cudssMatrixDestroy for A");

CUDSS_CALL_AND_CHECK(cudssMatrixDestroy(b), status, "cudssMatrixDestroy for b");

CUDSS_CALL_AND_CHECK(cudssMatrixDestroy(x), status, "cudssMatrixDestroy for x");

CUDSS_CALL_AND_CHECK(cudssDataDestroy(handle, solverData), status, "cudssDataDestroy");

CUDSS_CALL_AND_CHECK(cudssConfigDestroy(solverConfig), status, "cudssConfigDestroy");

CUDSS_CALL_AND_CHECK(cudssDestroy(handle), status, "cudssHandleDestroy");

CUDA_CALL_AND_CHECK(cudaStreamSynchronize(stream), "cudaStreamSynchronize");

/* Print the solution and compare against the exact solution */

CUDA_CALL_AND_CHECK(cudaMemcpy(x_values_h, x_values_d, nrhs * n * sizeof(cuComplex),

cudaMemcpyDeviceToHost), "cudaMemcpy for x_values");

int passed = 1;

for (int i = 0; i < n; i++) {

printf("x[%d] = (%1.4f, %1.4f) expected (%1.4f, 0)\n", i,

x_values_h[i].x, x_values_h[i].y, double(i+1));

if (fabs(x_values_h[i].x - (i + 1)) + fabs(x_values_h[i].y) > 2.e-6)

passed = 0;

}

/* Release the data allocated on the user side */

CUDSS_EXAMPLE_FREE;

if (status == CUDSS_STATUS_SUCCESS && passed) {

printf("Example PASSED\n");

return 0;

} else {

printf("Example FAILED\n");

return -1;

}

}