├── README.md
├── run_experiments.sh
├── Makefile
├── inc
    ├── mvstructs.h
    └── mmio.h
├── apps
    └── csrspmv.cpp
└── src
    ├── mmio.cpp
    └── mvstructs.cpp


/README.md:
--------------------------------------------------------------------------------
1 | # cusparse spmv
2 | 
3 | A small example program for benchmarking cuSPARSE's csrmv routine with real-world
4 | data, against a randomly initialised vector.
5 | 
6 | Calling `make` should be sufficient to build the example program.
7 | The example can then be called as follows: `./bin/csrspmv <matrixfile> <matrixname> <hostname>`


--------------------------------------------------------------------------------
/run_experiments.sh:
--------------------------------------------------------------------------------
 1 | #/bin/sh
 2 | 
 3 | datasetf=$1
 4 | echo "Dataset folder: $datasetf"
 5 | 
 6 | spmv=$2
 7 | echo "SparseMatrixDenseVector excutable: $spmv"
 8 | 
 9 | table=$3
10 | echo "Table name: $table"
11 | 
12 | # Get some unique data for the experiment ID
13 | now=$(date -Iminutes)
14 | hsh=$(git rev-parse HEAD)
15 | exID="$hsh-$now"
16 | host=$(hostname)
17 | 
18 | # make a folder for results
19 | mkdir -p "results-$exID"
20 | 
21 | for f in $(cat $datasetf/datasets.txt);
22 | do
23 | 	echo "matrix: $f"
24 | 	echo "Resultfile: result_$f.txt"
25 | 
26 | 	$spmv $datasetf/$f/$f.mtx $f $host $exID $table &> results-$exID/result_$f.txt
27 | done
28 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | # Compiler
 2 | CC = g++
 3 | 
 4 | # (Final) Binary, Source, Include, Object and Apps directories
 5 | BIN = bin
 6 | SRC = src
 7 | INC = inc
 8 | OBJ = obj
 9 | APP = apps
10 | 
11 | # Sources for building object files, and their associated objects
12 | SOURCES = mvstructs.cpp mmio.cpp
13 | OBJECTS = $(patsubst %.cpp,$(OBJ)/%.o,$(SOURCES))
14 | 
15 | # Sources for the applications this makefile builds
16 | APP_SOURCES = csrspmv.cpp 
17 | APPS = $(patsubst %.cpp,$(BIN)/%,$(APP_SOURCES))
18 | 
19 | # Universal C flags
20 | CFLAGS = -std=c++11 -O3 
21 | 
22 | # Get the host and shell, to determine include directories and link options
23 | HOST = $(shell hostname)
24 | UNAME = $(shell uname)
25 | SKELCL_DIR = 
26 | 
27 | # Add the include directories to a single variable, which we can pass to $(CC)
28 | INCLUDE = -I$(INC) -I/usr/local/cuda-8.0/include/
29 | 
30 | # Define a single general linker string for $(CC)
31 | LINK = -L/usr/local/cuda-8.0/lib64/ -lcuda -lcudart -lcusparse
32 | 
33 | # discover where source and header files are located
34 | vpath %.cpp $(SRC) $(APPS)
35 | # vpath %.cpp 
36 | vpath %.h $(INC)
37 | vpath %.hpp $(INC)
38 | 
39 | # General rule to trigger the others, depend on the makefile so that everything recompiles when the makefile changes
40 | all: $(APPS) $(OBJECTS) Makefile
41 | 
42 | # Clean by simply deleting the $(OBJ) and $(BIN) directories
43 | clean: 
44 | 	rm -rf $(OBJ) $(BIN) 
45 | 
46 | # A rule for building individual apps - make the $(BIN) directory if it doesn't exist
47 | $(BIN)/%: $(APP)/%.cpp $(OBJECTS) 
48 | 	if [ ! -d $(BIN) ]; then mkdir $(BIN); fi
49 | 	# add -Werror here, as it breaks some of the libraries (e.g. mmio) that we rely on
50 | 	$(CC) $< $(INCLUDE) $(OBJECTS) $(CFLAGS) $(LINK) -o $@
51 | 
52 | # A rule for building individual object files - make the $(OBJ) directory if it doesn't exist
53 | $(OBJ)/%.o: %.cpp
54 | 	if [ ! -d $(OBJ) ]; then mkdir $(OBJ); fi
55 | 	$(CC) $(CFLAGS) $(INCLUDE) -c $< -o $@
56 | 
57 | 


--------------------------------------------------------------------------------
/inc/mvstructs.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <cstdlib>
  3 | #include <iostream>
  4 | #include <fstream>
  5 | #include <cstdlib>
  6 | #include <cstdio>
  7 | #include <random>
  8 | #include <algorithm>
  9 | #include <functional>
 10 | #include "mmio.h"
 11 | #include <cuda_runtime.h>
 12 | #include "cusparse.h"
 13 | 
 14 | 
 15 | enum MemStatus {
 16 |     HostOutdated,
 17 |     DeviceOutdated,
 18 |     UpToDate
 19 | };
 20 | 
 21 | class denseVector
 22 | {
 23 | public:
 24 |     denseVector(int);
 25 |     ~denseVector();
 26 |     denseVector & operator= (const denseVector&);
 27 |     void push(float);
 28 |     void fill(float);
 29 |     void fillRandom();
 30 |     void print();
 31 |     float* getDevPtr();
 32 |     void download();
 33 | private:
 34 |     float* hostPtr;
 35 |     float* devPtr;
 36 |     int n;
 37 |     int ixPtr;
 38 |     MemStatus mstatus;
 39 | 
 40 |     void updateBuffers();
 41 |     void cleanup();
 42 | };
 43 | 
 44 | class csrMatrix
 45 | {
 46 | public:
 47 | 
 48 |     csrMatrix(int, int, int, int*, int*, float*);
 49 |     ~csrMatrix();
 50 |     std::vector<float> spmv(cusparseHandle_t,denseVector&,denseVector&);
 51 | private:
 52 |     // device pointers 
 53 |     int* rowDevPtr;
 54 |     int* colIxDevPtr;
 55 |     float* valDevPtr;
 56 |     int nnz;
 57 |     int h;
 58 |     int w;
 59 |     // no host pointers - we hopefully won't need them
 60 |     // buffer status. This should always be "HostOutdated"
 61 |     // MemStatus status;
 62 |     // void updateBuffers();
 63 | };
 64 | 
 65 | class cooMatrix
 66 | {
 67 | public:
 68 |     cooMatrix(int, int, int);
 69 |     cooMatrix(std::string);
 70 |     ~cooMatrix();
 71 |     void push(int, int, float);
 72 |     // sorting after pushing values
 73 |     void print();
 74 |     csrMatrix asCSR(cusparseHandle_t);
 75 |     int getWidth() {return w;}
 76 | 
 77 | private: 
 78 |     int nnz;
 79 |     int h;
 80 |     int w;
 81 |     // host pointers
 82 |     int * rowIndexHostPtr;
 83 |     int * colIndexHostPtr;
 84 |     float * valHostPtr;
 85 |     // device pointers
 86 |     int * rowIndexDevPtr;
 87 |     int * colIndexDevPtr;
 88 |     float* valDevPtr;
 89 |     int ixPtr;
 90 |     // transfer status
 91 |     MemStatus mstatus;
 92 |     void updateBuffers();
 93 |     // cleanup functionality
 94 |     void cleanup();
 95 |     // memory allocation
 96 |     void alloc();
 97 | };
 98 | 
 99 | 
100 | 


--------------------------------------------------------------------------------
/inc/mmio.h:
--------------------------------------------------------------------------------
  1 | /* 
  2 | *   Matrix Market I/O library for ANSI C
  3 | *
  4 | *   See http://math.nist.gov/MatrixMarket for details.
  5 | *
  6 | *
  7 | */
  8 | 
  9 | #ifndef MM_IO_H
 10 | #define MM_IO_H
 11 | 
 12 | #define MM_MAX_LINE_LENGTH 1025
 13 | #define MatrixMarketBanner "%%MatrixMarket"
 14 | #define MM_MAX_TOKEN_LENGTH 64
 15 | 
 16 | typedef char MM_typecode[4];
 17 | 
 18 | char *mm_typecode_to_str(MM_typecode matcode);
 19 | 
 20 | int mm_read_banner(FILE *f, MM_typecode *matcode);
 21 | int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz);
 22 | int mm_read_mtx_array_size(FILE *f, int *M, int *N);
 23 | 
 24 | int mm_write_banner(FILE *f, MM_typecode matcode);
 25 | int mm_write_mtx_crd_size(FILE *f, int M, int N, int nz);
 26 | int mm_write_mtx_array_size(FILE *f, int M, int N);
 27 | 
 28 | 
 29 | /********************* MM_typecode query fucntions ***************************/
 30 | 
 31 | #define mm_is_matrix(typecode)	((typecode)[0]=='M')
 32 | 
 33 | #define mm_is_sparse(typecode)	((typecode)[1]=='C')
 34 | #define mm_is_coordinate(typecode)((typecode)[1]=='C')
 35 | #define mm_is_dense(typecode)	((typecode)[1]=='A')
 36 | #define mm_is_array(typecode)	((typecode)[1]=='A')
 37 | 
 38 | #define mm_is_complex(typecode)	((typecode)[2]=='C')
 39 | #define mm_is_real(typecode)		((typecode)[2]=='R')
 40 | #define mm_is_pattern(typecode)	((typecode)[2]=='P')
 41 | #define mm_is_integer(typecode) ((typecode)[2]=='I')
 42 | 
 43 | #define mm_is_symmetric(typecode)((typecode)[3]=='S')
 44 | #define mm_is_general(typecode)	((typecode)[3]=='G')
 45 | #define mm_is_skew(typecode)	((typecode)[3]=='K')
 46 | #define mm_is_hermitian(typecode)((typecode)[3]=='H')
 47 | 
 48 | int mm_is_valid(MM_typecode matcode);		/* too complex for a macro */
 49 | 
 50 | 
 51 | /********************* MM_typecode modify fucntions ***************************/
 52 | 
 53 | #define mm_set_matrix(typecode)	((*typecode)[0]='M')
 54 | #define mm_set_coordinate(typecode)	((*typecode)[1]='C')
 55 | #define mm_set_array(typecode)	((*typecode)[1]='A')
 56 | #define mm_set_dense(typecode)	mm_set_array(typecode)
 57 | #define mm_set_sparse(typecode)	mm_set_coordinate(typecode)
 58 | 
 59 | #define mm_set_complex(typecode)((*typecode)[2]='C')
 60 | #define mm_set_real(typecode)	((*typecode)[2]='R')
 61 | #define mm_set_pattern(typecode)((*typecode)[2]='P')
 62 | #define mm_set_integer(typecode)((*typecode)[2]='I')
 63 | 
 64 | 
 65 | #define mm_set_symmetric(typecode)((*typecode)[3]='S')
 66 | #define mm_set_general(typecode)((*typecode)[3]='G')
 67 | #define mm_set_skew(typecode)	((*typecode)[3]='K')
 68 | #define mm_set_hermitian(typecode)((*typecode)[3]='H')
 69 | 
 70 | #define mm_clear_typecode(typecode) ((*typecode)[0]=(*typecode)[1]= \
 71 | 									(*typecode)[2]=' ',(*typecode)[3]='G')
 72 | 
 73 | #define mm_initialize_typecode(typecode) mm_clear_typecode(typecode)
 74 | 
 75 | 
 76 | /********************* Matrix Market error codes ***************************/
 77 | 
 78 | 
 79 | #define MM_COULD_NOT_READ_FILE	11
 80 | #define MM_PREMATURE_EOF		12
 81 | #define MM_NOT_MTX				13
 82 | #define MM_NO_HEADER			14
 83 | #define MM_UNSUPPORTED_TYPE		15
 84 | #define MM_LINE_TOO_LONG		16
 85 | #define MM_COULD_NOT_WRITE_FILE	17
 86 | 
 87 | 
 88 | /******************** Matrix Market internal definitions ********************
 89 | 
 90 |    MM_matrix_typecode: 4-character sequence
 91 | 
 92 | 				    object 		sparse/   	data        storage 
 93 | 						  		dense     	type        scheme
 94 | 
 95 |    string position:	 [0]        [1]			[2]         [3]
 96 | 
 97 |    Matrix typecode:  M(atrix)  C(oord)		R(eal)   	G(eneral)
 98 | 						        A(array)	C(omplex)   H(ermitian)
 99 | 											P(attern)   S(ymmetric)
100 | 								    		I(nteger)	K(kew)
101 | 
102 |  ***********************************************************************/
103 | 
104 | #define MM_MTX_STR		"matrix"
105 | #define MM_ARRAY_STR	"array"
106 | #define MM_DENSE_STR	"array"
107 | #define MM_COORDINATE_STR "coordinate" 
108 | #define MM_SPARSE_STR	"coordinate"
109 | #define MM_COMPLEX_STR	"complex"
110 | #define MM_REAL_STR		"real"
111 | #define MM_INT_STR		"integer"
112 | #define MM_GENERAL_STR  "general"
113 | #define MM_SYMM_STR		"symmetric"
114 | #define MM_HERM_STR		"hermitian"
115 | #define MM_SKEW_STR		"skew-symmetric"
116 | #define MM_PATTERN_STR  "pattern"
117 | 
118 | 
119 | /*  high level routines */
120 | 
121 | int mm_write_mtx_crd(char fname[], int M, int N, int nz, int I[], int J[],
122 | 		 double val[], MM_typecode matcode);
123 | int mm_read_mtx_crd_data(FILE *f, int M, int N, int nz, int I[], int J[],
124 | 		double val[], MM_typecode matcode);
125 | int mm_read_mtx_crd_entry(FILE *f, int *I, int *J, double *real, double *img,
126 | 			MM_typecode matcode);
127 | 
128 | int mm_read_unsymmetric_sparse(const char *fname, int *M_, int *N_, int *nz_,
129 |                 double **val_, int **I_, int **J_);
130 | 
131 | 
132 | 
133 | #endif
134 | 


--------------------------------------------------------------------------------
/apps/csrspmv.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <string>
  3 | #include <cstdlib>
  4 | #include <tuple>
  5 | #include <cuda_runtime.h>
  6 | 
  7 | #include "cusparse.h"
  8 | #include "mvstructs.h"
  9 | 
 10 | std::tuple<cusparseHandle_t, std::string> initCUSparse() {
 11 |   cusparseStatus_t status;
 12 |   cusparseHandle_t handle = 0;
 13 | 
 14 |   // init cusparse
 15 |   status = cusparseCreate(&handle);
 16 |   if (status != CUSPARSE_STATUS_SUCCESS) {
 17 |     std::cerr << "CUSPARSE Library initialisation failed" << std::endl;
 18 |     cusparseDestroy(handle);
 19 |     exit(1);
 20 |   }
 21 | 
 22 |   // get ad device, and check it has compute capability 1.3
 23 |   int devID;
 24 |   cudaDeviceProp prop;
 25 |   cudaError_t cudaStat;
 26 |   cudaStat = cudaGetDevice(&devID);
 27 |   if (cudaSuccess != cudaStat) {
 28 |     std::cerr << "Error: cudaGetDevice failed!" << std::endl;
 29 |     // do some cleanup...
 30 |     cusparseDestroy(handle);
 31 |     std::cerr << "Error: cudaStat: " << cudaStat << ", "
 32 |               << cudaGetErrorString(cudaStat) << std::endl;
 33 |     exit(1);
 34 |   }
 35 | 
 36 |   cudaStat = cudaGetDeviceProperties(&prop, devID);
 37 |   if (cudaSuccess != cudaStat) {
 38 |     std::cerr << "Error: cudaGetDeviceProperties failed!" << std::endl;
 39 |     // do some cleanup...
 40 |     cusparseDestroy(handle);
 41 |     std::cerr << "Error: cudaStat: " << cudaStat << ", "
 42 |               << cudaGetErrorString(cudaStat) << std::endl;
 43 |     exit(1);
 44 |   }
 45 | 
 46 |   int cc = 100 * prop.major + 10 * prop.minor;
 47 |   if (cc <= 130) {
 48 |     cusparseDestroy(handle);
 49 | 
 50 |     std::cerr << "waive the test because only sm13 and above are supported"
 51 |               << std::endl;
 52 |     std::cerr << "the device has compute capability" << cc << std::endl;
 53 |     std::cerr << "example test WAIVED" << std::endl;
 54 |     exit(2);
 55 |   } else {
 56 |     std::cerr << "Compute capability: " << prop.major << "." << prop.minor
 57 |               << std::endl;
 58 |   }
 59 | 
 60 |   std::string deviceName(prop.name);
 61 |   return std::make_tuple(handle, deviceName);
 62 | }
 63 | 
 64 | void printSqlResult(std::string host, std::string device, std::string matrix,
 65 |                     std::string exID, std::string table,
 66 |                     std::vector<float> runtimes) {
 67 |   std::cout << "insert into " << table
 68 |             << " (time, correct, kernel, global, local, host, device, matrix, "
 69 |                "iteration, trial, statistic, experiment_id) values ";
 70 |   // std::cout<<"insert into TABLE (time, host, device, matrix) values ("<<
 71 |   int trial = 0;
 72 |   std::sort(runtimes.begin(), runtimes.end());
 73 |   for (auto time : runtimes) {
 74 | 
 75 |     if (trial == 0) {
 76 |       std::cout << "(";
 77 |     } else {
 78 |       std::cout << ",(";
 79 |     }
 80 |     std::cout << time << "," << // time
 81 |         "\'correct\'"
 82 |               << "," << // correct
 83 |         "\'cuSPARSE\'"
 84 |               << "," << // kernel
 85 |         "-1"
 86 |               << "," << // global
 87 |         "-1"
 88 |               << "," << // local
 89 |         "\'" << host << "\'"
 90 |               << "," << // host
 91 |         "\'" << device << "\'"
 92 |               << "," << // device
 93 |         "\'" << matrix << "\'"
 94 |               << "," << // matrix
 95 |         "0"
 96 |               << "," << // iteration
 97 |         trial << "," << // trial
 98 |         "\'RAW_RESULT\'"
 99 |               << "," << // statistic
100 |         "\'" << exID << "\'"
101 |               << ")"; // experiment ID
102 |     trial++;
103 |   }
104 | 
105 |   auto median = runtimes[runtimes.size() / 2];
106 |   std::cout << ",(" << median << ", " << // time
107 |       "\'correct\'"
108 |             << "," << // correct
109 |       "\'cuSPARSE\'"
110 |             << "," << // kernel
111 |       "-1"
112 |             << "," << // global
113 |       "-1"
114 |             << "," << // local
115 |       "\'" << host << "\'"
116 |             << "," << // host
117 |       "\'" << device << "\'"
118 |             << "," << // device
119 |       "\'" << matrix << "\'"
120 |             << "," << // matrix
121 |       "0"
122 |             << "," << // iteration
123 |       "-1"
124 |             << "," << // trial
125 |       "\'MEDIAN_RESULT\'"
126 |             << "," << // statistic
127 |       "\'" << exID << "\'"
128 |             << ")"; // experiment ID
129 |   std::cout << ";" << std::endl;
130 | }
131 | 
132 | int main(int argc, char const *argv[]) {
133 |   if (argc < 6) {
134 |     std::cerr << "No table name given!" << std::endl;
135 |     exit(1);
136 |   }
137 |   if (argc < 5) {
138 |     std::cerr << "No expermient id given!" << std::endl;
139 |     exit(1);
140 |   }
141 |   if (argc < 4) {
142 |     std::cerr << "Error: no hostname given!" << std::endl;
143 |     exit(1);
144 |   }
145 |   if (argc < 3) {
146 |     std::cerr << "Error: no matrix name given!" << std::endl;
147 |     exit(1);
148 |   }
149 |   if (argc < 2) {
150 |     std::cerr << "Error: no matrix file specified!" << std::endl;
151 |     exit(1);
152 |   }
153 |   std::string mfname(argv[1]);
154 |   std::string mname(argv[2]);
155 |   std::string hostname(argv[3]);
156 |   std::string exID(argv[4]);
157 |   std::string table(argv[5]);
158 |   std::cerr << "Matrix filename: " << mfname << std::endl;
159 |   std::cerr << "Matrix name: " << mname << std::endl;
160 |   std::cerr << "Hostname: " << hostname << std::endl;
161 |   std::cerr << "Experiment ID: " << exID << std::endl;
162 |   std::cerr << "SQL table: " << table << std::endl;
163 | 
164 |   // input matrix
165 |   cooMatrix cm(mfname);
166 | 
167 |   // input vector
168 |   denseVector v(cm.getWidth());
169 |   v.fillRandom();
170 |   std::cerr << "v before: " << std::endl;
171 |   // v.print();
172 | 
173 |   // output vector
174 |   denseVector result(cm.getWidth());
175 | 
176 |   // cusparse handle
177 |   auto hn = initCUSparse();
178 |   auto handle = std::get<0>(hn);
179 |   auto devname = std::get<1>(hn);
180 |   std::cerr << "Running on device: " << devname << std::endl;
181 | 
182 |   // csr version of the matrix
183 |   csrMatrix csrm = cm.asCSR(handle);
184 | 
185 |   // compute a sparse matrix vector multiplication
186 |   auto times = csrm.spmv(handle, v, result);
187 |   // std::sort(times.begin(), times.end());
188 |   // if (times.size() % 2) {
189 |   //   std::cerr << "Median: " << times[times.size() / 2] << std::endl;
190 |   // } else {
191 |   //   std::cerr << "Median: " << times[(times.size() + 1) / 2] << std::endl;
192 |   // }
193 | 
194 |   printSqlResult(hostname, devname, mname, exID, table, times);
195 | 
196 |   // the result
197 |   // std::cerr<<"result after: "<<std::endl;
198 |   // result.print();
199 | 
200 |   // clean up
201 |   cusparseDestroy(handle);
202 | 
203 |   return 0;
204 | }


--------------------------------------------------------------------------------
/src/mmio.cpp:
--------------------------------------------------------------------------------
  1 | /* 
  2 | *   Matrix Market I/O library for ANSI C
  3 | *
  4 | *   See http://math.nist.gov/MatrixMarket for details.
  5 | *
  6 | *
  7 | */
  8 | 
  9 | 
 10 | #include <stdio.h>
 11 | #include <string.h>
 12 | #include <stdlib.h>
 13 | #include <ctype.h>
 14 | 
 15 | #include "mmio.h"
 16 | 
 17 | int mm_read_unsymmetric_sparse(const char *fname, int *M_, int *N_, int *nz_,
 18 |                 double **val_, int **I_, int **J_)
 19 | {
 20 |     FILE *f;
 21 |     MM_typecode matcode;
 22 |     int M, N, nz;
 23 |     int i;
 24 |     double *val;
 25 |     int *I, *J;
 26 |  
 27 |     if ((f = fopen(fname, "r")) == NULL)
 28 |             return -1;
 29 |  
 30 |  
 31 |     if (mm_read_banner(f, &matcode) != 0)
 32 |     {
 33 |         fprintf(stderr, "mm_read_unsymetric: Could not process Matrix Market banner ");
 34 |         fprintf(stderr, " in file [%s]\n", fname);
 35 |         return -1;
 36 |     }
 37 |  
 38 |  
 39 |  
 40 |     if ( !(mm_is_real(matcode) && mm_is_matrix(matcode) &&
 41 |             mm_is_sparse(matcode)))
 42 |     {
 43 |         fprintf(stderr, "Sorry, this application does not support ");
 44 |         fprintf(stderr, "Market Market type: [%s]\n",
 45 |                 mm_typecode_to_str(matcode));
 46 |         return -1;
 47 |     }
 48 |  
 49 |     /* find out size of sparse matrix: M, N, nz .... */
 50 |  
 51 |     if (mm_read_mtx_crd_size(f, &M, &N, &nz) !=0)
 52 |     {
 53 |         fprintf(stderr, "read_unsymmetric_sparse(): could not parse matrix size.\n");
 54 |         return -1;
 55 |     }
 56 |  
 57 |     *M_ = M;
 58 |     *N_ = N;
 59 |     *nz_ = nz;
 60 |  
 61 |     /* reseve memory for matrices */
 62 |  
 63 |     I = (int *) malloc(nz * sizeof(int));
 64 |     J = (int *) malloc(nz * sizeof(int));
 65 |     val = (double *) malloc(nz * sizeof(double));
 66 |  
 67 |     *val_ = val;
 68 |     *I_ = I;
 69 |     *J_ = J;
 70 |  
 71 |     /* NOTE: when reading in doubles, ANSI C requires the use of the "l"  */
 72 |     /*   specifier as in "%lg", "%lf", "%le", otherwise errors will occur */
 73 |     /*  (ANSI C X3.159-1989, Sec. 4.9.6.2, p. 136 lines 13-15)            */
 74 |  
 75 |     for (i=0; i<nz; i++)
 76 |     {
 77 |         fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i]);
 78 |         I[i]--;  /* adjust from 1-based to 0-based */
 79 |         J[i]--;
 80 |     }
 81 |     fclose(f);
 82 |  
 83 |     return 0;
 84 | }
 85 | 
 86 | int mm_is_valid(MM_typecode matcode)
 87 | {
 88 |     if (!mm_is_matrix(matcode)) return 0;
 89 |     if (mm_is_dense(matcode) && mm_is_pattern(matcode)) return 0;
 90 |     if (mm_is_real(matcode) && mm_is_hermitian(matcode)) return 0;
 91 |     if (mm_is_pattern(matcode) && (mm_is_hermitian(matcode) || 
 92 |                 mm_is_skew(matcode))) return 0;
 93 |     return 1;
 94 | }
 95 | 
 96 | int mm_read_banner(FILE *f, MM_typecode *matcode)
 97 | {
 98 |     char line[MM_MAX_LINE_LENGTH];
 99 |     char banner[MM_MAX_TOKEN_LENGTH];
100 |     char mtx[MM_MAX_TOKEN_LENGTH]; 
101 |     char crd[MM_MAX_TOKEN_LENGTH];
102 |     char data_type[MM_MAX_TOKEN_LENGTH];
103 |     char storage_scheme[MM_MAX_TOKEN_LENGTH];
104 |     char *p;
105 | 
106 | 
107 |     mm_clear_typecode(matcode);  
108 | 
109 |     if (fgets(line, MM_MAX_LINE_LENGTH, f) == NULL) 
110 |         return MM_PREMATURE_EOF;
111 | 
112 |     if (sscanf(line, "%s %s %s %s %s", banner, mtx, crd, data_type, 
113 |         storage_scheme) != 5)
114 |         return MM_PREMATURE_EOF;
115 | 
116 |     for (p=mtx; *p!='\0'; *p=tolower(*p),p++);  /* convert to lower case */
117 |     for (p=crd; *p!='\0'; *p=tolower(*p),p++);  
118 |     for (p=data_type; *p!='\0'; *p=tolower(*p),p++);
119 |     for (p=storage_scheme; *p!='\0'; *p=tolower(*p),p++);
120 | 
121 |     /* check for banner */
122 |     if (strncmp(banner, MatrixMarketBanner, strlen(MatrixMarketBanner)) != 0)
123 |         return MM_NO_HEADER;
124 | 
125 |     /* first field should be "mtx" */
126 |     if (strcmp(mtx, MM_MTX_STR) != 0)
127 |         return  MM_UNSUPPORTED_TYPE;
128 |     mm_set_matrix(matcode);
129 | 
130 | 
131 |     /* second field describes whether this is a sparse matrix (in coordinate
132 |             storgae) or a dense array */
133 | 
134 | 
135 |     if (strcmp(crd, MM_SPARSE_STR) == 0)
136 |         mm_set_sparse(matcode);
137 |     else
138 |     if (strcmp(crd, MM_DENSE_STR) == 0)
139 |             mm_set_dense(matcode);
140 |     else
141 |         return MM_UNSUPPORTED_TYPE;
142 |     
143 | 
144 |     /* third field */
145 | 
146 |     if (strcmp(data_type, MM_REAL_STR) == 0)
147 |         mm_set_real(matcode);
148 |     else
149 |     if (strcmp(data_type, MM_COMPLEX_STR) == 0)
150 |         mm_set_complex(matcode);
151 |     else
152 |     if (strcmp(data_type, MM_PATTERN_STR) == 0)
153 |         mm_set_pattern(matcode);
154 |     else
155 |     if (strcmp(data_type, MM_INT_STR) == 0)
156 |         mm_set_integer(matcode);
157 |     else
158 |         return MM_UNSUPPORTED_TYPE;
159 |     
160 | 
161 |     /* fourth field */
162 | 
163 |     if (strcmp(storage_scheme, MM_GENERAL_STR) == 0)
164 |         mm_set_general(matcode);
165 |     else
166 |     if (strcmp(storage_scheme, MM_SYMM_STR) == 0)
167 |         mm_set_symmetric(matcode);
168 |     else
169 |     if (strcmp(storage_scheme, MM_HERM_STR) == 0)
170 |         mm_set_hermitian(matcode);
171 |     else
172 |     if (strcmp(storage_scheme, MM_SKEW_STR) == 0)
173 |         mm_set_skew(matcode);
174 |     else
175 |         return MM_UNSUPPORTED_TYPE;
176 |         
177 | 
178 |     return 0;
179 | }
180 | 
181 | int mm_write_mtx_crd_size(FILE *f, int M, int N, int nz)
182 | {
183 |     if (fprintf(f, "%d %d %d\n", M, N, nz) != 3)
184 |         return MM_COULD_NOT_WRITE_FILE;
185 |     else 
186 |         return 0;
187 | }
188 | 
189 | int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz )
190 | {
191 |     char line[MM_MAX_LINE_LENGTH];
192 |     int num_items_read;
193 | 
194 |     /* set return null parameter values, in case we exit with errors */
195 |     *M = *N = *nz = 0;
196 | 
197 |     /* now continue scanning until you reach the end-of-comments */
198 |     do 
199 |     {
200 |         if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL) 
201 |             return MM_PREMATURE_EOF;
202 |     }while (line[0] == '%');
203 | 
204 |     /* line[] is either blank or has M,N, nz */
205 |     if (sscanf(line, "%d %d %d", M, N, nz) == 3)
206 |         return 0;
207 |         
208 |     else
209 |     do
210 |     { 
211 |         num_items_read = fscanf(f, "%d %d %d", M, N, nz); 
212 |         if (num_items_read == EOF) return MM_PREMATURE_EOF;
213 |     }
214 |     while (num_items_read != 3);
215 | 
216 |     return 0;
217 | }
218 | 
219 | 
220 | int mm_read_mtx_array_size(FILE *f, int *M, int *N)
221 | {
222 |     char line[MM_MAX_LINE_LENGTH];
223 |     int num_items_read;
224 |     /* set return null parameter values, in case we exit with errors */
225 |     *M = *N = 0;
226 | 	
227 |     /* now continue scanning until you reach the end-of-comments */
228 |     do 
229 |     {
230 |         if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL) 
231 |             return MM_PREMATURE_EOF;
232 |     }while (line[0] == '%');
233 | 
234 |     /* line[] is either blank or has M,N, nz */
235 |     if (sscanf(line, "%d %d", M, N) == 2)
236 |         return 0;
237 |         
238 |     else /* we have a blank line */
239 |     do
240 |     { 
241 |         num_items_read = fscanf(f, "%d %d", M, N); 
242 |         if (num_items_read == EOF) return MM_PREMATURE_EOF;
243 |     }
244 |     while (num_items_read != 2);
245 | 
246 |     return 0;
247 | }
248 | 
249 | int mm_write_mtx_array_size(FILE *f, int M, int N)
250 | {
251 |     if (fprintf(f, "%d %d\n", M, N) != 2)
252 |         return MM_COULD_NOT_WRITE_FILE;
253 |     else 
254 |         return 0;
255 | }
256 | 
257 | 
258 | 
259 | /*-------------------------------------------------------------------------*/
260 | 
261 | /******************************************************************/
262 | /* use when I[], J[], and val[]J, and val[] are already allocated */
263 | /******************************************************************/
264 | 
265 | int mm_read_mtx_crd_data(FILE *f, int M, int N, int nz, int I[], int J[],
266 |         double val[], MM_typecode matcode)
267 | {
268 |     int i;
269 |     if (mm_is_complex(matcode))
270 |     {
271 |         for (i=0; i<nz; i++)
272 |             if (fscanf(f, "%d %d %lg %lg", &I[i], &J[i], &val[2*i], &val[2*i+1])
273 |                 != 4) return MM_PREMATURE_EOF;
274 |     }
275 |     else if (mm_is_real(matcode))
276 |     {
277 |         for (i=0; i<nz; i++)
278 |         {
279 |             if (fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i])
280 |                 != 3) return MM_PREMATURE_EOF;
281 | 
282 |         }
283 |     }
284 | 
285 |     else if (mm_is_pattern(matcode))
286 |     {
287 |         for (i=0; i<nz; i++)
288 |             if (fscanf(f, "%d %d", &I[i], &J[i])
289 |                 != 2) return MM_PREMATURE_EOF;
290 |     }
291 |     else
292 |         return MM_UNSUPPORTED_TYPE;
293 | 
294 |     return 0;
295 |         
296 | }
297 | 
298 | int mm_read_mtx_crd_entry(FILE *f, int *I, int *J,
299 |         double *real, double *imag, MM_typecode matcode)
300 | {
301 |     if (mm_is_complex(matcode))
302 |     {
303 |             if (fscanf(f, "%d %d %lg %lg", I, J, real, imag)
304 |                 != 4) return MM_PREMATURE_EOF;
305 |     }
306 |     else if (mm_is_real(matcode))
307 |     {
308 |             if (fscanf(f, "%d %d %lg\n", I, J, real)
309 |                 != 3) return MM_PREMATURE_EOF;
310 | 
311 |     }
312 | 
313 |     else if (mm_is_pattern(matcode))
314 |     {
315 |             if (fscanf(f, "%d %d", I, J) != 2) return MM_PREMATURE_EOF;
316 |     }
317 |     else
318 |         return MM_UNSUPPORTED_TYPE;
319 | 
320 |     return 0;
321 |         
322 | }
323 | 
324 | 
325 | /************************************************************************
326 |     mm_read_mtx_crd()  fills M, N, nz, array of values, and return
327 |                         type code, e.g. 'MCRS'
328 | 
329 |                         if matrix is complex, values[] is of size 2*nz,
330 |                             (nz pairs of real/imaginary values)
331 | ************************************************************************/
332 | 
333 | int mm_read_mtx_crd(char *fname, int *M, int *N, int *nz, int **I, int **J, 
334 |         double **val, MM_typecode *matcode)
335 | {
336 |     int ret_code;
337 |     FILE *f;
338 | 
339 |     if (strcmp(fname, "stdin") == 0) f=stdin;
340 |     else
341 |     if ((f = fopen(fname, "r")) == NULL)
342 |         return MM_COULD_NOT_READ_FILE;
343 | 
344 | 
345 |     if ((ret_code = mm_read_banner(f, matcode)) != 0)
346 |         return ret_code;
347 | 
348 |     if (!(mm_is_valid(*matcode) && mm_is_sparse(*matcode) && 
349 |             mm_is_matrix(*matcode)))
350 |         return MM_UNSUPPORTED_TYPE;
351 | 
352 |     if ((ret_code = mm_read_mtx_crd_size(f, M, N, nz)) != 0)
353 |         return ret_code;
354 | 
355 | 
356 |     *I = (int *)  malloc(*nz * sizeof(int));
357 |     *J = (int *)  malloc(*nz * sizeof(int));
358 |     *val = NULL;
359 | 
360 |     if (mm_is_complex(*matcode))
361 |     {
362 |         *val = (double *) malloc(*nz * 2 * sizeof(double));
363 |         ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val, 
364 |                 *matcode);
365 |         if (ret_code != 0) return ret_code;
366 |     }
367 |     else if (mm_is_real(*matcode))
368 |     {
369 |         *val = (double *) malloc(*nz * sizeof(double));
370 |         ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val, 
371 |                 *matcode);
372 |         if (ret_code != 0) return ret_code;
373 |     }
374 | 
375 |     else if (mm_is_pattern(*matcode))
376 |     {
377 |         ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val, 
378 |                 *matcode);
379 |         if (ret_code != 0) return ret_code;
380 |     }
381 | 
382 |     if (f != stdin) fclose(f);
383 |     return 0;
384 | }
385 | 
386 | int mm_write_banner(FILE *f, MM_typecode matcode)
387 | {
388 |     char *str = mm_typecode_to_str(matcode);
389 |     int ret_code;
390 | 
391 |     ret_code = fprintf(f, "%s %s\n", MatrixMarketBanner, str);
392 |     free(str);
393 |     if (ret_code !=2 )
394 |         return MM_COULD_NOT_WRITE_FILE;
395 |     else
396 |         return 0;
397 | }
398 | 
399 | int mm_write_mtx_crd(char fname[], int M, int N, int nz, int I[], int J[],
400 |         double val[], MM_typecode matcode)
401 | {
402 |     FILE *f;
403 |     int i;
404 | 
405 |     if (strcmp(fname, "stdout") == 0) 
406 |         f = stdout;
407 |     else
408 |     if ((f = fopen(fname, "w")) == NULL)
409 |         return MM_COULD_NOT_WRITE_FILE;
410 |     
411 |     /* print banner followed by typecode */
412 |     fprintf(f, "%s ", MatrixMarketBanner);
413 |     fprintf(f, "%s\n", mm_typecode_to_str(matcode));
414 | 
415 |     /* print matrix sizes and nonzeros */
416 |     fprintf(f, "%d %d %d\n", M, N, nz);
417 | 
418 |     /* print values */
419 |     if (mm_is_pattern(matcode))
420 |         for (i=0; i<nz; i++)
421 |             fprintf(f, "%d %d\n", I[i], J[i]);
422 |     else
423 |     if (mm_is_real(matcode))
424 |         for (i=0; i<nz; i++)
425 |             fprintf(f, "%d %d %20.16g\n", I[i], J[i], val[i]);
426 |     else
427 |     if (mm_is_complex(matcode))
428 |         for (i=0; i<nz; i++)
429 |             fprintf(f, "%d %d %20.16g %20.16g\n", I[i], J[i], val[2*i], 
430 |                         val[2*i+1]);
431 |     else
432 |     {
433 |         if (f != stdout) fclose(f);
434 |         return MM_UNSUPPORTED_TYPE;
435 |     }
436 | 
437 |     if (f !=stdout) fclose(f);
438 | 
439 |     return 0;
440 | }
441 |   
442 | 
443 | /**
444 | *  Create a new copy of a string s.  mm_strdup() is a common routine, but
445 | *  not part of ANSI C, so it is included here.  Used by mm_typecode_to_str().
446 | *
447 | */
448 | char *mm_strdup(const char *s)
449 | {
450 | 	int len = strlen(s);
451 | 	char *s2 = (char *) malloc((len+1)*sizeof(char));
452 | 	return strcpy(s2, s);
453 | }
454 | 
455 | char  *mm_typecode_to_str(MM_typecode matcode)
456 | {
457 |     char buffer[MM_MAX_LINE_LENGTH];
458 |     char *types[4];
459 | 	char *mm_strdup(const char *);
460 |     int error =0;
461 | 
462 |     /* check for MTX type */
463 |     if (mm_is_matrix(matcode)) 
464 |         types[0] = MM_MTX_STR;
465 |     else
466 |         error=1;
467 | 
468 |     /* check for CRD or ARR matrix */
469 |     if (mm_is_sparse(matcode))
470 |         types[1] = MM_SPARSE_STR;
471 |     else
472 |     if (mm_is_dense(matcode))
473 |         types[1] = MM_DENSE_STR;
474 |     else
475 |         return NULL;
476 | 
477 |     /* check for element data type */
478 |     if (mm_is_real(matcode))
479 |         types[2] = MM_REAL_STR;
480 |     else
481 |     if (mm_is_complex(matcode))
482 |         types[2] = MM_COMPLEX_STR;
483 |     else
484 |     if (mm_is_pattern(matcode))
485 |         types[2] = MM_PATTERN_STR;
486 |     else
487 |     if (mm_is_integer(matcode))
488 |         types[2] = MM_INT_STR;
489 |     else
490 |         return NULL;
491 | 
492 | 
493 |     /* check for symmetry type */
494 |     if (mm_is_general(matcode))
495 |         types[3] = MM_GENERAL_STR;
496 |     else
497 |     if (mm_is_symmetric(matcode))
498 |         types[3] = MM_SYMM_STR;
499 |     else 
500 |     if (mm_is_hermitian(matcode))
501 |         types[3] = MM_HERM_STR;
502 |     else 
503 |     if (mm_is_skew(matcode))
504 |         types[3] = MM_SKEW_STR;
505 |     else
506 |         return NULL;
507 | 
508 |     sprintf(buffer,"%s %s %s %s", types[0], types[1], types[2], types[3]);
509 |     return mm_strdup(buffer);
510 | 
511 | }
512 | 


--------------------------------------------------------------------------------
/src/mvstructs.cpp:
--------------------------------------------------------------------------------
  1 | #include "mvstructs.h"
  2 | 
  3 | // =============================================================================
  4 | // =============================== CSR Matrix ==================================
  5 | // =============================================================================
  6 | 
  7 | 
  8 | csrMatrix::csrMatrix(int _nnz, int _h, int _w, int* _rp, int* _cixp, float* _vp) {
  9 |     rowDevPtr = _rp;
 10 |     colIxDevPtr = _cixp;
 11 |     valDevPtr = _vp;
 12 |     nnz = _nnz;
 13 |     h = _h;
 14 |     w = _w;
 15 | }
 16 | 
 17 | csrMatrix::~csrMatrix() {
 18 |     if(rowDevPtr) cudaFree(rowDevPtr);
 19 |     if(colIxDevPtr) cudaFree(colIxDevPtr);
 20 |     if(valDevPtr) cudaFree(valDevPtr);
 21 | }
 22 | 
 23 | std::vector<float> csrMatrix::spmv(cusparseHandle_t handle, denseVector& _x, denseVector& _r){
 24 |     // create a matrix descriptor
 25 |     cusparseMatDescr_t descr=0;
 26 |     cusparseStatus_t status = cusparseCreateMatDescr(&descr);
 27 |     if(status != CUSPARSE_STATUS_SUCCESS) {
 28 |         std::cerr<<"Matrix desriptor initialisation failed"<<std::endl;
 29 |         cusparseDestroyMatDescr(descr);
 30 |         cusparseDestroy(handle);
 31 |         exit(1);
 32 |     }
 33 |     cusparseSetMatType(descr, CUSPARSE_MATRIX_TYPE_GENERAL);
 34 |     cusparseSetMatIndexBase(descr, CUSPARSE_INDEX_BASE_ZERO);
 35 | 
 36 |     // create cuda events for timing
 37 |     cudaEvent_t start, stop;
 38 |     cudaEventCreate(&start); cudaEventCreate(&stop);
 39 | 
 40 |     // build a vector y
 41 |     denseVector _y = denseVector(w);
 42 |     
 43 | 
 44 |     std::cerr<<"_y before: "<<std::endl;
 45 |     // _y.print();
 46 | 
 47 |     std::cerr<<"Starting spmv..."<<std::endl;
 48 |     // get a pointer to the vector's device memory
 49 |     float* x = _x.getDevPtr();
 50 |     float* y = _y.getDevPtr();
 51 | 
 52 |     float alpha = 1.0;
 53 |     float beta = 1.0;
 54 | 
 55 |     int iterations = 100;
 56 | 
 57 |     float* runtimes = new float[iterations];
 58 |     for(int i = 0;i<iterations;i++){
 59 |         _y.fill(0.0f);
 60 |         // perform the csrspmv computation, and time it
 61 |         cudaEventRecord(start);
 62 |         status= cusparseScsrmv(handle, CUSPARSE_OPERATION_NON_TRANSPOSE, h, w, nnz, &alpha,
 63 |             descr, valDevPtr, rowDevPtr, colIxDevPtr, x, &beta, y);
 64 |         cudaEventRecord(stop);
 65 | 
 66 |         if (status != CUSPARSE_STATUS_SUCCESS) {
 67 |             std::cerr<<"Spmv failed!"<<std::endl;
 68 |             cusparseDestroy(handle);
 69 |             cusparseDestroyMatDescr(descr);
 70 |             exit(3);
 71 |         }    
 72 | 
 73 |         _y.download();
 74 |         cudaEventSynchronize(stop);
 75 |         float milliseconds = 0;
 76 |         cudaEventElapsedTime(&milliseconds, start, stop);
 77 |         // std::cout<<"Took: "<<milliseconds<<"ms"<<std::endl;
 78 |         runtimes[i] = milliseconds;
 79 |     }
 80 | 
 81 | 
 82 |     std::cerr<<"_y after: "<<std::endl;
 83 |     // _y.print();
 84 | 
 85 |     // copy y into _r;
 86 |     _r = _y;
 87 | 
 88 |     cusparseDestroyMatDescr(descr);
 89 | 
 90 |     auto rv =  std::vector<float>(runtimes, runtimes + iterations);
 91 |     delete[] runtimes;
 92 |     return rv;
 93 | }
 94 | 
 95 | 
 96 | // =============================================================================
 97 | // =============================== COO Matrix ==================================
 98 | // =============================================================================
 99 | 
100 | // public
101 | 
102 | cooMatrix::cooMatrix(int _nnz, int _h, int _w) {
103 |     nnz = _nnz;
104 |     h = _h;
105 |     w = _w;
106 |     alloc();
107 |     // set the indexing pointer for adding nonzero elements
108 |     ixPtr = 0;
109 |     // assume we start with the device buffers outdated
110 |     mstatus = DeviceOutdated;
111 | }
112 | 
113 | cooMatrix::cooMatrix(std::string filename) {
114 |     // parse the file!
115 |     // we have to use crappy C file IO functions,
116 |     // as we're using the mmio libraries
117 |     int ret_code;
118 |     MM_typecode matcode;
119 |     FILE* f;
120 | 
121 |     if((f = fopen(filename.c_str(), "r")) == NULL) {
122 |         std::cerr<<"Failed to open matrix file!"<<std::endl;
123 |         exit(3);
124 |     }
125 |     // read in the banner
126 |     if(mm_read_banner(f, &matcode) != 0) {
127 |         std::cerr<<"Could not red matrix market banner!"<<std::endl;
128 |         exit(3);
129 |     }
130 |     // check the banner properties
131 |     if(mm_is_matrix(matcode) && 
132 |        mm_is_coordinate(matcode) &&
133 |        (mm_is_real(matcode) || mm_is_integer(matcode) || mm_is_pattern(matcode)) &&
134 |        (mm_is_general(matcode) || mm_is_symmetric(matcode))
135 |     ){
136 |         std::cerr<<"Found matrix of type: "<<matcode<<std::endl;
137 |     }else{
138 |         std::cerr<<"Cannot process matrix of type: "<<matcode<<std::endl;
139 |     }
140 | 
141 |     // declare matrix size information:
142 |     int _h = -1;
143 |     int _w = -1;
144 |     int _nnz = -1;
145 | 
146 |     if((ret_code = mm_read_mtx_crd_size(f, &_h, &_w, &_nnz)) != 0){
147 |         std::cerr<<"Cannot read matrix size/number of elements!"<<std::endl;
148 |         exit(3);
149 |     }else{
150 |         std::cerr<<"rows: "<<_h<<" cols: "<<_w<<" nnz: "<<_nnz<<std::endl;
151 |     }
152 | 
153 |     // a structure to hold triples
154 |     typedef struct coord {
155 |         int row, col;
156 |         float val;
157 |     } coord;
158 |     // vector of values
159 |     std::vector<coord> nzelems;
160 |     int pat = mm_is_pattern(matcode);
161 |     int sym = mm_is_symmetric(matcode);
162 | 
163 |     // the mmio routines have read up until the first entry, so take advantage of it
164 |     for(int i = 0; i < _nnz; i++){
165 |         coord tmp = {-1, -1, -1.0f};
166 |         if(pat) {
167 |             fscanf(f, "%d %d\n", &(tmp.row), &(tmp.col));
168 |             tmp.val = 1.0;
169 |         }else{
170 |             fscanf(f, "%d %d %f\n", &(tmp.row), &(tmp.col), &(tmp.val));
171 |         }
172 |         // std::cerr<<"row: " << tmp.row << " col: " << tmp.col  << " val: " << tmp.val << std::endl;
173 |         tmp.row -= 1;
174 |         tmp.col -= 1;
175 |         nzelems.push_back(tmp);
176 |         // add an element if symmetric - but not repeating the diagonal
177 |         if(sym && (tmp.row != tmp.col)){
178 |             int t = tmp.row;
179 |             tmp.row = tmp.col; tmp.col=t;
180 |             nzelems.push_back(tmp);
181 |         }
182 |         
183 |     }
184 |     // sort the nonzero elements
185 |     auto comparator = [](coord a, coord b){
186 |         if(a.row < b.row){
187 |             return true;
188 |         } else if(a.row > b.row){
189 |             return false;
190 |         } else {
191 |             if(a.col < b.col){
192 |                 return true;
193 |             }else{
194 |                 return false;
195 |             }
196 |         }
197 |     };
198 |     std::sort(nzelems.begin(), nzelems.end(), comparator);
199 | 
200 |     // allocate space in the matrix class
201 |     nnz = nzelems.size();
202 |     h = _h;
203 |     w = _w;
204 |     alloc();
205 | 
206 |     // add the nonzero elements
207 |     for(int i = 0;i<nnz;i++){
208 |         auto c = nzelems[i];
209 |         rowIndexHostPtr[i] = c.row;
210 |         colIndexHostPtr[i] = c.col;
211 |         valHostPtr[i] = c.val;
212 |     }
213 |     // print it
214 |     // print();
215 |     // set the iterator to 0, and the memstatus to device outdated
216 |     ixPtr = 0;
217 |     // assume we start with the device buffers outdated
218 |     mstatus = DeviceOutdated;
219 | }
220 | 
221 | cooMatrix::~cooMatrix() {
222 |     cleanup();
223 | }
224 | 
225 | void cooMatrix::push(int col, int row, float val){
226 |     if(!colIndexHostPtr || !rowIndexHostPtr || !valHostPtr){
227 |         std::cerr<<"Error: attemping to push elements before allocating."<<std::endl;
228 |     }
229 |     if(ixPtr >= nnz){
230 |         std::cerr<<"Error: allocating too many elements!"<<std::endl;
231 |         std::cerr<<"ixPtr: " << ixPtr << " >= "<< nnz << " (nnz) "<< std::endl;
232 |     }
233 |     // todo: add check that element is within bounds
234 |     rowIndexHostPtr[ixPtr] = row;
235 |     colIndexHostPtr[ixPtr] = col;
236 |     valHostPtr[ixPtr] = val;
237 |     ixPtr++;
238 | }
239 | 
240 | void cooMatrix::print() {
241 |     for (int i=0; i<nnz; i++){       
242 |         std::cerr<<"rowIndexHostPtr["<<i<<"] = "<< rowIndexHostPtr[i]<<"  ";
243 |         std::cerr<<"colIndexHostPtr["<<i<<"] = "<< colIndexHostPtr[i]<<"  ";
244 |         std::cerr<<"valHostPtr["<<i<<"] = "<<valHostPtr[i]<<std::endl;
245 |     }
246 | }
247 | 
248 | csrMatrix cooMatrix::asCSR(cusparseHandle_t handle) {
249 |     updateBuffers();
250 |     std::cerr<<"Building csrmatrix"<<std::endl;
251 |     // get a 
252 |     int * csrRowPtr = 0;
253 |     std::cerr<<"Allocating csr memory"<<std::endl;
254 | 
255 |     cudaError_t alloc_s = cudaMalloc((void**)&csrRowPtr,(h+1)*sizeof(int));
256 |     if(alloc_s != cudaSuccess) {
257 |         std::cerr<<"Device malloc failed before line "<<__LINE__<<" in "<<__FILE__<<std::endl;
258 | 
259 |         cleanup();
260 |         cudaFree(csrRowPtr);
261 |         exit(1);
262 |     }
263 |     std::cerr<<"Converting"<<std::endl;
264 | 
265 |     cusparseStatus_t convert_s = cusparseXcoo2csr(handle, rowIndexDevPtr, nnz, h,
266 |                                            csrRowPtr, CUSPARSE_INDEX_BASE_ZERO);
267 |     if(convert_s != CUSPARSE_STATUS_SUCCESS){
268 |         std::cerr<<"Conversion from COO to CSR format failed"<<std::endl;
269 |         cleanup();
270 |         exit(1);
271 |     }
272 | 
273 |     csrMatrix csr(nnz, h, w, csrRowPtr, colIndexDevPtr, valDevPtr);
274 |     return csr;
275 | }
276 | 
277 | // Private 
278 | 
279 | void cooMatrix::updateBuffers() {
280 |     if(mstatus == DeviceOutdated) {
281 |         std::cerr<<"Copying matrix to device"<<std::endl;
282 |         // copy from host to device
283 |         cudaError_t rowCopy = cudaMemcpy(rowIndexDevPtr, rowIndexHostPtr, 
284 |                                       (size_t)(nnz*sizeof(rowIndexHostPtr[0])),
285 |                                       cudaMemcpyHostToDevice);
286 |         cudaError_t colCopy = cudaMemcpy(colIndexDevPtr, colIndexHostPtr, 
287 |                                       (size_t)(nnz*sizeof(colIndexHostPtr[0])),
288 |                                       cudaMemcpyHostToDevice);
289 |         cudaError_t valCopy = cudaMemcpy(valDevPtr, valHostPtr, 
290 |                                       (size_t)(nnz*sizeof(valHostPtr[0])),
291 |                                       cudaMemcpyHostToDevice);
292 |         if((rowCopy != cudaSuccess) || 
293 |            (colCopy != cudaSuccess) || 
294 |            (valCopy != cudaSuccess)) {
295 |             std::cerr<<"Host to device copy failed before line "<<__LINE__<<" in "<<__FILE__<<std::endl;
296 |             cleanup();
297 |         }   
298 |     }else if(mstatus == HostOutdated) {
299 |         std::cerr<<"Copying matrix to host"<<std::endl;
300 |         // copy from device to host
301 |         cudaError_t rowCopy = cudaMemcpy(rowIndexHostPtr, rowIndexDevPtr, 
302 |                                       (size_t)(nnz*sizeof(rowIndexHostPtr[0])),
303 |                                       cudaMemcpyDeviceToHost);
304 |         cudaError_t colCopy = cudaMemcpy(colIndexHostPtr, colIndexDevPtr, 
305 |                                       (size_t)(nnz*sizeof(colIndexHostPtr[0])),
306 |                                       cudaMemcpyDeviceToHost);
307 |         cudaError_t valCopy = cudaMemcpy(valHostPtr, valDevPtr, 
308 |                                       (size_t)(nnz*sizeof(valHostPtr[0])),
309 |                                       cudaMemcpyDeviceToHost);
310 |         if((rowCopy != cudaSuccess) || 
311 |            (colCopy != cudaSuccess) || 
312 |            (valCopy != cudaSuccess)) {
313 |             std::cerr<<"Device to host copy failed before line "<<__LINE__<<" in "<<__FILE__<<std::endl;
314 |             cleanup();
315 |         }   
316 |     } 
317 |     mstatus = UpToDate;
318 | }
319 | 
320 | void cooMatrix::cleanup() {
321 |     // do something to make sure we can't use them later!
322 |     // free host pointers
323 |     delete[] colIndexHostPtr;
324 |     delete[] rowIndexHostPtr;
325 |     delete[] valHostPtr;
326 |     // free device pointers
327 |     if(rowIndexDevPtr) cudaFree(rowIndexDevPtr);
328 |     if(colIndexDevPtr) cudaFree(colIndexDevPtr);
329 |     if(valDevPtr) cudaFree(valDevPtr);
330 | }
331 | 
332 | void cooMatrix::alloc() {
333 |     // allocate on the host
334 |     rowIndexHostPtr = new int[nnz];
335 |     colIndexHostPtr = new int[nnz];
336 |     valHostPtr = new float[nnz];
337 |     // allocate ont the device
338 |     cudaError_t rowAlloc = cudaMalloc((void**)&rowIndexDevPtr, nnz*sizeof(int));
339 |     cudaError_t colAlloc = cudaMalloc((void**)&colIndexDevPtr, nnz*sizeof(int));
340 |     cudaError_t valAlloc = cudaMalloc((void**)&valDevPtr, nnz*sizeof(float));
341 |     // check for errors
342 |     if((rowAlloc != cudaSuccess) || 
343 |        (colAlloc != cudaSuccess) || 
344 |        (valAlloc != cudaSuccess)) {
345 |         std::cerr<<"Device malloc failed before line "<<__LINE__<<" in "<<__FILE__<<std::endl;
346 | 	std::cerr<<"rowAlloc: "<<cudaGetErrorString(rowAlloc)<<std::endl;
347 | 	std::cerr<<"colAlloc: "<<cudaGetErrorString(colAlloc)<<std::endl;
348 | 	std::cerr<<"valAlloc: "<<cudaGetErrorString(valAlloc)<<std::endl;
349 |         cleanup();
350 |     }
351 | }
352 | 
353 | // =============================================================================
354 | // ============================== Dense vector =================================
355 | // =============================================================================
356 | 
357 | // public
358 | 
359 | denseVector::denseVector(int _n){
360 |     n = _n;
361 |     // alloc on the host and device
362 |     hostPtr = new float[n];
363 |     cudaError_t alloc_s = cudaMalloc((void**)&devPtr, n*sizeof(float));
364 |     // check for errors
365 |     if((alloc_s != cudaSuccess)) {
366 |         std::cerr<<"Device malloc failed before line "<<__LINE__<<" in "<<__FILE__<<std::endl;
367 |         cleanup();
368 |     }
369 |     // assume we start with the device buffers outdated
370 |     mstatus = DeviceOutdated;
371 |     ixPtr = 0;
372 | }
373 | 
374 | denseVector::~denseVector(){
375 |     cleanup();
376 | }
377 | 
378 | denseVector & denseVector::operator= (const denseVector& other) {
379 |     if(this != &other) 
380 |     {
381 |         // delete our memory first, then reallocate
382 |         cleanup();
383 |         n = other.n;
384 |         ixPtr = 0;
385 |         mstatus = other.mstatus;
386 |         // allocate memory
387 |         hostPtr = new float[n];
388 |         cudaError_t alloc_s = cudaMalloc((void**)&devPtr, n*sizeof(float));
389 |         // check for errors
390 |         if((alloc_s != cudaSuccess)) {
391 |             std::cerr<<"Device malloc failed before line "<<__LINE__<<" in "<<__FILE__<<std::endl;
392 |             cleanup();
393 |         }
394 |         // copy over
395 |         std::copy(other.hostPtr, other.hostPtr + other.n, hostPtr);
396 |         cudaError_t mcopy = cudaMemcpy(devPtr, other.devPtr,
397 |                                     (size_t)(other.n*sizeof(other.hostPtr[0])),
398 |                                     cudaMemcpyDeviceToDevice);
399 |         if((mcopy != cudaSuccess)) {
400 |             std::cerr<<"Device to host copy failed before line "<<
401 |                 __LINE__<<" in "<<__FILE__<<std::endl;
402 |             cleanup();
403 |             exit(1);
404 |         }   
405 |     }
406 |     return *this;
407 | }
408 | 
409 | void denseVector::push(float value) {
410 |     if(!hostPtr){
411 |         std::cerr<<"Error: attemping to push elements before allocating."<<std::endl;
412 |     }
413 |     if(ixPtr >= n){
414 |         std::cerr<<"Error: allocating too many elements!"<<std::endl;
415 |     }
416 |     hostPtr[ixPtr] = value;
417 |     ixPtr++;
418 |     mstatus = DeviceOutdated;
419 | }
420 | 
421 | void denseVector::fill(float value) {
422 |     if(!hostPtr){
423 |         std::cerr<<"Error: attemping to push elements before allocating."<<std::endl;
424 |     }
425 |     // don't need to update host buffer - we're just about to overwrite it
426 |     for(int i = 0;i<n;i++){
427 |         hostPtr[i] = value;
428 |     }
429 |     mstatus = DeviceOutdated;
430 |     updateBuffers();
431 | }
432 | 
433 | void denseVector::fillRandom() {
434 |     if(!hostPtr){
435 |         std::cerr<<"Error: attemping to push elements before allocating."<<std::endl;
436 |     }
437 |       // c++ random number generation!
438 |     std::default_random_engine generator;
439 |     std::uniform_real_distribution<float> distribution(0.0, 1000.0);
440 |     auto rgen = std::bind(distribution, generator);
441 | 
442 |     // build the vector
443 |     for(int i = 0;i<n;i++){
444 |         hostPtr[i] = rgen();
445 |     }
446 |     mstatus = DeviceOutdated;
447 |     updateBuffers();
448 | }
449 | 
450 | void denseVector::print(){
451 |     updateBuffers();
452 |     std::cerr<<"[";
453 |     for(int i = 0;i<n;i++){
454 |         if(i == 0){
455 |             std::cerr<<hostPtr[i];
456 |         }else{
457 |             std::cerr<<","<<hostPtr[i];
458 |         }
459 |     }
460 |     std::cerr<<"]"<<std::endl;
461 | }
462 | 
463 | float* denseVector::getDevPtr(){
464 |     updateBuffers();
465 |     return devPtr;
466 | }
467 | 
468 | void denseVector::download() {
469 |     std::cerr<<"Downloading from the device"<<std::endl;
470 |     mstatus = HostOutdated;
471 |     updateBuffers();
472 | }
473 | 
474 | // private
475 | 
476 | void denseVector::cleanup(){
477 |     // do something to make sure we can't use them later!
478 |     // free host pointers
479 |     if(hostPtr){
480 |         delete[] hostPtr;
481 |         hostPtr = 0;
482 |     }
483 |     // free device pointers
484 |     if(devPtr) {
485 |         cudaFree(devPtr);
486 |         devPtr = 0;
487 |     }
488 | }
489 | 
490 | void denseVector::updateBuffers() {
491 |     if(mstatus == DeviceOutdated) {
492 |         std::cerr<<"Copying vector to device"<<std::endl;
493 |         // copy from host to device
494 |         cudaError_t mcopy = cudaMemcpy(devPtr, hostPtr, 
495 |                                       (size_t)(n*sizeof(hostPtr[0])),
496 |                                       cudaMemcpyHostToDevice);
497 |         if((mcopy != cudaSuccess)) {
498 |             std::cerr<<"Host to device copy failed before line "<<
499 |                 __LINE__<<" in "<<__FILE__<<std::endl;
500 |             cleanup();
501 |         }   
502 |     }else if(mstatus == HostOutdated) {
503 |         std::cerr<<"Copying vector to host"<<std::endl;
504 |         // copy from device to host
505 |         cudaError_t mcopy = cudaMemcpy(hostPtr, devPtr, 
506 |                                       (size_t)(n*sizeof(hostPtr[0])),
507 |                                       cudaMemcpyDeviceToHost);
508 |         if((mcopy != cudaSuccess)) {
509 |             std::cerr<<"Device to host copy failed before line "<<
510 |                 __LINE__<<" in "<<__FILE__<<std::endl;
511 |             cleanup();
512 |         }   
513 |     }
514 |     mstatus = UpToDate;
515 | }
516 | 


--------------------------------------------------------------------------------