/*
* Copyright 1993-2014 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.
*/
#if !defined(CUSOLVERRF_H_)
#define CUSOLVERRF_H_
#include "driver_types.h"
#include "cuComplex.h"
#include "cusolver_common.h"
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
/* CUSOLVERRF mode */
typedef enum {
CUSOLVERRF_RESET_VALUES_FAST_MODE_OFF = 0, // default
CUSOLVERRF_RESET_VALUES_FAST_MODE_ON = 1
} cusolverRfResetValuesFastMode_t;
/* CUSOLVERRF matrix format */
typedef enum {
CUSOLVERRF_MATRIX_FORMAT_CSR = 0, // default
CUSOLVERRF_MATRIX_FORMAT_CSC = 1
} cusolverRfMatrixFormat_t;
/* CUSOLVERRF unit diagonal */
typedef enum {
CUSOLVERRF_UNIT_DIAGONAL_STORED_L = 0, // default
CUSOLVERRF_UNIT_DIAGONAL_STORED_U = 1,
CUSOLVERRF_UNIT_DIAGONAL_ASSUMED_L = 2,
CUSOLVERRF_UNIT_DIAGONAL_ASSUMED_U = 3
} cusolverRfUnitDiagonal_t;
/* CUSOLVERRF factorization algorithm */
typedef enum {
CUSOLVERRF_FACTORIZATION_ALG0 = 0, // default
CUSOLVERRF_FACTORIZATION_ALG1 = 1,
CUSOLVERRF_FACTORIZATION_ALG2 = 2,
} cusolverRfFactorization_t;
/* CUSOLVERRF triangular solve algorithm */
typedef enum {
CUSOLVERRF_TRIANGULAR_SOLVE_ALG1 = 1, // default
CUSOLVERRF_TRIANGULAR_SOLVE_ALG2 = 2,
CUSOLVERRF_TRIANGULAR_SOLVE_ALG3 = 3
} cusolverRfTriangularSolve_t;
/* CUSOLVERRF numeric boost report */
typedef enum {
CUSOLVERRF_NUMERIC_BOOST_NOT_USED = 0, // default
CUSOLVERRF_NUMERIC_BOOST_USED = 1
} cusolverRfNumericBoostReport_t;
/* Opaque structure holding CUSOLVERRF library common */
struct cusolverRfCommon;
typedef struct cusolverRfCommon* cusolverRfHandle_t;
/* CUSOLVERRF create (allocate memory) and destroy (free memory) in the handle
*/
cusolverStatus_t CUSOLVERAPI cusolverRfCreate(cusolverRfHandle_t* handle);
cusolverStatus_t CUSOLVERAPI cusolverRfDestroy(cusolverRfHandle_t handle);
/* CUSOLVERRF set and get input format */
cusolverStatus_t CUSOLVERAPI cusolverRfGetMatrixFormat(
cusolverRfHandle_t handle,
cusolverRfMatrixFormat_t* format,
cusolverRfUnitDiagonal_t* diag);
cusolverStatus_t CUSOLVERAPI cusolverRfSetMatrixFormat(
cusolverRfHandle_t handle,
cusolverRfMatrixFormat_t format,
cusolverRfUnitDiagonal_t diag);
/* CUSOLVERRF set and get numeric properties */
cusolverStatus_t CUSOLVERAPI cusolverRfSetNumericProperties(
cusolverRfHandle_t handle,
double zero,
double boost);
cusolverStatus_t CUSOLVERAPI cusolverRfGetNumericProperties(
cusolverRfHandle_t handle,
double* zero,
double* boost);
cusolverStatus_t CUSOLVERAPI cusolverRfGetNumericBoostReport(
cusolverRfHandle_t handle,
cusolverRfNumericBoostReport_t* report);
/* CUSOLVERRF choose the triangular solve algorithm */
cusolverStatus_t CUSOLVERAPI cusolverRfSetAlgs(
cusolverRfHandle_t handle,
cusolverRfFactorization_t factAlg,
cusolverRfTriangularSolve_t solveAlg);
cusolverStatus_t CUSOLVERAPI cusolverRfGetAlgs(
cusolverRfHandle_t handle,
cusolverRfFactorization_t* factAlg,
cusolverRfTriangularSolve_t* solveAlg);
/* CUSOLVERRF set and get fast mode */
cusolverStatus_t CUSOLVERAPI cusolverRfGetResetValuesFastMode(
cusolverRfHandle_t handle,
cusolverRfResetValuesFastMode_t* fastMode);
cusolverStatus_t CUSOLVERAPI cusolverRfSetResetValuesFastMode(
cusolverRfHandle_t handle,
cusolverRfResetValuesFastMode_t fastMode);
/*** Non-Batched Routines ***/
/* CUSOLVERRF setup of internal structures from host or device memory */
cusolverStatus_t CUSOLVERAPI
cusolverRfSetupHost(/* Input (in the host memory) */
int n,
int nnzA,
int* h_csrRowPtrA,
int* h_csrColIndA,
double* h_csrValA,
int nnzL,
int* h_csrRowPtrL,
int* h_csrColIndL,
double* h_csrValL,
int nnzU,
int* h_csrRowPtrU,
int* h_csrColIndU,
double* h_csrValU,
int* h_P,
int* h_Q,
/* Output */
cusolverRfHandle_t handle);
cusolverStatus_t CUSOLVERAPI
cusolverRfSetupDevice(/* Input (in the device memory) */
int n,
int nnzA,
int* csrRowPtrA,
int* csrColIndA,
double* csrValA,
int nnzL,
int* csrRowPtrL,
int* csrColIndL,
double* csrValL,
int nnzU,
int* csrRowPtrU,
int* csrColIndU,
double* csrValU,
int* P,
int* Q,
/* Output */
cusolverRfHandle_t handle);
/* CUSOLVERRF update the matrix values (assuming the reordering, pivoting
and consequently the sparsity pattern of L and U did not change),
and zero out the remaining values. */
cusolverStatus_t CUSOLVERAPI
cusolverRfResetValues(/* Input (in the device memory) */
int n,
int nnzA,
int* csrRowPtrA,
int* csrColIndA,
double* csrValA,
int* P,
int* Q,
/* Output */
cusolverRfHandle_t handle);
/* CUSOLVERRF analysis (for parallelism) */
cusolverStatus_t CUSOLVERAPI cusolverRfAnalyze(cusolverRfHandle_t handle);
/* CUSOLVERRF re-factorization (for parallelism) */
cusolverStatus_t CUSOLVERAPI cusolverRfRefactor(cusolverRfHandle_t handle);
/* CUSOLVERRF extraction: Get L & U packed into a single matrix M */
cusolverStatus_t CUSOLVERAPI
cusolverRfAccessBundledFactorsDevice(/* Input */
cusolverRfHandle_t handle,
/* Output (in the host memory) */
int* nnzM,
/* Output (in the device memory) */
int** Mp,
int** Mi,
double** Mx);
cusolverStatus_t CUSOLVERAPI
cusolverRfExtractBundledFactorsHost(/* Input */
cusolverRfHandle_t handle,
/* Output (in the host memory) */
int* h_nnzM,
int** h_Mp,
int** h_Mi,
double** h_Mx);
/* CUSOLVERRF extraction: Get L & U individually */
cusolverStatus_t CUSOLVERAPI
cusolverRfExtractSplitFactorsHost(/* Input */
cusolverRfHandle_t handle,
/* Output (in the host memory) */
int* h_nnzL,
int** h_csrRowPtrL,
int** h_csrColIndL,
double** h_csrValL,
int* h_nnzU,
int** h_csrRowPtrU,
int** h_csrColIndU,
double** h_csrValU);
/* CUSOLVERRF (forward and backward triangular) solves */
cusolverStatus_t CUSOLVERAPI
cusolverRfSolve(/* Input (in the device memory) */
cusolverRfHandle_t handle,
int* P,
int* Q,
int nrhs, // only nrhs=1 is supported
double* Temp, // of size ldt*nrhs (ldt>=n)
int ldt,
/* Input/Output (in the device memory) */
double* XF,
/* Input */
int ldxf);
/*** Batched Routines ***/
/* CUSOLVERRF-batch setup of internal structures from host */
cusolverStatus_t CUSOLVERAPI
cusolverRfBatchSetupHost(/* Input (in the host memory)*/
int batchSize,
int n,
int nnzA,
int* h_csrRowPtrA,
int* h_csrColIndA,
double* h_csrValA_array[],
int nnzL,
int* h_csrRowPtrL,
int* h_csrColIndL,
double* h_csrValL,
int nnzU,
int* h_csrRowPtrU,
int* h_csrColIndU,
double* h_csrValU,
int* h_P,
int* h_Q,
/* Output (in the device memory) */
cusolverRfHandle_t handle);
/* CUSOLVERRF-batch update the matrix values (assuming the reordering,
pivoting and consequently the sparsity pattern of L and U did not change),
and zero out the remaining values. */
cusolverStatus_t CUSOLVERAPI
cusolverRfBatchResetValues(/* Input (in the device memory) */
int batchSize,
int n,
int nnzA,
int* csrRowPtrA,
int* csrColIndA,
double* csrValA_array[],
int* P,
int* Q,
/* Output */
cusolverRfHandle_t handle);
/* CUSOLVERRF-batch analysis (for parallelism) */
cusolverStatus_t CUSOLVERAPI
cusolverRfBatchAnalyze(cusolverRfHandle_t handle);
/* CUSOLVERRF-batch re-factorization (for parallelism) */
cusolverStatus_t CUSOLVERAPI
cusolverRfBatchRefactor(cusolverRfHandle_t handle);
/* CUSOLVERRF-batch (forward and backward triangular) solves */
cusolverStatus_t CUSOLVERAPI
cusolverRfBatchSolve(/* Input (in the device memory) */
cusolverRfHandle_t handle,
int* P,
int* Q,
int nrhs, // only nrhs=1 is supported
double* Temp, // of size 2*batchSize*(n*nrhs)
int ldt, // only ldt=n is supported
/* Input/Output (in the device memory) */
double* XF_array[],
/* Input */
int ldxf);
/* CUSOLVERRF-batch obtain the position of zero pivot */
cusolverStatus_t CUSOLVERAPI
cusolverRfBatchZeroPivot(/* Input */
cusolverRfHandle_t handle,
/* Output (in the host memory) */
int* position);
#if defined(__cplusplus)
}
#endif /* __cplusplus */
#endif /* CUSOLVERRF_H_ */