mirror of
https://github.com/NVIDIA/cuda-samples.git
synced 2026-10-25 22:28:17 +08:00
CUDA 13.2 samples update (#432)
- Added Python samples for CUDA Python 1.0 release - Renamed top-level `Samples` directory to `cpp` to accommodate Python samples.
This commit is contained in:
Dheemanth
GitHub
18
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/.vscode/c_cpp_properties.json
vendored
Normal file
18
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/.vscode/c_cpp_properties.json
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Linux",
|
||||
"includePath": [
|
||||
"${workspaceFolder}/**",
|
||||
"${workspaceFolder}/../../../Common"
|
||||
],
|
||||
"defines": [],
|
||||
"compilerPath": "/usr/local/cuda/bin/nvcc",
|
||||
"cStandard": "gnu17",
|
||||
"cppStandard": "gnu++14",
|
||||
"intelliSenseMode": "linux-gcc-x64",
|
||||
"configurationProvider": "ms-vscode.makefile-tools"
|
||||
}
|
||||
],
|
||||
"version": 4
|
||||
}
|
||||
7
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/.vscode/extensions.json
vendored
Normal file
7
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/.vscode/extensions.json
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"recommendations": [
|
||||
"nvidia.nsight-vscode-edition",
|
||||
"ms-vscode.cpptools",
|
||||
"ms-vscode.makefile-tools"
|
||||
]
|
||||
}
|
||||
58
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/CMakeLists.txt
Normal file
58
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/CMakeLists.txt
Normal file
@@ -0,0 +1,58 @@
|
||||
cmake_minimum_required(VERSION 3.20)
|
||||
|
||||
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
|
||||
|
||||
project(cuSolverSp_LinearSolver LANGUAGES C CXX)
|
||||
|
||||
find_package(CUDAToolkit REQUIRED)
|
||||
|
||||
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
|
||||
|
||||
set(CMAKE_CUDA_ARCHITECTURES 75 80 86 87 89 90 100 110 120)
|
||||
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
|
||||
if(ENABLE_CUDA_DEBUG)
|
||||
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (may significantly affect performance on some targets)
|
||||
else()
|
||||
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -lineinfo") # add line information to all builds for debug tools (exclusive to -G option)
|
||||
endif()
|
||||
|
||||
# Include directories and libraries
|
||||
include_directories(../../../Common)
|
||||
|
||||
# Source file
|
||||
# Add target for cuSolverSp_LinearSolver
|
||||
add_executable(cuSolverSp_LinearSolver cuSolverSp_LinearSolver.cpp mmio.c mmio_wrapper.cpp)
|
||||
|
||||
target_compile_options(cuSolverSp_LinearSolver PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
|
||||
|
||||
target_compile_features(cuSolverSp_LinearSolver PRIVATE cxx_std_17 cuda_std_17)
|
||||
|
||||
set_target_properties(cuSolverSp_LinearSolver PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
|
||||
|
||||
target_include_directories(cuSolverSp_LinearSolver PRIVATE
|
||||
${CUDAToolkit_INCLUDE_DIRS}
|
||||
)
|
||||
|
||||
target_link_libraries(cuSolverSp_LinearSolver PRIVATE
|
||||
CUDA::cudart
|
||||
CUDA::cublas
|
||||
CUDA::cusolver
|
||||
)
|
||||
|
||||
# Copy data files to output directory
|
||||
add_custom_command(TARGET cuSolverSp_LinearSolver POST_BUILD
|
||||
COMMAND ${CMAKE_COMMAND} -E copy_if_different
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/lap2D_5pt_n100.mtx
|
||||
${CMAKE_CURRENT_BINARY_DIR}
|
||||
)
|
||||
|
||||
# Copy data files to output directory
|
||||
add_custom_command(TARGET cuSolverSp_LinearSolver POST_BUILD
|
||||
COMMAND ${CMAKE_COMMAND} -E copy_if_different
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/lap3D_7pt_n20.mtx
|
||||
${CMAKE_CURRENT_BINARY_DIR}
|
||||
)
|
||||
|
||||
# Include installation configuration
|
||||
include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
|
||||
setup_samples_install()
|
||||
39
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/README.md
Normal file
39
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/README.md
Normal file
@@ -0,0 +1,39 @@
|
||||
# cuSolverSp_LinearSolver - cuSolverSp Linear Solver
|
||||
|
||||
## Description
|
||||
|
||||
A CUDA Sample that demonstrates cuSolverSP's LU, QR and Cholesky factorization.
|
||||
|
||||
## Key Concepts
|
||||
|
||||
Linear Algebra, CUSOLVER Library
|
||||
|
||||
## Supported SM Architectures
|
||||
|
||||
[SM 5.0 ](https://developer.nvidia.com/cuda-gpus) [SM 5.2 ](https://developer.nvidia.com/cuda-gpus) [SM 5.3 ](https://developer.nvidia.com/cuda-gpus) [SM 6.0 ](https://developer.nvidia.com/cuda-gpus) [SM 6.1 ](https://developer.nvidia.com/cuda-gpus) [SM 7.0 ](https://developer.nvidia.com/cuda-gpus) [SM 7.2 ](https://developer.nvidia.com/cuda-gpus) [SM 7.5 ](https://developer.nvidia.com/cuda-gpus) [SM 8.0 ](https://developer.nvidia.com/cuda-gpus) [SM 8.6 ](https://developer.nvidia.com/cuda-gpus) [SM 8.7 ](https://developer.nvidia.com/cuda-gpus) [SM 8.9 ](https://developer.nvidia.com/cuda-gpus) [SM 9.0 ](https://developer.nvidia.com/cuda-gpus)
|
||||
|
||||
## Supported OSes
|
||||
|
||||
Linux, Windows
|
||||
|
||||
## Supported CPU Architecture
|
||||
|
||||
x86_64, armv7l
|
||||
|
||||
## CUDA APIs involved
|
||||
|
||||
### [CUDA Driver API](http://docs.nvidia.com/cuda/cuda-driver-api/index.html)
|
||||
cuDoubleComplex, cuComplex
|
||||
|
||||
### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
|
||||
cudaStreamDestroy, cudaFree, cudaDeviceSynchronize, cudaMalloc, cudaStreamCreate, cudaMemcpyAsync
|
||||
|
||||
## Dependencies needed to build/run
|
||||
[CUSOLVER](../../../README.md#cusolver), [CUSPARSE](../../../README.md#cusparse)
|
||||
|
||||
## Prerequisites
|
||||
|
||||
Download and install the [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
|
||||
Make sure the dependencies mentioned in [Dependencies]() section above are installed.
|
||||
|
||||
## References (for more details)
|
||||
@@ -0,0 +1,738 @@
|
||||
/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Test three linear solvers, including Cholesky, LU and QR.
|
||||
* The user has to prepare a sparse matrix of "matrix market format" (with
|
||||
extension .mtx).
|
||||
* For example, the user can download matrices in Florida Sparse Matrix
|
||||
Collection.
|
||||
* (http://www.cise.ufl.edu/research/sparse/matrices/)
|
||||
*
|
||||
* The user needs to choose a solver by the switch -R<solver> and
|
||||
* to provide the path of the matrix by the switch -F<file>, then
|
||||
* the program solves
|
||||
* A*x = b
|
||||
* and reports relative error
|
||||
* |b-A*x|/(|A|*|x|+|b|)
|
||||
*
|
||||
* How does it work?
|
||||
* The example solves A*x = b by the following steps
|
||||
* step 1: B = A(Q,Q)
|
||||
* Q is the ordering to minimize zero fill-in.
|
||||
* The user can choose symrcm or symamd.
|
||||
* step 2: solve B*z = Q*b
|
||||
* step 3: x = inv(Q)*z
|
||||
*
|
||||
* Above three steps can be combined by the formula
|
||||
* (Q*A*Q')*(Q*x) = (Q*b)
|
||||
*
|
||||
* The elapsed time is also reported so the user can compare efficiency of
|
||||
different solvers.
|
||||
*
|
||||
* How to use
|
||||
/cuSolverSp_LinearSolver // Default: Cholesky, symrcm &
|
||||
file=lap2D_5pt_n100.mtx
|
||||
* ./cuSolverSp_LinearSolver -R=chol -file=<file> // cholesky
|
||||
factorization
|
||||
* ./cuSolverSp_LinearSolver -R=lu -P=symrcm -file=<file> // symrcm + LU
|
||||
with partial pivoting
|
||||
* ./cuSolverSp_LinearSolver -R=qr -P=symamd -file=<file> // symamd + QR
|
||||
factorization
|
||||
*
|
||||
*
|
||||
* Remark: the absolute error on solution x is meaningless without knowing
|
||||
condition number of A.
|
||||
* The relative error on residual should be close to machine zero,
|
||||
i.e. 1.e-15.
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
#include <cuda_runtime.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "cusolverSp.h"
|
||||
#include "cusparse.h"
|
||||
#include "helper_cuda.h"
|
||||
#include "helper_cusolver.h"
|
||||
|
||||
template <typename T_ELEM>
|
||||
int loadMMSparseMatrix(char *filename,
|
||||
char elem_type,
|
||||
bool csrFormat,
|
||||
int *m,
|
||||
int *n,
|
||||
int *nnz,
|
||||
T_ELEM **aVal,
|
||||
int **aRowInd,
|
||||
int **aColInd,
|
||||
int extendSymMatrix);
|
||||
|
||||
void UsageSP(void)
|
||||
{
|
||||
printf("<options>\n");
|
||||
printf("-h : display this help\n");
|
||||
printf("-R=<name> : choose a linear solver\n");
|
||||
printf(" chol (cholesky factorization), this is default\n");
|
||||
printf(" qr (QR factorization)\n");
|
||||
printf(" lu (LU factorization)\n");
|
||||
printf("-P=<name> : choose a reordering\n");
|
||||
printf(" symrcm (Reverse Cuthill-McKee)\n");
|
||||
printf(" symamd (Approximate Minimum Degree)\n");
|
||||
printf(" metis (nested dissection)\n");
|
||||
printf("-file=<filename> : filename containing a matrix in MM format\n");
|
||||
printf("-device=<device_id> : <device_id> if want to run on specific GPU\n");
|
||||
|
||||
exit(0);
|
||||
}
|
||||
|
||||
void parseCommandLineArguments(int argc, char *argv[], struct testOpts &opts)
|
||||
{
|
||||
memset(&opts, 0, sizeof(opts));
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "-h")) {
|
||||
UsageSP();
|
||||
}
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "R")) {
|
||||
char *solverType = NULL;
|
||||
getCmdLineArgumentString(argc, (const char **)argv, "R", &solverType);
|
||||
|
||||
if (solverType) {
|
||||
if ((STRCASECMP(solverType, "chol") != 0) && (STRCASECMP(solverType, "lu") != 0)
|
||||
&& (STRCASECMP(solverType, "qr") != 0)) {
|
||||
printf("\nIncorrect argument passed to -R option\n");
|
||||
UsageSP();
|
||||
}
|
||||
else {
|
||||
opts.testFunc = solverType;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "P")) {
|
||||
char *reorderType = NULL;
|
||||
getCmdLineArgumentString(argc, (const char **)argv, "P", &reorderType);
|
||||
|
||||
if (reorderType) {
|
||||
if ((STRCASECMP(reorderType, "symrcm") != 0) && (STRCASECMP(reorderType, "symamd") != 0)
|
||||
&& (STRCASECMP(reorderType, "metis") != 0)) {
|
||||
printf("\nIncorrect argument passed to -P option\n");
|
||||
UsageSP();
|
||||
}
|
||||
else {
|
||||
opts.reorder = reorderType;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "file")) {
|
||||
char *fileName = 0;
|
||||
getCmdLineArgumentString(argc, (const char **)argv, "file", &fileName);
|
||||
|
||||
if (fileName) {
|
||||
opts.sparse_mat_filename = fileName;
|
||||
}
|
||||
else {
|
||||
printf("\nIncorrect filename passed to -file \n ");
|
||||
UsageSP();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
struct testOpts opts;
|
||||
cusolverSpHandle_t handle = NULL;
|
||||
cusparseHandle_t cusparseHandle = NULL; /* used in residual evaluation */
|
||||
cudaStream_t stream = NULL;
|
||||
cusparseMatDescr_t descrA = NULL;
|
||||
|
||||
int rowsA = 0; /* number of rows of A */
|
||||
int colsA = 0; /* number of columns of A */
|
||||
int nnzA = 0; /* number of nonzeros of A */
|
||||
int baseA = 0; /* base index in CSR format */
|
||||
|
||||
/* CSR(A) from I/O */
|
||||
int *h_csrRowPtrA = NULL;
|
||||
int *h_csrColIndA = NULL;
|
||||
double *h_csrValA = NULL;
|
||||
|
||||
double *h_z = NULL; /* z = B \ (Q*b) */
|
||||
double *h_x = NULL; /* x = A \ b */
|
||||
double *h_b = NULL; /* b = ones(n,1) */
|
||||
double *h_Qb = NULL; /* Q*b */
|
||||
double *h_r = NULL; /* r = b - A*x */
|
||||
|
||||
int *h_Q = NULL; /* <int> n */
|
||||
/* reorder to reduce zero fill-in */
|
||||
/* Q = symrcm(A) or Q = symamd(A) */
|
||||
/* B = Q*A*Q' or B = A(Q,Q) by MATLAB notation */
|
||||
int *h_csrRowPtrB = NULL; /* <int> n+1 */
|
||||
int *h_csrColIndB = NULL; /* <int> nnzA */
|
||||
double *h_csrValB = NULL; /* <double> nnzA */
|
||||
int *h_mapBfromA = NULL; /* <int> nnzA */
|
||||
|
||||
size_t size_perm = 0;
|
||||
void *buffer_cpu = NULL; /* working space for permutation: B = Q*A*Q^T */
|
||||
|
||||
/* device copy of A: used in residual evaluation */
|
||||
int *d_csrRowPtrA = NULL;
|
||||
int *d_csrColIndA = NULL;
|
||||
double *d_csrValA = NULL;
|
||||
|
||||
/* device copy of B: used in B*z = Q*b */
|
||||
int *d_csrRowPtrB = NULL;
|
||||
int *d_csrColIndB = NULL;
|
||||
double *d_csrValB = NULL;
|
||||
|
||||
int *d_Q = NULL; /* device copy of h_Q */
|
||||
double *d_z = NULL; /* z = B \ Q*b */
|
||||
double *d_x = NULL; /* x = A \ b */
|
||||
double *d_b = NULL; /* a copy of h_b */
|
||||
double *d_Qb = NULL; /* a copy of h_Qb */
|
||||
double *d_r = NULL; /* r = b - A*x */
|
||||
|
||||
double tol = 1.e-12;
|
||||
const int reorder = 0; /* no reordering */
|
||||
int singularity = 0; /* -1 if A is invertible under tol. */
|
||||
|
||||
/* the constants are used in residual evaluation, r = b - A*x */
|
||||
const double minus_one = -1.0;
|
||||
const double one = 1.0;
|
||||
|
||||
double b_inf = 0.0;
|
||||
double x_inf = 0.0;
|
||||
double r_inf = 0.0;
|
||||
double A_inf = 0.0;
|
||||
int errors = 0;
|
||||
int issym = 0;
|
||||
|
||||
double start, stop;
|
||||
double time_solve_cpu;
|
||||
double time_solve_gpu;
|
||||
|
||||
parseCommandLineArguments(argc, argv, opts);
|
||||
|
||||
if (NULL == opts.testFunc) {
|
||||
opts.testFunc = "chol"; /* By default running Cholesky as NO solver selected with -R
|
||||
option. */
|
||||
}
|
||||
|
||||
findCudaDevice(argc, (const char **)argv);
|
||||
|
||||
if (opts.sparse_mat_filename == NULL) {
|
||||
opts.sparse_mat_filename = sdkFindFilePath("lap2D_5pt_n100.mtx", argv[0]);
|
||||
if (opts.sparse_mat_filename != NULL)
|
||||
printf("Using default input file [%s]\n", opts.sparse_mat_filename);
|
||||
else
|
||||
printf("Could not find lap2D_5pt_n100.mtx\n");
|
||||
}
|
||||
else {
|
||||
printf("Using input file [%s]\n", opts.sparse_mat_filename);
|
||||
}
|
||||
|
||||
printf("step 1: read matrix market format\n");
|
||||
|
||||
if (opts.sparse_mat_filename == NULL) {
|
||||
fprintf(stderr, "Error: input matrix is not provided\n");
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
if (loadMMSparseMatrix<double>(opts.sparse_mat_filename,
|
||||
'd',
|
||||
true,
|
||||
&rowsA,
|
||||
&colsA,
|
||||
&nnzA,
|
||||
&h_csrValA,
|
||||
&h_csrRowPtrA,
|
||||
&h_csrColIndA,
|
||||
true)) {
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
baseA = h_csrRowPtrA[0]; // baseA = {0,1}
|
||||
printf("sparse matrix A is %d x %d with %d nonzeros, base=%d\n", rowsA, colsA, nnzA, baseA);
|
||||
|
||||
if (rowsA != colsA) {
|
||||
fprintf(stderr, "Error: only support square matrix\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
checkCudaErrors(cusolverSpCreate(&handle));
|
||||
checkCudaErrors(cusparseCreate(&cusparseHandle));
|
||||
|
||||
checkCudaErrors(cudaStreamCreate(&stream));
|
||||
/* bind stream to cusparse and cusolver*/
|
||||
checkCudaErrors(cusolverSpSetStream(handle, stream));
|
||||
checkCudaErrors(cusparseSetStream(cusparseHandle, stream));
|
||||
|
||||
/* configure matrix descriptor*/
|
||||
checkCudaErrors(cusparseCreateMatDescr(&descrA));
|
||||
checkCudaErrors(cusparseSetMatType(descrA, CUSPARSE_MATRIX_TYPE_GENERAL));
|
||||
if (baseA) {
|
||||
checkCudaErrors(cusparseSetMatIndexBase(descrA, CUSPARSE_INDEX_BASE_ONE));
|
||||
}
|
||||
else {
|
||||
checkCudaErrors(cusparseSetMatIndexBase(descrA, CUSPARSE_INDEX_BASE_ZERO));
|
||||
}
|
||||
|
||||
h_z = (double *)malloc(sizeof(double) * colsA);
|
||||
h_x = (double *)malloc(sizeof(double) * colsA);
|
||||
h_b = (double *)malloc(sizeof(double) * rowsA);
|
||||
h_Qb = (double *)malloc(sizeof(double) * rowsA);
|
||||
h_r = (double *)malloc(sizeof(double) * rowsA);
|
||||
|
||||
h_Q = (int *)malloc(sizeof(int) * colsA);
|
||||
h_csrRowPtrB = (int *)malloc(sizeof(int) * (rowsA + 1));
|
||||
h_csrColIndB = (int *)malloc(sizeof(int) * nnzA);
|
||||
h_csrValB = (double *)malloc(sizeof(double) * nnzA);
|
||||
h_mapBfromA = (int *)malloc(sizeof(int) * nnzA);
|
||||
|
||||
assert(NULL != h_z);
|
||||
assert(NULL != h_x);
|
||||
assert(NULL != h_b);
|
||||
assert(NULL != h_Qb);
|
||||
assert(NULL != h_r);
|
||||
assert(NULL != h_Q);
|
||||
assert(NULL != h_csrRowPtrB);
|
||||
assert(NULL != h_csrColIndB);
|
||||
assert(NULL != h_csrValB);
|
||||
assert(NULL != h_mapBfromA);
|
||||
|
||||
checkCudaErrors(cudaMalloc((void **)&d_csrRowPtrA, sizeof(int) * (rowsA + 1)));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_csrColIndA, sizeof(int) * nnzA));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_csrValA, sizeof(double) * nnzA));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_csrRowPtrB, sizeof(int) * (rowsA + 1)));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_csrColIndB, sizeof(int) * nnzA));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_csrValB, sizeof(double) * nnzA));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_Q, sizeof(int) * colsA));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_z, sizeof(double) * colsA));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_x, sizeof(double) * colsA));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_b, sizeof(double) * rowsA));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_Qb, sizeof(double) * rowsA));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_r, sizeof(double) * rowsA));
|
||||
|
||||
/* verify if A has symmetric pattern or not */
|
||||
checkCudaErrors(
|
||||
cusolverSpXcsrissymHost(handle, rowsA, nnzA, descrA, h_csrRowPtrA, h_csrRowPtrA + 1, h_csrColIndA, &issym));
|
||||
|
||||
if (0 == strcmp(opts.testFunc, "chol")) {
|
||||
if (!issym) {
|
||||
printf("Error: A has no symmetric pattern, please use LU or QR \n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
|
||||
printf("step 2: reorder the matrix A to minimize zero fill-in\n");
|
||||
printf(" if the user choose a reordering by -P=symrcm, -P=symamd or "
|
||||
"-P=metis\n");
|
||||
|
||||
if (NULL != opts.reorder) {
|
||||
if (0 == strcmp(opts.reorder, "symrcm")) {
|
||||
printf("step 2.1: Q = symrcm(A) \n");
|
||||
checkCudaErrors(cusolverSpXcsrsymrcmHost(handle, rowsA, nnzA, descrA, h_csrRowPtrA, h_csrColIndA, h_Q));
|
||||
}
|
||||
else if (0 == strcmp(opts.reorder, "symamd")) {
|
||||
printf("step 2.1: Q = symamd(A) \n");
|
||||
checkCudaErrors(cusolverSpXcsrsymamdHost(handle, rowsA, nnzA, descrA, h_csrRowPtrA, h_csrColIndA, h_Q));
|
||||
}
|
||||
else if (0 == strcmp(opts.reorder, "metis")) {
|
||||
printf("step 2.1: Q = metis(A) \n");
|
||||
checkCudaErrors(cusolverSpXcsrmetisndHost(handle,
|
||||
rowsA,
|
||||
nnzA,
|
||||
descrA,
|
||||
h_csrRowPtrA,
|
||||
h_csrColIndA,
|
||||
NULL, /* default setting. */
|
||||
h_Q));
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "Error: %s is unknown reordering\n", opts.reorder);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
printf("step 2.1: no reordering is chosen, Q = 0:n-1 \n");
|
||||
for (int j = 0; j < rowsA; j++) {
|
||||
h_Q[j] = j;
|
||||
}
|
||||
}
|
||||
|
||||
printf("step 2.2: B = A(Q,Q) \n");
|
||||
|
||||
memcpy(h_csrRowPtrB, h_csrRowPtrA, sizeof(int) * (rowsA + 1));
|
||||
memcpy(h_csrColIndB, h_csrColIndA, sizeof(int) * nnzA);
|
||||
|
||||
checkCudaErrors(cusolverSpXcsrperm_bufferSizeHost(
|
||||
handle, rowsA, colsA, nnzA, descrA, h_csrRowPtrB, h_csrColIndB, h_Q, h_Q, &size_perm));
|
||||
|
||||
if (buffer_cpu) {
|
||||
free(buffer_cpu);
|
||||
}
|
||||
buffer_cpu = (void *)malloc(sizeof(char) * size_perm);
|
||||
assert(NULL != buffer_cpu);
|
||||
|
||||
/* h_mapBfromA = Identity */
|
||||
for (int j = 0; j < nnzA; j++) {
|
||||
h_mapBfromA[j] = j;
|
||||
}
|
||||
checkCudaErrors(cusolverSpXcsrpermHost(
|
||||
handle, rowsA, colsA, nnzA, descrA, h_csrRowPtrB, h_csrColIndB, h_Q, h_Q, h_mapBfromA, buffer_cpu));
|
||||
|
||||
/* B = A( mapBfromA ) */
|
||||
for (int j = 0; j < nnzA; j++) {
|
||||
h_csrValB[j] = h_csrValA[h_mapBfromA[j]];
|
||||
}
|
||||
|
||||
printf("step 3: b(j) = 1 + j/n \n");
|
||||
for (int row = 0; row < rowsA; row++) {
|
||||
h_b[row] = 1.0 + ((double)row) / ((double)rowsA);
|
||||
}
|
||||
|
||||
/* h_Qb = b(Q) */
|
||||
for (int row = 0; row < rowsA; row++) {
|
||||
h_Qb[row] = h_b[h_Q[row]];
|
||||
}
|
||||
|
||||
printf("step 4: prepare data on device\n");
|
||||
checkCudaErrors(
|
||||
cudaMemcpyAsync(d_csrRowPtrA, h_csrRowPtrA, sizeof(int) * (rowsA + 1), cudaMemcpyHostToDevice, stream));
|
||||
checkCudaErrors(cudaMemcpyAsync(d_csrColIndA, h_csrColIndA, sizeof(int) * nnzA, cudaMemcpyHostToDevice, stream));
|
||||
checkCudaErrors(cudaMemcpyAsync(d_csrValA, h_csrValA, sizeof(double) * nnzA, cudaMemcpyHostToDevice, stream));
|
||||
checkCudaErrors(
|
||||
cudaMemcpyAsync(d_csrRowPtrB, h_csrRowPtrB, sizeof(int) * (rowsA + 1), cudaMemcpyHostToDevice, stream));
|
||||
checkCudaErrors(cudaMemcpyAsync(d_csrColIndB, h_csrColIndB, sizeof(int) * nnzA, cudaMemcpyHostToDevice, stream));
|
||||
checkCudaErrors(cudaMemcpyAsync(d_csrValB, h_csrValB, sizeof(double) * nnzA, cudaMemcpyHostToDevice, stream));
|
||||
checkCudaErrors(cudaMemcpyAsync(d_b, h_b, sizeof(double) * rowsA, cudaMemcpyHostToDevice, stream));
|
||||
checkCudaErrors(cudaMemcpyAsync(d_Qb, h_Qb, sizeof(double) * rowsA, cudaMemcpyHostToDevice, stream));
|
||||
checkCudaErrors(cudaMemcpyAsync(d_Q, h_Q, sizeof(int) * rowsA, cudaMemcpyHostToDevice, stream));
|
||||
|
||||
printf("step 5: solve A*x = b on CPU \n");
|
||||
start = second();
|
||||
|
||||
/* solve B*z = Q*b */
|
||||
if (0 == strcmp(opts.testFunc, "chol")) {
|
||||
checkCudaErrors(cusolverSpDcsrlsvcholHost(
|
||||
handle, rowsA, nnzA, descrA, h_csrValB, h_csrRowPtrB, h_csrColIndB, h_Qb, tol, reorder, h_z, &singularity));
|
||||
}
|
||||
else if (0 == strcmp(opts.testFunc, "lu")) {
|
||||
checkCudaErrors(cusolverSpDcsrlsvluHost(
|
||||
handle, rowsA, nnzA, descrA, h_csrValB, h_csrRowPtrB, h_csrColIndB, h_Qb, tol, reorder, h_z, &singularity));
|
||||
}
|
||||
else if (0 == strcmp(opts.testFunc, "qr")) {
|
||||
checkCudaErrors(cusolverSpDcsrlsvqrHost(
|
||||
handle, rowsA, nnzA, descrA, h_csrValB, h_csrRowPtrB, h_csrColIndB, h_Qb, tol, reorder, h_z, &singularity));
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "Error: %s is unknown function\n", opts.testFunc);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Q*x = z */
|
||||
for (int row = 0; row < rowsA; row++) {
|
||||
h_x[h_Q[row]] = h_z[row];
|
||||
}
|
||||
|
||||
if (0 <= singularity) {
|
||||
printf("WARNING: the matrix is singular at row %d under tol (%E)\n", singularity, tol);
|
||||
}
|
||||
|
||||
stop = second();
|
||||
time_solve_cpu = stop - start;
|
||||
|
||||
printf("step 6: evaluate residual r = b - A*x (result on CPU)\n");
|
||||
checkCudaErrors(cudaMemcpyAsync(d_r, d_b, sizeof(double) * rowsA, cudaMemcpyDeviceToDevice, stream));
|
||||
checkCudaErrors(cudaMemcpyAsync(d_x, h_x, sizeof(double) * colsA, cudaMemcpyHostToDevice, stream));
|
||||
|
||||
/* Wrap raw data into cuSPARSE generic API objects */
|
||||
cusparseSpMatDescr_t matA = NULL;
|
||||
if (baseA) {
|
||||
checkCudaErrors(cusparseCreateCsr(&matA,
|
||||
rowsA,
|
||||
colsA,
|
||||
nnzA,
|
||||
d_csrRowPtrA,
|
||||
d_csrColIndA,
|
||||
d_csrValA,
|
||||
CUSPARSE_INDEX_32I,
|
||||
CUSPARSE_INDEX_32I,
|
||||
CUSPARSE_INDEX_BASE_ONE,
|
||||
CUDA_R_64F));
|
||||
}
|
||||
else {
|
||||
checkCudaErrors(cusparseCreateCsr(&matA,
|
||||
rowsA,
|
||||
colsA,
|
||||
nnzA,
|
||||
d_csrRowPtrA,
|
||||
d_csrColIndA,
|
||||
d_csrValA,
|
||||
CUSPARSE_INDEX_32I,
|
||||
CUSPARSE_INDEX_32I,
|
||||
CUSPARSE_INDEX_BASE_ZERO,
|
||||
CUDA_R_64F));
|
||||
}
|
||||
|
||||
cusparseDnVecDescr_t vecx = NULL;
|
||||
checkCudaErrors(cusparseCreateDnVec(&vecx, colsA, d_x, CUDA_R_64F));
|
||||
cusparseDnVecDescr_t vecAx = NULL;
|
||||
checkCudaErrors(cusparseCreateDnVec(&vecAx, rowsA, d_r, CUDA_R_64F));
|
||||
|
||||
/* Allocate workspace for cuSPARSE */
|
||||
size_t bufferSize = 0;
|
||||
checkCudaErrors(cusparseSpMV_bufferSize(cusparseHandle,
|
||||
CUSPARSE_OPERATION_NON_TRANSPOSE,
|
||||
&minus_one,
|
||||
matA,
|
||||
vecx,
|
||||
&one,
|
||||
vecAx,
|
||||
CUDA_R_64F,
|
||||
CUSPARSE_SPMV_ALG_DEFAULT,
|
||||
&bufferSize));
|
||||
void *buffer = NULL;
|
||||
checkCudaErrors(cudaMalloc(&buffer, bufferSize));
|
||||
|
||||
checkCudaErrors(cusparseSpMV(cusparseHandle,
|
||||
CUSPARSE_OPERATION_NON_TRANSPOSE,
|
||||
&minus_one,
|
||||
matA,
|
||||
vecx,
|
||||
&one,
|
||||
vecAx,
|
||||
CUDA_R_64F,
|
||||
CUSPARSE_SPMV_ALG_DEFAULT,
|
||||
buffer));
|
||||
|
||||
checkCudaErrors(cudaMemcpyAsync(h_r, d_r, sizeof(double) * rowsA, cudaMemcpyDeviceToHost, stream));
|
||||
/* wait until h_r is ready */
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
|
||||
b_inf = vec_norminf(rowsA, h_b);
|
||||
x_inf = vec_norminf(colsA, h_x);
|
||||
r_inf = vec_norminf(rowsA, h_r);
|
||||
A_inf = csr_mat_norminf(rowsA, colsA, nnzA, descrA, h_csrValA, h_csrRowPtrA, h_csrColIndA);
|
||||
|
||||
printf("(CPU) |b - A*x| = %E \n", r_inf);
|
||||
printf("(CPU) |A| = %E \n", A_inf);
|
||||
printf("(CPU) |x| = %E \n", x_inf);
|
||||
printf("(CPU) |b| = %E \n", b_inf);
|
||||
printf("(CPU) |b - A*x|/(|A|*|x| + |b|) = %E \n", r_inf / (A_inf * x_inf + b_inf));
|
||||
|
||||
printf("step 7: solve A*x = b on GPU\n");
|
||||
start = second();
|
||||
|
||||
/* solve B*z = Q*b */
|
||||
if (0 == strcmp(opts.testFunc, "chol")) {
|
||||
checkCudaErrors(cusolverSpDcsrlsvchol(
|
||||
handle, rowsA, nnzA, descrA, d_csrValB, d_csrRowPtrB, d_csrColIndB, d_Qb, tol, reorder, d_z, &singularity));
|
||||
}
|
||||
else if (0 == strcmp(opts.testFunc, "lu")) {
|
||||
printf("WARNING: no LU available on GPU \n");
|
||||
}
|
||||
else if (0 == strcmp(opts.testFunc, "qr")) {
|
||||
checkCudaErrors(cusolverSpDcsrlsvqr(
|
||||
handle, rowsA, nnzA, descrA, d_csrValB, d_csrRowPtrB, d_csrColIndB, d_Qb, tol, reorder, d_z, &singularity));
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "Error: %s is unknow function\n", opts.testFunc);
|
||||
return 1;
|
||||
}
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
if (0 <= singularity) {
|
||||
printf("WARNING: the matrix is singular at row %d under tol (%E)\n", singularity, tol);
|
||||
}
|
||||
/* Q*x = z */
|
||||
cusparseSpVecDescr_t vecz = NULL;
|
||||
checkCudaErrors(
|
||||
cusparseCreateSpVec(&vecz, colsA, rowsA, d_Q, d_z, CUSPARSE_INDEX_32I, CUSPARSE_INDEX_BASE_ZERO, CUDA_R_64F));
|
||||
checkCudaErrors(cusparseScatter(cusparseHandle, vecz, vecx));
|
||||
checkCudaErrors(cusparseDestroySpVec(vecz));
|
||||
|
||||
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
|
||||
stop = second();
|
||||
time_solve_gpu = stop - start;
|
||||
|
||||
printf("step 8: evaluate residual r = b - A*x (result on GPU)\n");
|
||||
checkCudaErrors(cudaMemcpyAsync(d_r, d_b, sizeof(double) * rowsA, cudaMemcpyDeviceToDevice, stream));
|
||||
|
||||
checkCudaErrors(cusparseSpMV(cusparseHandle,
|
||||
CUSPARSE_OPERATION_NON_TRANSPOSE,
|
||||
&minus_one,
|
||||
matA,
|
||||
vecx,
|
||||
&one,
|
||||
vecAx,
|
||||
CUDA_R_64F,
|
||||
CUSPARSE_SPMV_ALG_DEFAULT,
|
||||
buffer));
|
||||
|
||||
checkCudaErrors(cudaMemcpyAsync(h_x, d_x, sizeof(double) * colsA, cudaMemcpyDeviceToHost, stream));
|
||||
checkCudaErrors(cudaMemcpyAsync(h_r, d_r, sizeof(double) * rowsA, cudaMemcpyDeviceToHost, stream));
|
||||
/* wait until h_x and h_r are ready */
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
|
||||
b_inf = vec_norminf(rowsA, h_b);
|
||||
x_inf = vec_norminf(colsA, h_x);
|
||||
r_inf = vec_norminf(rowsA, h_r);
|
||||
|
||||
if (0 != strcmp(opts.testFunc, "lu")) {
|
||||
// only cholesky and qr have GPU version
|
||||
printf("(GPU) |b - A*x| = %E \n", r_inf);
|
||||
printf("(GPU) |A| = %E \n", A_inf);
|
||||
printf("(GPU) |x| = %E \n", x_inf);
|
||||
printf("(GPU) |b| = %E \n", b_inf);
|
||||
printf("(GPU) |b - A*x|/(|A|*|x| + |b|) = %E \n", r_inf / (A_inf * x_inf + b_inf));
|
||||
}
|
||||
|
||||
fprintf(stdout, "timing %s: CPU = %10.6f sec , GPU = %10.6f sec\n", opts.testFunc, time_solve_cpu, time_solve_gpu);
|
||||
|
||||
if (0 != strcmp(opts.testFunc, "lu")) {
|
||||
printf("show last 10 elements of solution vector (GPU) \n");
|
||||
printf("consistent result for different reordering and solver \n");
|
||||
for (int j = rowsA - 10; j < rowsA; j++) {
|
||||
printf("x[%d] = %E\n", j, h_x[j]);
|
||||
}
|
||||
}
|
||||
|
||||
if (handle) {
|
||||
checkCudaErrors(cusolverSpDestroy(handle));
|
||||
}
|
||||
if (cusparseHandle) {
|
||||
checkCudaErrors(cusparseDestroy(cusparseHandle));
|
||||
}
|
||||
if (stream) {
|
||||
checkCudaErrors(cudaStreamDestroy(stream));
|
||||
}
|
||||
if (descrA) {
|
||||
checkCudaErrors(cusparseDestroyMatDescr(descrA));
|
||||
}
|
||||
if (matA) {
|
||||
checkCudaErrors(cusparseDestroySpMat(matA));
|
||||
}
|
||||
if (vecx) {
|
||||
checkCudaErrors(cusparseDestroyDnVec(vecx));
|
||||
}
|
||||
if (vecAx) {
|
||||
checkCudaErrors(cusparseDestroyDnVec(vecAx));
|
||||
}
|
||||
|
||||
if (h_csrValA) {
|
||||
free(h_csrValA);
|
||||
}
|
||||
if (h_csrRowPtrA) {
|
||||
free(h_csrRowPtrA);
|
||||
}
|
||||
if (h_csrColIndA) {
|
||||
free(h_csrColIndA);
|
||||
}
|
||||
if (h_z) {
|
||||
free(h_z);
|
||||
}
|
||||
if (h_x) {
|
||||
free(h_x);
|
||||
}
|
||||
if (h_b) {
|
||||
free(h_b);
|
||||
}
|
||||
if (h_Qb) {
|
||||
free(h_Qb);
|
||||
}
|
||||
if (h_r) {
|
||||
free(h_r);
|
||||
}
|
||||
|
||||
if (h_Q) {
|
||||
free(h_Q);
|
||||
}
|
||||
|
||||
if (h_csrRowPtrB) {
|
||||
free(h_csrRowPtrB);
|
||||
}
|
||||
if (h_csrColIndB) {
|
||||
free(h_csrColIndB);
|
||||
}
|
||||
if (h_csrValB) {
|
||||
free(h_csrValB);
|
||||
}
|
||||
if (h_mapBfromA) {
|
||||
free(h_mapBfromA);
|
||||
}
|
||||
|
||||
if (buffer_cpu) {
|
||||
free(buffer_cpu);
|
||||
}
|
||||
|
||||
if (buffer) {
|
||||
checkCudaErrors(cudaFree(buffer));
|
||||
}
|
||||
if (d_csrValA) {
|
||||
checkCudaErrors(cudaFree(d_csrValA));
|
||||
}
|
||||
if (d_csrRowPtrA) {
|
||||
checkCudaErrors(cudaFree(d_csrRowPtrA));
|
||||
}
|
||||
if (d_csrColIndA) {
|
||||
checkCudaErrors(cudaFree(d_csrColIndA));
|
||||
}
|
||||
if (d_csrValB) {
|
||||
checkCudaErrors(cudaFree(d_csrValB));
|
||||
}
|
||||
if (d_csrRowPtrB) {
|
||||
checkCudaErrors(cudaFree(d_csrRowPtrB));
|
||||
}
|
||||
if (d_csrColIndB) {
|
||||
checkCudaErrors(cudaFree(d_csrColIndB));
|
||||
}
|
||||
if (d_Q) {
|
||||
checkCudaErrors(cudaFree(d_Q));
|
||||
}
|
||||
if (d_z) {
|
||||
checkCudaErrors(cudaFree(d_z));
|
||||
}
|
||||
if (d_x) {
|
||||
checkCudaErrors(cudaFree(d_x));
|
||||
}
|
||||
if (d_b) {
|
||||
checkCudaErrors(cudaFree(d_b));
|
||||
}
|
||||
if (d_Qb) {
|
||||
checkCudaErrors(cudaFree(d_Qb));
|
||||
}
|
||||
if (d_r) {
|
||||
checkCudaErrors(cudaFree(d_r));
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
29803
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/lap2D_5pt_n100.mtx
Normal file
29803
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/lap2D_5pt_n100.mtx
Normal file
File diff suppressed because it is too large
Load Diff
30803
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/lap3D_7pt_n20.mtx
Normal file
30803
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/lap3D_7pt_n20.mtx
Normal file
File diff suppressed because it is too large
Load Diff
477
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/mmio.c
Normal file
477
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/mmio.c
Normal file
@@ -0,0 +1,477 @@
|
||||
/*
|
||||
* Matrix Market I/O library for ANSI C
|
||||
*
|
||||
* See http://math.nist.gov/MatrixMarket for details.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
/* avoid Windows warnings (for example: strcpy, fscanf, etc.) */
|
||||
#if defined(_WIN32)
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#endif
|
||||
|
||||
#include "mmio.h"
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
int mm_read_unsymmetric_sparse(const char *fname, int *M_, int *N_, int *nz_, double **val_, int **I_, int **J_)
|
||||
{
|
||||
FILE *f;
|
||||
MM_typecode matcode;
|
||||
int M, N, nz;
|
||||
int i;
|
||||
double *val;
|
||||
int *I, *J;
|
||||
|
||||
if ((f = fopen(fname, "r")) == NULL)
|
||||
return -1;
|
||||
|
||||
|
||||
if (mm_read_banner(f, &matcode) != 0) {
|
||||
printf("mm_read_unsymetric: Could not process Matrix Market banner ");
|
||||
printf(" in file [%s]\n", fname);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
if (!(mm_is_real(matcode) && mm_is_matrix(matcode) && mm_is_sparse(matcode))) {
|
||||
fprintf(stderr, "Sorry, this application does not support ");
|
||||
fprintf(stderr, "Market Market type: [%s]\n", mm_typecode_to_str(matcode));
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* find out size of sparse matrix: M, N, nz .... */
|
||||
|
||||
if (mm_read_mtx_crd_size(f, &M, &N, &nz) != 0) {
|
||||
fprintf(stderr, "read_unsymmetric_sparse(): could not parse matrix size.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
*M_ = M;
|
||||
*N_ = N;
|
||||
*nz_ = nz;
|
||||
|
||||
/* reserve memory for matrices */
|
||||
|
||||
I = (int *)malloc(nz * sizeof(int));
|
||||
J = (int *)malloc(nz * sizeof(int));
|
||||
val = (double *)malloc(nz * sizeof(double));
|
||||
|
||||
*val_ = val;
|
||||
*I_ = I;
|
||||
*J_ = J;
|
||||
|
||||
/* NOTE: when reading in doubles, ANSI C requires the use of the "l" */
|
||||
/* specifier as in "%lg", "%lf", "%le", otherwise errors will occur */
|
||||
/* (ANSI C X3.159-1989, Sec. 4.9.6.2, p. 136 lines 13-15) */
|
||||
|
||||
for (i = 0; i < nz; i++) {
|
||||
if (fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i]) != 3) {
|
||||
return -1;
|
||||
}
|
||||
I[i]--; /* adjust from 1-based to 0-based */
|
||||
J[i]--;
|
||||
}
|
||||
fclose(f);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mm_is_valid(MM_typecode matcode)
|
||||
{
|
||||
if (!mm_is_matrix(matcode))
|
||||
return 0;
|
||||
if (mm_is_dense(matcode) && mm_is_pattern(matcode))
|
||||
return 0;
|
||||
if (mm_is_real(matcode) && mm_is_hermitian(matcode))
|
||||
return 0;
|
||||
if (mm_is_pattern(matcode) && (mm_is_hermitian(matcode) || mm_is_skew(matcode)))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int mm_read_banner(FILE *f, MM_typecode *matcode)
|
||||
{
|
||||
char line[MM_MAX_LINE_LENGTH];
|
||||
char banner[MM_MAX_TOKEN_LENGTH];
|
||||
char mtx[MM_MAX_TOKEN_LENGTH];
|
||||
char crd[MM_MAX_TOKEN_LENGTH];
|
||||
char data_type[MM_MAX_TOKEN_LENGTH];
|
||||
char storage_scheme[MM_MAX_TOKEN_LENGTH];
|
||||
char *p;
|
||||
|
||||
|
||||
mm_clear_typecode(matcode);
|
||||
|
||||
if (fgets(line, MM_MAX_LINE_LENGTH, f) == NULL)
|
||||
return MM_PREMATURE_EOF;
|
||||
|
||||
if (sscanf(line, "%s %s %s %s %s", banner, mtx, crd, data_type, storage_scheme) != 5)
|
||||
return MM_PREMATURE_EOF;
|
||||
|
||||
for (p = mtx; *p != '\0'; *p = tolower(*p), p++)
|
||||
; /* convert to lower case */
|
||||
for (p = crd; *p != '\0'; *p = tolower(*p), p++)
|
||||
;
|
||||
for (p = data_type; *p != '\0'; *p = tolower(*p), p++)
|
||||
;
|
||||
for (p = storage_scheme; *p != '\0'; *p = tolower(*p), p++)
|
||||
;
|
||||
|
||||
/* check for banner */
|
||||
if (strncmp(banner, MatrixMarketBanner, strlen(MatrixMarketBanner)) != 0)
|
||||
return MM_NO_HEADER;
|
||||
|
||||
/* first field should be "mtx" */
|
||||
if (strcmp(mtx, MM_MTX_STR) != 0)
|
||||
return MM_UNSUPPORTED_TYPE;
|
||||
mm_set_matrix(matcode);
|
||||
|
||||
|
||||
/* second field describes whether this is a sparse matrix (in coordinate
|
||||
storage) or a dense array */
|
||||
|
||||
|
||||
if (strcmp(crd, MM_SPARSE_STR) == 0)
|
||||
mm_set_sparse(matcode);
|
||||
else if (strcmp(crd, MM_DENSE_STR) == 0)
|
||||
mm_set_dense(matcode);
|
||||
else
|
||||
return MM_UNSUPPORTED_TYPE;
|
||||
|
||||
|
||||
/* third field */
|
||||
|
||||
if (strcmp(data_type, MM_REAL_STR) == 0)
|
||||
mm_set_real(matcode);
|
||||
else if (strcmp(data_type, MM_COMPLEX_STR) == 0)
|
||||
mm_set_complex(matcode);
|
||||
else if (strcmp(data_type, MM_PATTERN_STR) == 0)
|
||||
mm_set_pattern(matcode);
|
||||
else if (strcmp(data_type, MM_INT_STR) == 0)
|
||||
mm_set_integer(matcode);
|
||||
else
|
||||
return MM_UNSUPPORTED_TYPE;
|
||||
|
||||
|
||||
/* fourth field */
|
||||
|
||||
if (strcmp(storage_scheme, MM_GENERAL_STR) == 0)
|
||||
mm_set_general(matcode);
|
||||
else if (strcmp(storage_scheme, MM_SYMM_STR) == 0)
|
||||
mm_set_symmetric(matcode);
|
||||
else if (strcmp(storage_scheme, MM_HERM_STR) == 0)
|
||||
mm_set_hermitian(matcode);
|
||||
else if (strcmp(storage_scheme, MM_SKEW_STR) == 0)
|
||||
mm_set_skew(matcode);
|
||||
else
|
||||
return MM_UNSUPPORTED_TYPE;
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mm_write_mtx_crd_size(FILE *f, int M, int N, int nz)
|
||||
{
|
||||
if (fprintf(f, "%d %d %d\n", M, N, nz) != 3)
|
||||
return MM_COULD_NOT_WRITE_FILE;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz)
|
||||
{
|
||||
char line[MM_MAX_LINE_LENGTH];
|
||||
int num_items_read;
|
||||
|
||||
/* set return null parameter values, in case we exit with errors */
|
||||
*M = *N = *nz = 0;
|
||||
|
||||
/* now continue scanning until you reach the end-of-comments */
|
||||
do {
|
||||
if (fgets(line, MM_MAX_LINE_LENGTH, f) == NULL)
|
||||
return MM_PREMATURE_EOF;
|
||||
} while (line[0] == '%');
|
||||
|
||||
/* line[] is either blank or has M,N, nz */
|
||||
if (sscanf(line, "%d %d %d", M, N, nz) == 3)
|
||||
return 0;
|
||||
|
||||
else
|
||||
do {
|
||||
num_items_read = fscanf(f, "%d %d %d", M, N, nz);
|
||||
if (num_items_read == EOF)
|
||||
return MM_PREMATURE_EOF;
|
||||
} while (num_items_read != 3);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int mm_read_mtx_array_size(FILE *f, int *M, int *N)
|
||||
{
|
||||
char line[MM_MAX_LINE_LENGTH];
|
||||
int num_items_read;
|
||||
/* set return null parameter values, in case we exit with errors */
|
||||
*M = *N = 0;
|
||||
|
||||
/* now continue scanning until you reach the end-of-comments */
|
||||
do {
|
||||
if (fgets(line, MM_MAX_LINE_LENGTH, f) == NULL)
|
||||
return MM_PREMATURE_EOF;
|
||||
} while (line[0] == '%');
|
||||
|
||||
/* line[] is either blank or has M,N, nz */
|
||||
if (sscanf(line, "%d %d", M, N) == 2)
|
||||
return 0;
|
||||
|
||||
else /* we have a blank line */
|
||||
do {
|
||||
num_items_read = fscanf(f, "%d %d", M, N);
|
||||
if (num_items_read == EOF)
|
||||
return MM_PREMATURE_EOF;
|
||||
} while (num_items_read != 2);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mm_write_mtx_array_size(FILE *f, int M, int N)
|
||||
{
|
||||
if (fprintf(f, "%d %d\n", M, N) != 2)
|
||||
return MM_COULD_NOT_WRITE_FILE;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/******************************************************************/
|
||||
/* use when I[], J[], and val[]J, and val[] are already allocated */
|
||||
/******************************************************************/
|
||||
|
||||
int mm_read_mtx_crd_data(FILE *f, int M, int N, int nz, int I[], int J[], double val[], MM_typecode matcode)
|
||||
{
|
||||
int i;
|
||||
if (mm_is_complex(matcode)) {
|
||||
for (i = 0; i < nz; i++)
|
||||
if (fscanf(f, "%d %d %lg %lg", &I[i], &J[i], &val[2 * i], &val[2 * i + 1]) != 4)
|
||||
return MM_PREMATURE_EOF;
|
||||
}
|
||||
else if (mm_is_real(matcode) || mm_is_integer(matcode)) {
|
||||
for (i = 0; i < nz; i++) {
|
||||
if (fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i]) != 3)
|
||||
return MM_PREMATURE_EOF;
|
||||
}
|
||||
}
|
||||
|
||||
else if (mm_is_pattern(matcode)) {
|
||||
for (i = 0; i < nz; i++)
|
||||
if (fscanf(f, "%d %d", &I[i], &J[i]) != 2)
|
||||
return MM_PREMATURE_EOF;
|
||||
}
|
||||
else
|
||||
return MM_UNSUPPORTED_TYPE;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mm_read_mtx_crd_entry(FILE *f, int *I, int *J, double *real, double *imag, MM_typecode matcode)
|
||||
{
|
||||
if (mm_is_complex(matcode)) {
|
||||
if (fscanf(f, "%d %d %lg %lg", I, J, real, imag) != 4)
|
||||
return MM_PREMATURE_EOF;
|
||||
}
|
||||
else if (mm_is_real(matcode) || mm_is_integer(matcode)) {
|
||||
if (fscanf(f, "%d %d %lg\n", I, J, real) != 3)
|
||||
return MM_PREMATURE_EOF;
|
||||
}
|
||||
|
||||
else if (mm_is_pattern(matcode)) {
|
||||
if (fscanf(f, "%d %d", I, J) != 2)
|
||||
return MM_PREMATURE_EOF;
|
||||
}
|
||||
else
|
||||
return MM_UNSUPPORTED_TYPE;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/************************************************************************
|
||||
mm_read_mtx_crd() fills M, N, nz, array of values, and return
|
||||
type code, e.g. 'MCRS'
|
||||
|
||||
if matrix is complex, values[] is of size 2*nz,
|
||||
(nz pairs of real/imaginary values)
|
||||
************************************************************************/
|
||||
|
||||
int mm_read_mtx_crd(char *fname, int *M, int *N, int *nz, int **I, int **J, double **val, MM_typecode *matcode)
|
||||
{
|
||||
int ret_code;
|
||||
FILE *f;
|
||||
|
||||
if (strcmp(fname, "stdin") == 0)
|
||||
f = stdin;
|
||||
else if ((f = fopen(fname, "r")) == NULL)
|
||||
return MM_COULD_NOT_READ_FILE;
|
||||
|
||||
|
||||
if ((ret_code = mm_read_banner(f, matcode)) != 0)
|
||||
return ret_code;
|
||||
|
||||
if (!(mm_is_valid(*matcode) && mm_is_sparse(*matcode) && mm_is_matrix(*matcode)))
|
||||
return MM_UNSUPPORTED_TYPE;
|
||||
|
||||
if ((ret_code = mm_read_mtx_crd_size(f, M, N, nz)) != 0)
|
||||
return ret_code;
|
||||
|
||||
|
||||
*I = (int *)malloc(*nz * sizeof(int));
|
||||
*J = (int *)malloc(*nz * sizeof(int));
|
||||
*val = NULL;
|
||||
|
||||
if (mm_is_complex(*matcode)) {
|
||||
*val = (double *)malloc(*nz * 2 * sizeof(double));
|
||||
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val, *matcode);
|
||||
if (ret_code != 0)
|
||||
return ret_code;
|
||||
}
|
||||
else if (mm_is_real(*matcode) || mm_is_integer(*matcode)) {
|
||||
*val = (double *)malloc(*nz * sizeof(double));
|
||||
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val, *matcode);
|
||||
if (ret_code != 0)
|
||||
return ret_code;
|
||||
}
|
||||
|
||||
else if (mm_is_pattern(*matcode)) {
|
||||
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val, *matcode);
|
||||
if (ret_code != 0)
|
||||
return ret_code;
|
||||
}
|
||||
|
||||
if (f != stdin)
|
||||
fclose(f);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mm_write_banner(FILE *f, MM_typecode matcode)
|
||||
{
|
||||
char *str = mm_typecode_to_str(matcode);
|
||||
int ret_code;
|
||||
|
||||
ret_code = fprintf(f, "%s %s\n", MatrixMarketBanner, str);
|
||||
free(str);
|
||||
if (ret_code != 2)
|
||||
return MM_COULD_NOT_WRITE_FILE;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mm_write_mtx_crd(char fname[], int M, int N, int nz, int I[], int J[], double val[], MM_typecode matcode)
|
||||
{
|
||||
FILE *f;
|
||||
int i;
|
||||
|
||||
if (strcmp(fname, "stdout") == 0)
|
||||
f = stdout;
|
||||
else if ((f = fopen(fname, "w")) == NULL)
|
||||
return MM_COULD_NOT_WRITE_FILE;
|
||||
|
||||
/* print banner followed by typecode */
|
||||
fprintf(f, "%s ", MatrixMarketBanner);
|
||||
fprintf(f, "%s\n", mm_typecode_to_str(matcode));
|
||||
|
||||
/* print matrix sizes and nonzeros */
|
||||
fprintf(f, "%d %d %d\n", M, N, nz);
|
||||
|
||||
/* print values */
|
||||
if (mm_is_pattern(matcode))
|
||||
for (i = 0; i < nz; i++)
|
||||
fprintf(f, "%d %d\n", I[i], J[i]);
|
||||
else if (mm_is_integer(matcode))
|
||||
for (i = 0; i < nz; i++)
|
||||
fprintf(f, "%d %d %d\n", I[i], J[i], (int)val[i]);
|
||||
else if (mm_is_real(matcode))
|
||||
for (i = 0; i < nz; i++)
|
||||
fprintf(f, "%d %d %20.16g\n", I[i], J[i], val[i]);
|
||||
else if (mm_is_complex(matcode))
|
||||
for (i = 0; i < nz; i++)
|
||||
fprintf(f, "%d %d %20.16g %20.16g\n", I[i], J[i], val[2 * i], val[2 * i + 1]);
|
||||
else {
|
||||
if (f != stdout)
|
||||
fclose(f);
|
||||
return MM_UNSUPPORTED_TYPE;
|
||||
}
|
||||
|
||||
if (f != stdout)
|
||||
fclose(f);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new copy of a string s. mm_strdup() is a common routine, but
|
||||
* not part of ANSI C, so it is included here. Used by mm_typecode_to_str().
|
||||
*
|
||||
*/
|
||||
static char *mm_strdup(const char *s)
|
||||
{
|
||||
size_t len = strlen(s);
|
||||
char *s2 = (char *)malloc((len + 1) * sizeof(char));
|
||||
return strcpy(s2, s);
|
||||
}
|
||||
|
||||
char *mm_typecode_to_str(MM_typecode matcode)
|
||||
{
|
||||
char buffer[MM_MAX_LINE_LENGTH];
|
||||
char *types[4];
|
||||
// char *mm_strdup(const char *);
|
||||
// int error =0;
|
||||
|
||||
/* check for MTX type */
|
||||
if (mm_is_matrix(matcode))
|
||||
types[0] = MM_MTX_STR;
|
||||
else
|
||||
return NULL; // error=1;
|
||||
|
||||
/* check for CRD or ARR matrix */
|
||||
if (mm_is_sparse(matcode))
|
||||
types[1] = MM_SPARSE_STR;
|
||||
else if (mm_is_dense(matcode))
|
||||
types[1] = MM_DENSE_STR;
|
||||
else
|
||||
return NULL;
|
||||
|
||||
/* check for element data type */
|
||||
if (mm_is_real(matcode))
|
||||
types[2] = MM_REAL_STR;
|
||||
else if (mm_is_complex(matcode))
|
||||
types[2] = MM_COMPLEX_STR;
|
||||
else if (mm_is_pattern(matcode))
|
||||
types[2] = MM_PATTERN_STR;
|
||||
else if (mm_is_integer(matcode))
|
||||
types[2] = MM_INT_STR;
|
||||
else
|
||||
return NULL;
|
||||
|
||||
|
||||
/* check for symmetry type */
|
||||
if (mm_is_general(matcode))
|
||||
types[3] = MM_GENERAL_STR;
|
||||
else if (mm_is_symmetric(matcode))
|
||||
types[3] = MM_SYMM_STR;
|
||||
else if (mm_is_hermitian(matcode))
|
||||
types[3] = MM_HERM_STR;
|
||||
else if (mm_is_skew(matcode))
|
||||
types[3] = MM_SKEW_STR;
|
||||
else
|
||||
return NULL;
|
||||
|
||||
sprintf(buffer, "%s %s %s %s", types[0], types[1], types[2], types[3]);
|
||||
return mm_strdup(buffer);
|
||||
}
|
||||
138
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/mmio.h
Normal file
138
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/mmio.h
Normal file
@@ -0,0 +1,138 @@
|
||||
/*
|
||||
* Matrix Market I/O library for ANSI C
|
||||
*
|
||||
* See http://math.nist.gov/MatrixMarket for details.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MM_IO_H
|
||||
#define MM_IO_H
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C"
|
||||
{
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#define MM_MAX_LINE_LENGTH 1025
|
||||
#define MatrixMarketBanner "%%MatrixMarket"
|
||||
#define MM_MAX_TOKEN_LENGTH 64
|
||||
|
||||
typedef char MM_typecode[4];
|
||||
|
||||
char *mm_typecode_to_str(MM_typecode matcode);
|
||||
|
||||
int mm_read_banner(FILE *f, MM_typecode *matcode);
|
||||
int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz);
|
||||
int mm_read_mtx_array_size(FILE *f, int *M, int *N);
|
||||
|
||||
int mm_write_banner(FILE *f, MM_typecode matcode);
|
||||
int mm_write_mtx_crd_size(FILE *f, int M, int N, int nz);
|
||||
int mm_write_mtx_array_size(FILE *f, int M, int N);
|
||||
|
||||
|
||||
/********************* MM_typecode query fucntions ***************************/
|
||||
|
||||
#define mm_is_matrix(typecode) ((typecode)[0] == 'M')
|
||||
|
||||
#define mm_is_sparse(typecode) ((typecode)[1] == 'C')
|
||||
#define mm_is_coordinate(typecode) ((typecode)[1] == 'C')
|
||||
#define mm_is_dense(typecode) ((typecode)[1] == 'A')
|
||||
#define mm_is_array(typecode) ((typecode)[1] == 'A')
|
||||
|
||||
#define mm_is_complex(typecode) ((typecode)[2] == 'C')
|
||||
#define mm_is_real(typecode) ((typecode)[2] == 'R')
|
||||
#define mm_is_pattern(typecode) ((typecode)[2] == 'P')
|
||||
#define mm_is_integer(typecode) ((typecode)[2] == 'I')
|
||||
|
||||
#define mm_is_symmetric(typecode) ((typecode)[3] == 'S')
|
||||
#define mm_is_general(typecode) ((typecode)[3] == 'G')
|
||||
#define mm_is_skew(typecode) ((typecode)[3] == 'K')
|
||||
#define mm_is_hermitian(typecode) ((typecode)[3] == 'H')
|
||||
|
||||
int mm_is_valid(MM_typecode matcode); /* too complex for a macro */
|
||||
|
||||
|
||||
/********************* MM_typecode modify fucntions ***************************/
|
||||
|
||||
#define mm_set_matrix(typecode) ((*typecode)[0] = 'M')
|
||||
#define mm_set_coordinate(typecode) ((*typecode)[1] = 'C')
|
||||
#define mm_set_array(typecode) ((*typecode)[1] = 'A')
|
||||
#define mm_set_dense(typecode) mm_set_array(typecode)
|
||||
#define mm_set_sparse(typecode) mm_set_coordinate(typecode)
|
||||
|
||||
#define mm_set_complex(typecode) ((*typecode)[2] = 'C')
|
||||
#define mm_set_real(typecode) ((*typecode)[2] = 'R')
|
||||
#define mm_set_pattern(typecode) ((*typecode)[2] = 'P')
|
||||
#define mm_set_integer(typecode) ((*typecode)[2] = 'I')
|
||||
|
||||
|
||||
#define mm_set_symmetric(typecode) ((*typecode)[3] = 'S')
|
||||
#define mm_set_general(typecode) ((*typecode)[3] = 'G')
|
||||
#define mm_set_skew(typecode) ((*typecode)[3] = 'K')
|
||||
#define mm_set_hermitian(typecode) ((*typecode)[3] = 'H')
|
||||
|
||||
#define mm_clear_typecode(typecode) ((*typecode)[0] = (*typecode)[1] = (*typecode)[2] = ' ', (*typecode)[3] = 'G')
|
||||
|
||||
#define mm_initialize_typecode(typecode) mm_clear_typecode(typecode)
|
||||
|
||||
|
||||
/********************* Matrix Market error codes ***************************/
|
||||
|
||||
|
||||
#define MM_COULD_NOT_READ_FILE 11
|
||||
#define MM_PREMATURE_EOF 12
|
||||
#define MM_NOT_MTX 13
|
||||
#define MM_NO_HEADER 14
|
||||
#define MM_UNSUPPORTED_TYPE 15
|
||||
#define MM_LINE_TOO_LONG 16
|
||||
#define MM_COULD_NOT_WRITE_FILE 17
|
||||
|
||||
|
||||
/******************** Matrix Market internal definitions ********************
|
||||
|
||||
MM_matrix_typecode: 4-character sequence
|
||||
|
||||
ojbect sparse/ data storage
|
||||
dense type scheme
|
||||
|
||||
string position: [0] [1] [2] [3]
|
||||
|
||||
Matrix typecode: M(atrix) C(oord) R(eal) G(eneral)
|
||||
A(array) C(omplex) H(ermitian)
|
||||
P(attern) S(ymmetric)
|
||||
I(nteger) K(kew)
|
||||
|
||||
***********************************************************************/
|
||||
|
||||
#define MM_MTX_STR "matrix"
|
||||
#define MM_ARRAY_STR "array"
|
||||
#define MM_DENSE_STR "array"
|
||||
#define MM_COORDINATE_STR "coordinate"
|
||||
#define MM_SPARSE_STR "coordinate"
|
||||
#define MM_COMPLEX_STR "complex"
|
||||
#define MM_REAL_STR "real"
|
||||
#define MM_INT_STR "integer"
|
||||
#define MM_GENERAL_STR "general"
|
||||
#define MM_SYMM_STR "symmetric"
|
||||
#define MM_HERM_STR "hermitian"
|
||||
#define MM_SKEW_STR "skew-symmetric"
|
||||
#define MM_PATTERN_STR "pattern"
|
||||
|
||||
|
||||
/* high level routines */
|
||||
int mm_read_mtx_crd(char *fname, int *M, int *N, int *nz, int **I, int **J, double **val, MM_typecode *matcode);
|
||||
|
||||
int mm_write_mtx_crd(char fname[], int M, int N, int nz, int I[], int J[], double val[], MM_typecode matcode);
|
||||
int mm_read_mtx_crd_data(FILE *f, int M, int N, int nz, int I[], int J[], double val[], MM_typecode matcode);
|
||||
int mm_read_mtx_crd_entry(FILE *f, int *I, int *J, double *real, double *img, MM_typecode matcode);
|
||||
|
||||
int mm_read_unsymmetric_sparse(const char *fname, int *M_, int *N_, int *nz_, double **val_, int **I_, int **J_);
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
473
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/mmio_wrapper.cpp
Normal file
473
cpp/4_CUDA_Libraries/cuSolverSp_LinearSolver/mmio_wrapper.cpp
Normal file
@@ -0,0 +1,473 @@
|
||||
|
||||
#include <cusolverDn.h>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "mmio.h"
|
||||
|
||||
/* avoid Windows warnings (for example: strcpy, fscanf, etc.) */
|
||||
#if defined(_WIN32)
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#endif
|
||||
|
||||
/* various __inline__ __device__ function to initialize a T_ELEM */
|
||||
template <typename T_ELEM> __inline__ T_ELEM cuGet(int);
|
||||
template <> __inline__ float cuGet<float>(int x) { return float(x); }
|
||||
|
||||
template <> __inline__ double cuGet<double>(int x) { return double(x); }
|
||||
|
||||
template <> __inline__ cuComplex cuGet<cuComplex>(int x) { return (make_cuComplex(float(x), 0.0f)); }
|
||||
|
||||
template <> __inline__ cuDoubleComplex cuGet<cuDoubleComplex>(int x) { return (make_cuDoubleComplex(double(x), 0.0)); }
|
||||
|
||||
|
||||
template <typename T_ELEM> __inline__ T_ELEM cuGet(int, int);
|
||||
template <> __inline__ float cuGet<float>(int x, int y) { return float(x); }
|
||||
|
||||
template <> __inline__ double cuGet<double>(int x, int y) { return double(x); }
|
||||
|
||||
template <> __inline__ cuComplex cuGet<cuComplex>(int x, int y) { return make_cuComplex(float(x), float(y)); }
|
||||
|
||||
template <> __inline__ cuDoubleComplex cuGet<cuDoubleComplex>(int x, int y)
|
||||
{
|
||||
return (make_cuDoubleComplex(double(x), double(y)));
|
||||
}
|
||||
|
||||
|
||||
template <typename T_ELEM> __inline__ T_ELEM cuGet(float);
|
||||
template <> __inline__ float cuGet<float>(float x) { return float(x); }
|
||||
|
||||
template <> __inline__ double cuGet<double>(float x) { return double(x); }
|
||||
|
||||
template <> __inline__ cuComplex cuGet<cuComplex>(float x) { return (make_cuComplex(float(x), 0.0f)); }
|
||||
|
||||
template <> __inline__ cuDoubleComplex cuGet<cuDoubleComplex>(float x)
|
||||
{
|
||||
return (make_cuDoubleComplex(double(x), 0.0));
|
||||
}
|
||||
|
||||
|
||||
template <typename T_ELEM> __inline__ T_ELEM cuGet(float, float);
|
||||
template <> __inline__ float cuGet<float>(float x, float y) { return float(x); }
|
||||
|
||||
template <> __inline__ double cuGet<double>(float x, float y) { return double(x); }
|
||||
|
||||
template <> __inline__ cuComplex cuGet<cuComplex>(float x, float y) { return (make_cuComplex(float(x), float(y))); }
|
||||
|
||||
template <> __inline__ cuDoubleComplex cuGet<cuDoubleComplex>(float x, float y)
|
||||
{
|
||||
return (make_cuDoubleComplex(double(x), double(y)));
|
||||
}
|
||||
|
||||
|
||||
template <typename T_ELEM> __inline__ T_ELEM cuGet(double);
|
||||
template <> __inline__ float cuGet<float>(double x) { return float(x); }
|
||||
|
||||
template <> __inline__ double cuGet<double>(double x) { return double(x); }
|
||||
|
||||
template <> __inline__ cuComplex cuGet<cuComplex>(double x) { return (make_cuComplex(float(x), 0.0f)); }
|
||||
|
||||
template <> __inline__ cuDoubleComplex cuGet<cuDoubleComplex>(double x)
|
||||
{
|
||||
return (make_cuDoubleComplex(double(x), 0.0));
|
||||
}
|
||||
|
||||
|
||||
template <typename T_ELEM> __inline__ T_ELEM cuGet(double, double);
|
||||
template <> __inline__ float cuGet<float>(double x, double y) { return float(x); }
|
||||
|
||||
template <> __inline__ double cuGet<double>(double x, double y) { return double(x); }
|
||||
|
||||
template <> __inline__ cuComplex cuGet<cuComplex>(double x, double y) { return (make_cuComplex(float(x), float(y))); }
|
||||
|
||||
template <> __inline__ cuDoubleComplex cuGet<cuDoubleComplex>(double x, double y)
|
||||
{
|
||||
return (make_cuDoubleComplex(double(x), double(y)));
|
||||
}
|
||||
|
||||
|
||||
static void compress_index(const int *Ind, int nnz, int m, int *Ptr, int base)
|
||||
{
|
||||
int i;
|
||||
|
||||
/* initialize everything to zero */
|
||||
for (i = 0; i < m + 1; i++) {
|
||||
Ptr[i] = 0;
|
||||
}
|
||||
/* count elements in every row */
|
||||
Ptr[0] = base;
|
||||
for (i = 0; i < nnz; i++) {
|
||||
Ptr[Ind[i] + (1 - base)]++;
|
||||
}
|
||||
/* add all the values */
|
||||
for (i = 0; i < m; i++) {
|
||||
Ptr[i + 1] += Ptr[i];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
struct cooFormat
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int p; // permutation
|
||||
};
|
||||
|
||||
|
||||
int cmp_cooFormat_csr(struct cooFormat *s, struct cooFormat *t)
|
||||
{
|
||||
if (s->i < t->i) {
|
||||
return -1;
|
||||
}
|
||||
else if (s->i > t->i) {
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
return s->j - t->j;
|
||||
}
|
||||
}
|
||||
|
||||
int cmp_cooFormat_csc(struct cooFormat *s, struct cooFormat *t)
|
||||
{
|
||||
if (s->j < t->j) {
|
||||
return -1;
|
||||
}
|
||||
else if (s->j > t->j) {
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
return s->i - t->i;
|
||||
}
|
||||
}
|
||||
|
||||
typedef int (*FUNPTR)(const void *, const void *);
|
||||
typedef int (*FUNPTR2)(struct cooFormat *s, struct cooFormat *t);
|
||||
|
||||
static FUNPTR2 fptr_array[2] = {
|
||||
cmp_cooFormat_csr,
|
||||
cmp_cooFormat_csc,
|
||||
};
|
||||
|
||||
|
||||
static int verify_pattern(int m, int nnz, int *csrRowPtr, int *csrColInd)
|
||||
{
|
||||
int i, col, start, end, base_index;
|
||||
int error_found = 0;
|
||||
|
||||
if (nnz != (csrRowPtr[m] - csrRowPtr[0])) {
|
||||
fprintf(stderr,
|
||||
"Error (nnz check failed): (csrRowPtr[%d]=%d - csrRowPtr[%d]=%d) != (nnz=%d)\n",
|
||||
0,
|
||||
csrRowPtr[0],
|
||||
m,
|
||||
csrRowPtr[m],
|
||||
nnz);
|
||||
error_found = 1;
|
||||
}
|
||||
|
||||
base_index = csrRowPtr[0];
|
||||
if ((0 != base_index) && (1 != base_index)) {
|
||||
fprintf(stderr, "Error (base index check failed): base index = %d\n", base_index);
|
||||
error_found = 1;
|
||||
}
|
||||
|
||||
for (i = 0; (!error_found) && (i < m); i++) {
|
||||
start = csrRowPtr[i] - base_index;
|
||||
end = csrRowPtr[i + 1] - base_index;
|
||||
if (start > end) {
|
||||
fprintf(stderr,
|
||||
"Error (corrupted row): csrRowPtr[%d] (=%d) > csrRowPtr[%d] (=%d)\n",
|
||||
i,
|
||||
start + base_index,
|
||||
i + 1,
|
||||
end + base_index);
|
||||
error_found = 1;
|
||||
}
|
||||
for (col = start; col < end; col++) {
|
||||
if (csrColInd[col] < base_index) {
|
||||
fprintf(stderr, "Error (column vs. base index check failed): csrColInd[%d] < %d\n", col, base_index);
|
||||
error_found = 1;
|
||||
}
|
||||
if ((col < (end - 1)) && (csrColInd[col] >= csrColInd[col + 1])) {
|
||||
fprintf(
|
||||
stderr,
|
||||
"Error (sorting of the column indecis check failed): (csrColInd[%d]=%d) >= (csrColInd[%d]=%d)\n",
|
||||
col,
|
||||
csrColInd[col],
|
||||
col + 1,
|
||||
csrColInd[col + 1]);
|
||||
error_found = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return error_found;
|
||||
}
|
||||
|
||||
|
||||
template <typename T_ELEM>
|
||||
int loadMMSparseMatrix(char *filename,
|
||||
char elem_type,
|
||||
bool csrFormat,
|
||||
int *m,
|
||||
int *n,
|
||||
int *nnz,
|
||||
T_ELEM **aVal,
|
||||
int **aRowInd,
|
||||
int **aColInd,
|
||||
int extendSymMatrix)
|
||||
{
|
||||
MM_typecode matcode;
|
||||
double *tempVal;
|
||||
int *tempRowInd, *tempColInd;
|
||||
double *tval;
|
||||
int *trow, *tcol;
|
||||
int *csrRowPtr, *cscColPtr;
|
||||
int i, j, error, base, count;
|
||||
struct cooFormat *work;
|
||||
|
||||
/* read the matrix */
|
||||
error = mm_read_mtx_crd(filename, m, n, nnz, &trow, &tcol, &tval, &matcode);
|
||||
if (error) {
|
||||
fprintf(stderr, "!!!! can not open file: '%s'\n", filename);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* start error checking */
|
||||
if (mm_is_complex(matcode) && ((elem_type != 'z') && (elem_type != 'c'))) {
|
||||
fprintf(stderr, "!!!! complex matrix requires type 'z' or 'c'\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (mm_is_dense(matcode) || mm_is_array(matcode) || mm_is_pattern(matcode) /*|| mm_is_integer(matcode)*/) {
|
||||
fprintf(stderr, "!!!! dense, array, pattern and integer matrices are not supported\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* if necessary symmetrize the pattern (transform from triangular to full) */
|
||||
if ((extendSymMatrix) && (mm_is_symmetric(matcode) || mm_is_hermitian(matcode) || mm_is_skew(matcode))) {
|
||||
// count number of non-diagonal elements
|
||||
count = 0;
|
||||
for (i = 0; i < (*nnz); i++) {
|
||||
if (trow[i] != tcol[i]) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
// allocate space for the symmetrized matrix
|
||||
tempRowInd = (int *)malloc((*nnz + count) * sizeof(int));
|
||||
tempColInd = (int *)malloc((*nnz + count) * sizeof(int));
|
||||
if (mm_is_real(matcode) || mm_is_integer(matcode)) {
|
||||
tempVal = (double *)malloc((*nnz + count) * sizeof(double));
|
||||
}
|
||||
else {
|
||||
tempVal = (double *)malloc(2 * (*nnz + count) * sizeof(double));
|
||||
}
|
||||
// copy the elements regular and transposed locations
|
||||
for (j = 0, i = 0; i < (*nnz); i++) {
|
||||
tempRowInd[j] = trow[i];
|
||||
tempColInd[j] = tcol[i];
|
||||
if (mm_is_real(matcode) || mm_is_integer(matcode)) {
|
||||
tempVal[j] = tval[i];
|
||||
}
|
||||
else {
|
||||
tempVal[2 * j] = tval[2 * i];
|
||||
tempVal[2 * j + 1] = tval[2 * i + 1];
|
||||
}
|
||||
j++;
|
||||
if (trow[i] != tcol[i]) {
|
||||
tempRowInd[j] = tcol[i];
|
||||
tempColInd[j] = trow[i];
|
||||
if (mm_is_real(matcode) || mm_is_integer(matcode)) {
|
||||
if (mm_is_skew(matcode)) {
|
||||
tempVal[j] = -tval[i];
|
||||
}
|
||||
else {
|
||||
tempVal[j] = tval[i];
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (mm_is_hermitian(matcode)) {
|
||||
tempVal[2 * j] = tval[2 * i];
|
||||
tempVal[2 * j + 1] = -tval[2 * i + 1];
|
||||
}
|
||||
else {
|
||||
tempVal[2 * j] = tval[2 * i];
|
||||
tempVal[2 * j + 1] = tval[2 * i + 1];
|
||||
}
|
||||
}
|
||||
j++;
|
||||
}
|
||||
}
|
||||
(*nnz) += count;
|
||||
// free temporary storage
|
||||
free(trow);
|
||||
free(tcol);
|
||||
free(tval);
|
||||
}
|
||||
else {
|
||||
tempRowInd = trow;
|
||||
tempColInd = tcol;
|
||||
tempVal = tval;
|
||||
}
|
||||
// life time of (trow, tcol, tval) is over.
|
||||
// please use COO format (tempRowInd, tempColInd, tempVal)
|
||||
|
||||
// use qsort to sort COO format
|
||||
work = (struct cooFormat *)malloc(sizeof(struct cooFormat) * (*nnz));
|
||||
if (NULL == work) {
|
||||
fprintf(stderr, "!!!! allocation error, malloc failed\n");
|
||||
return 1;
|
||||
}
|
||||
for (i = 0; i < (*nnz); i++) {
|
||||
work[i].i = tempRowInd[i];
|
||||
work[i].j = tempColInd[i];
|
||||
work[i].p = i; // permutation is identity
|
||||
}
|
||||
|
||||
if (csrFormat) {
|
||||
/* create row-major ordering of indices (sorted by row and within each row by column) */
|
||||
qsort(work, *nnz, sizeof(struct cooFormat), (FUNPTR)fptr_array[0]);
|
||||
}
|
||||
else {
|
||||
/* create column-major ordering of indices (sorted by column and within each column by row) */
|
||||
qsort(work, *nnz, sizeof(struct cooFormat), (FUNPTR)fptr_array[1]);
|
||||
}
|
||||
|
||||
// (tempRowInd, tempColInd) is sorted either by row-major or by col-major
|
||||
for (i = 0; i < (*nnz); i++) {
|
||||
tempRowInd[i] = work[i].i;
|
||||
tempColInd[i] = work[i].j;
|
||||
}
|
||||
|
||||
// setup base
|
||||
// check if there is any row/col 0, if so base-0
|
||||
// check if there is any row/col equal to matrix dimension m/n, if so base-1
|
||||
int base0 = 0;
|
||||
int base1 = 0;
|
||||
for (i = 0; i < (*nnz); i++) {
|
||||
const int row = tempRowInd[i];
|
||||
const int col = tempColInd[i];
|
||||
if ((0 == row) || (0 == col)) {
|
||||
base0 = 1;
|
||||
}
|
||||
if ((*m == row) || (*n == col)) {
|
||||
base1 = 1;
|
||||
}
|
||||
}
|
||||
if (base0 && base1) {
|
||||
printf("Error: input matrix is base-0 and base-1 \n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
base = 0;
|
||||
if (base1) {
|
||||
base = 1;
|
||||
}
|
||||
|
||||
/* compress the appropriate indices */
|
||||
if (csrFormat) {
|
||||
/* CSR format (assuming row-major format) */
|
||||
csrRowPtr = (int *)malloc(((*m) + 1) * sizeof(csrRowPtr[0]));
|
||||
if (!csrRowPtr)
|
||||
return 1;
|
||||
compress_index(tempRowInd, *nnz, *m, csrRowPtr, base);
|
||||
|
||||
*aRowInd = csrRowPtr;
|
||||
*aColInd = (int *)malloc((*nnz) * sizeof(int));
|
||||
}
|
||||
else {
|
||||
/* CSC format (assuming column-major format) */
|
||||
cscColPtr = (int *)malloc(((*n) + 1) * sizeof(cscColPtr[0]));
|
||||
if (!cscColPtr)
|
||||
return 1;
|
||||
compress_index(tempColInd, *nnz, *n, cscColPtr, base);
|
||||
|
||||
*aColInd = cscColPtr;
|
||||
*aRowInd = (int *)malloc((*nnz) * sizeof(int));
|
||||
}
|
||||
|
||||
/* transfrom the matrix values of type double into one of the cusparse library types */
|
||||
*aVal = (T_ELEM *)malloc((*nnz) * sizeof(T_ELEM));
|
||||
|
||||
for (i = 0; i < (*nnz); i++) {
|
||||
if (csrFormat) {
|
||||
(*aColInd)[i] = tempColInd[i];
|
||||
}
|
||||
else {
|
||||
(*aRowInd)[i] = tempRowInd[i];
|
||||
}
|
||||
if (mm_is_real(matcode) || mm_is_integer(matcode)) {
|
||||
(*aVal)[i] = cuGet<T_ELEM>(tempVal[work[i].p]);
|
||||
}
|
||||
else {
|
||||
(*aVal)[i] = cuGet<T_ELEM>(tempVal[2 * work[i].p], tempVal[2 * work[i].p + 1]);
|
||||
}
|
||||
}
|
||||
|
||||
/* check for corruption */
|
||||
int error_found;
|
||||
if (csrFormat) {
|
||||
error_found = verify_pattern(*m, *nnz, *aRowInd, *aColInd);
|
||||
}
|
||||
else {
|
||||
error_found = verify_pattern(*n, *nnz, *aColInd, *aRowInd);
|
||||
}
|
||||
if (error_found) {
|
||||
fprintf(stderr, "!!!! verify_pattern failed\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* cleanup and exit */
|
||||
free(work);
|
||||
free(tempVal);
|
||||
free(tempColInd);
|
||||
free(tempRowInd);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* specific instantiation */
|
||||
template int loadMMSparseMatrix<float>(char *filename,
|
||||
char elem_type,
|
||||
bool csrFormat,
|
||||
int *m,
|
||||
int *n,
|
||||
int *nnz,
|
||||
float **aVal,
|
||||
int **aRowInd,
|
||||
int **aColInd,
|
||||
int extendSymMatrix);
|
||||
|
||||
template int loadMMSparseMatrix<double>(char *filename,
|
||||
char elem_type,
|
||||
bool csrFormat,
|
||||
int *m,
|
||||
int *n,
|
||||
int *nnz,
|
||||
double **aVal,
|
||||
int **aRowInd,
|
||||
int **aColInd,
|
||||
int extendSymMatrix);
|
||||
|
||||
template int loadMMSparseMatrix<cuComplex>(char *filename,
|
||||
char elem_type,
|
||||
bool csrFormat,
|
||||
int *m,
|
||||
int *n,
|
||||
int *nnz,
|
||||
cuComplex **aVal,
|
||||
int **aRowInd,
|
||||
int **aColInd,
|
||||
int extendSymMatrix);
|
||||
|
||||
template int loadMMSparseMatrix<cuDoubleComplex>(char *filename,
|
||||
char elem_type,
|
||||
bool csrFormat,
|
||||
int *m,
|
||||
int *n,
|
||||
int *nnz,
|
||||
cuDoubleComplex **aVal,
|
||||
int **aRowInd,
|
||||
int **aColInd,
|
||||
int extendSymMatrix);
|
||||
Reference in New Issue
Block a user