Class DeviceSpMatCOO

XM/include/Utils/memory.h:670–748

//sparse matrix wrapper on device: COO format
template <typename T>
class DeviceSpMatCOO {
    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_ids = nullptr;
        T* vals = nullptr; 
        cusparseSpMatDescr_t cusparse_descr = nullptr;

        DeviceSpMatCOO(){}
        DeviceSpMatCOO(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_ids(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) );
                
                if (nnz > 0) {
                    CHECK_CUDA( cudaMalloc((void**) &this->row_ids, sizeof(int) * this->nnz) );
                    CHECK_CUDA( cudaMalloc((void**) &this->col_ids, sizeof(int) * this->nnz) );
                    CHECK_CUDA( cudaMalloc((void**) &this->vals, sizeof(T) * this->nnz) );
                } else {
                    this->row_ids = nullptr;
                    this->col_ids = nullptr;
                    this->vals = nullptr;
                }
                CHECK_CUSPARSE( cusparseCreateCoo(
                    &this->cusparse_descr, this->row_size, this->col_size, this->nnz,
                    this->row_ids, this->col_ids, this->vals,
                    CUSPARSE_INDEX_32I, CUSPARSE_INDEX_BASE_ZERO, CudaTypeMapper<T>::value
                ) );
            }
        }

        void SynchronizeHostToDevice(int* host_col_ids, int* host_row_ids, 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_ids, host_row_ids, sizeof(int) * this->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;
        }