Class DeviceSpMatDoubleCSR

XM/include/Utils/memory.h:1212–1285

sparse vector wrapper on device: double type + CSR format

// sparse vector wrapper on device: double type + CSR format
class DeviceSpMatDoubleCSR {
    public:
        int gpu_id;
        int64_t row_size; 
        int64_t col_size;
        int64_t nnz;
        int* row_ptrs;
        int* col_ids;
        double* vals; 
        cusparseSpMatDescr_t cusparse_descr;

        DeviceSpMatDoubleCSR(): gpu_id(0), row_size(0), col_size(0), nnz(0),
            row_ptrs(nullptr), col_ids(nullptr), vals(nullptr), cusparse_descr(NULL) {}
        DeviceSpMatDoubleCSR(const int gpu_id, const int row_size, const int col_size, const int nnz):
            gpu_id(gpu_id), row_size(row_size), col_size(col_size), nnz(nnz),
            row_ptrs(nullptr), col_ids(nullptr), vals(nullptr), cusparse_descr(NULL) {
                this->allocate(gpu_id, row_size, col_size, nnz);
            }

        inline void allocate(const int gpu_id, const int row_size, const int col_size, const int nnz) {
            if (this->vals == nullptr) {
                this->gpu_id = gpu_id;
                this->row_size = row_size;
                this->col_size = col_size;
                this->nnz = nnz;
                CHECK_CUDA( cudaSetDevice(this->gpu_id) );
                CHECK_CUDA( cudaSetDevice(this->gpu_id) );
                CHECK_CUDA( cudaMalloc((void**) &this->row_ptrs, sizeof(int) * (this->row_size + 1)) );
                if (nnz > 0) {
                    CHECK_CUDA( cudaMalloc((void**) &this->col_ids, sizeof(int) * this->nnz) );
                    CHECK_CUDA( cudaMalloc((void**) &this->vals, sizeof(double) * this->nnz) );
                } else {
                    this->col_ids = nullptr;
                    this->vals = nullptr;
                }
                CHECK_CUSPARSE( cusparseCreateCsr(
                    &this->cusparse_descr, this->row_size, this->col_size, this->nnz,
                    this->row_ptrs, this->col_ids, this->vals,
                    CUSPARSE_INDEX_32I, CUSPARSE_INDEX_32I, CUSPARSE_INDEX_BASE_ZERO, CUDA_R_64F
                ) );
            }
            return;
        }

        inline double get_norm(const DeviceBlasHandle& cublas_H) {
            double norm;
            CHECK_CUDA( cudaSetDevice(this->gpu_id) );
            CHECK_CUBLAS( cublasDnrm2_v2(
                cublas_H.cublas_handle, this->nnz, this->vals, 1, &norm
            ) );
            return norm;
        }

        ~DeviceSpMatDoubleCSR() {
            CHECK_CUDA( cudaSetDevice(this->gpu_id) );
            if (this->row_ptrs != nullptr) {
                CHECK_CUDA( cudaFree(this->row_ptrs) );
                this->row_ptrs = nullptr;