Class DeviceSpMatCSR

XM/include/Utils/memory.h:581–666

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

        DeviceSpMatCSR(){}
        DeviceSpMatCSR(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_ids(nullptr), row_ptrs(nullptr), vals(nullptr), cusparse_descr(NULL) {
                this->allocate();
            }

        inline void allocate() {
            if (this->vals == nullptr) {
                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(T) * 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, CudaTypeMapper<T>::value
                ) );
            }
        }

        void SynchronizeHostToDevice(int* host_col_ids, int* host_row_ptrs, T* host_val){
            // always Synchronize to avoid read-write conflict
            CHECK_CUDA(cudaDeviceSynchronize());
            CHECK_CUDA(cudaMemcpyAsync(col_ids, host_col_ids, sizeof(int) * this->nnz, cudaMemcpyHostToDevice));
            CHECK_CUDA(cudaMemcpyAsync(row_ptrs, host_row_ptrs, sizeof(int) * (this->row_size+1), cudaMemcpyHostToDevice));
            CHECK_CUDA(cudaMemcpyAsync(vals, host_val, sizeof(T) * this->nnz, cudaMemcpyHostToDevice));
            CHECK_CUDA(cudaDeviceSynchronize());
        }

        void SynchronizeDeviceToDevice(int* device_col_ids, int* device_row_ptrs, T* device_val){
            // always Synchronize to avoid read-write conflict
            CHECK_CUDA(cudaDeviceSynchronize());
            CHECK_CUDA(cudaMemcpyAsync(col_ids, device_col_ids, sizeof(int) * this->nnz, cudaMemcpyDeviceToDevice));
            CHECK_CUDA(cudaMemcpyAsync(row_ptrs, device_row_ptrs, sizeof(int) * (this->row_size+1), cudaMemcpyDeviceToDevice));
            CHECK_CUDA(cudaMemcpyAsync(vals, device_val, sizeof(T) * this->nnz, cudaMemcpyDeviceToDevice));
            CHECK_CUDA(cudaDeviceSynchronize());
        }

        inline double get_norm(const DeviceBlasHandle& cublas_H) {
            double norm;