Class DeviceSpMatCSC

XM/include/Utils/memory.h:506–577

//sparse matrix wrapper on device: CSC format
template <typename T>
class DeviceSpMatCSC {
    public:
        size_s gpu_id = 0;
        size_s row_size = 0; 
        size_s col_size = 0;
        size_l nnz = 0;
        int* col_ptrs = nullptr;
        int* row_ids = nullptr;
        T* vals = nullptr; 
        cusparseSpMatDescr_t cusparse_descr = nullptr;

        DeviceSpMatCSC(){}
        DeviceSpMatCSC(const size_s gpu_id, const size_s row_size, const size_s col_size, const size_l nnz):
            gpu_id(gpu_id), row_size(row_size), col_size(col_size), nnz(nnz),
            col_ptrs(nullptr), row_ids(nullptr), vals(nullptr), cusparse_descr(NULL) {
                this->allocate();
            }

        inline void allocate() {
            if (this->vals == nullptr) {
                CHECK_CUDA( cudaSetDevice(this->gpu_id) );
                CHECK_CUDA( cudaMalloc((void**) &this->col_ptrs, sizeof(int) * (this->col_size + 1)) );
                CHECK_CUDA( cudaMalloc((void**) &this->row_ids, sizeof(int) * this->nnz) );
                CHECK_CUDA( cudaMalloc((void**) &this->vals, sizeof(T) * this->nnz) );
                CHECK_CUSPARSE( cusparseCreateCsc(
                    &this->cusparse_descr, this->row_size, this->col_size, this->nnz,
                    this->col_ptrs, this->row_ids, this->vals,
                    CUSPARSE_INDEX_32I, CUSPARSE_INDEX_32I, CUSPARSE_INDEX_BASE_ZERO, CudaTypeMapper<T>::value
                ) );
            }
            return;
        }

        void SynchronizeHostToDevice(int* host_col_ptrs, int* host_row_ids, T* host_val){
        // always Synchronize to avoid read-write conflict
        CHECK_CUDA(cudaDeviceSynchronize());
        CHECK_CUDA(cudaMemcpyAsync(col_ptrs, host_col_ptrs, sizeof(int) * (col_size + 1), cudaMemcpyHostToDevice));
        CHECK_CUDA(cudaMemcpyAsync(row_ids, host_row_ids, sizeof(int) * nnz, cudaMemcpyHostToDevice));
        CHECK_CUDA(cudaMemcpyAsync(vals, host_val, sizeof(T) * nnz, cudaMemcpyHostToDevice));
        CHECK_CUDA(cudaDeviceSynchronize());
    }

        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;
        }

        ~DeviceSpMatCSC() {
            CHECK_CUDA( cudaSetDevice(this->gpu_id) );
            if (this->col_ptrs != nullptr) {
                CHECK_CUDA( cudaFree(this->col_ptrs) );
                this->col_ptrs = nullptr;
            }
            if (this->row_ids != nullptr) {