More tests, better errors, more exclusions for CUSPARSE

Author: kshyatt

lib/cusparse/conversions.jl

@@ -23,7 +23,7 @@ function SparseArrays.sparse(x::DenseCuMatrix; fmt=:csc)
     elseif fmt == :coo
         return CuSparseMatrixCOO(x)
     else
-        error("Format :$fmt not available, use :csc, :csr, :bsr or :coo.")
+        throw(ArgumentError("Format :$fmt not available, use :csc, :csr, :bsr or :coo."))
     end
 end
 
@@ -42,6 +42,7 @@ function SparseArrays.sparse(I::CuVector{Cint}, J::CuVector{Cint}, V::CuVector{T
     # otherwise, it will contain gaps of zeros that indicates duplicate values.
     coo = sort_coo(coo, 'R')
     groups = similar(I, Int)
+    # COV_EXCL_START
     function find_groups(groups, I, J)
         i = threadIdx().x + (blockIdx().x - 1) * blockDim().x
         if i > length(groups)
@@ -54,6 +55,7 @@ function SparseArrays.sparse(I::CuVector{Cint}, J::CuVector{Cint}, V::CuVector{T
 
         return
     end
+    # COV_EXCL_STOP
     kernel = @cuda launch=false find_groups(groups, coo.rowInd, coo.colInd)
     config = launch_configuration(kernel.fun)
     threads = min(length(groups), config.threads)
@@ -83,6 +85,7 @@ function SparseArrays.sparse(I::CuVector{Cint}, J::CuVector{Cint}, V::CuVector{T
 
         # use one thread per (old) value, and if it's at the start of a group,
         # combine (if needed) all values and update the output vectors.
+        # COV_EXCL_START
         function combine_groups(groups, indices, oldI, oldJ, oldV, newI, newJ, newV, combine)
             i = threadIdx().x + (blockIdx().x - 1) * blockDim().x
             if i > length(groups)
@@ -107,6 +110,7 @@ function SparseArrays.sparse(I::CuVector{Cint}, J::CuVector{Cint}, V::CuVector{T
 
             return
         end
+        # COV_EXCL_STOP
         kernel = @cuda launch=false combine_groups(groups, indices, coo.rowInd, coo.colInd, coo.nzVal, I, J, V, combine)
         config = launch_configuration(kernel.fun)
         threads = min(length(groups), config.threads)
@@ -123,7 +127,7 @@ function SparseArrays.sparse(I::CuVector{Cint}, J::CuVector{Cint}, V::CuVector{T
     elseif fmt == :csr
         return CuSparseMatrixCSR(coo)
     else
-        error("Format :$fmt not available, use :csc, :csr, or :coo.")
+        throw(ArgumentError("Format :$fmt not available, use :csc, :csr, or :coo."))
     end
 end
 

lib/cusparse/linalg.jl

@@ -7,7 +7,7 @@ function LinearAlgebra.opnorm(A::CuSparseMatrixCSR, p::Real=2)
     elseif p == 1
         return maximum(sum(abs, A; dims=1))
     else
-        error("p=$p is not supported")
+        throw(ArgumentError("p=$p is not supported"))
     end
 end
 

test/libraries/cusparse.jl

@@ -20,12 +20,14 @@ blockdim = 5
     @test size(d_x,1) == m
     @test size(d_x,2) == 1
     @test ndims(d_x)  == 1
+    dense_d_x = CuVector(x)
     CUDA.@allowscalar begin
         @test Array(d_x[:])        == x[:]
         @test d_x[firstindex(d_x)] == x[firstindex(x)]
         @test d_x[div(end, 2)]     == x[div(end, 2)]
         @test d_x[end]             == x[end]
         @test Array(d_x[firstindex(d_x):end]) == x[firstindex(x):end]
+        @test Array(dense_d_x[firstindex(d_x):end]) == x[firstindex(x):end]
     end
     @test_throws BoundsError d_x[firstindex(d_x) - 1]
     @test_throws BoundsError d_x[end + 1]
@@ -1232,3 +1234,17 @@ end
     @test convert(CUSPARSE.cusparseSpSMUpdate_t, CUSPARSE.SparseChar('D')) == CUSPARSE.CUSPARSE_SPSV_UPDATE_DIAGONAL
     @test_throws ArgumentError("Unknown update X") convert(CUSPARSE.cusparseSpSMUpdate_t, CUSPARSE.SparseChar('X'))
 end
+
+@testset "CuSparseArrayCSR" begin
+    x = sprand(n, m, 0.2)
+    d_x = CuSparseArrayCSR(CuArray(x.colptr), CuArray(x.rowval), CuArray(x.nzval), (m, n))
+    @test d_x isa CuSparseArrayCSR
+    @test length(d_x) == m*n
+    @test CuSparseArrayCSR(d_x) === d_x
+    @test size(similar(d_x)) == size(d_x)
+    @test size(d_x, 3) == 1
+    @test_throws ArgumentError("dimension must be ≥ 1, got 0") size(d_x, 0)
+    CUDA.@allowscalar begin
+        @test d_x[1, 2] == x[2, 1]
+    end
+end

test/libraries/cusparse/conversions.jl

@@ -37,6 +37,8 @@ using CUDA
             @test collect(x) == collect(dense)
         end
     end
+    @test_throws ArgumentError("Format :bad not available, use :csc, :csr, :bsr or :coo.") sparse(dense; fmt=:bad)
+    @test_throws ArgumentError("Format :bad not available, use :csc, :csr, or :coo.") sparse(I, J, V; fmt=:bad)
 end
 
 @testset "unsorted sparse (CUDA.jl#1407)" begin
@@ -121,6 +123,19 @@ for (n, bd, p) in [(100, 5, 0.02), (5, 1, 0.8), (4, 2, 0.5)]
     end
 end
 
+for (n, p) in [(100, 0.02), (5, 0.8), (4, 0.5)]
+    v"12.0" <= CUSPARSE.version() < v"12.1" && n == 4 && continue
+    @testset "conversions between CuSparseMatrices (n, p) = ($n, $p)" begin
+        A = sprand(n, n, p)
+        for CuSparseMatrixType1 in (CuSparseMatrixCSC, CuSparseMatrixCSR), CuSparseMatrixType2 in (CuSparseMatrixCSC, CuSparseMatrixCSR), op in (transpose, adjoint)
+            dA1 = CuSparseMatrixType1(A)
+            @testset "conversion $op($CuSparseMatrixType1) --> $CuSparseMatrixType2" begin
+                @test collect(CuSparseMatrixType2(op(dA1))) ≈ op(A)
+            end
+        end
+    end
+end
+
 @testset "sort CuSparseMatrix" begin
     #     [5 7 0]
     # A = [8 0 6]

test/libraries/cusparse/linalg.jl

@@ -9,6 +9,7 @@ using LinearAlgebra, SparseArrays
     @test opnorm(S, Inf) ≈ opnorm(dS_csr, Inf)
     @test opnorm(S, 1) ≈ opnorm(dS_csc, 1)
     @test opnorm(S, 1) ≈ opnorm(dS_csr, 1)
+    @test_throws ArgumentError("p=2 is not supported") opnorm(dS_csr, 2)
     @test norm(S, 0) ≈ norm(dS_csc, 0)
     @test norm(S, 0) ≈ norm(dS_csr, 0)
     @test norm(S, 1) ≈ norm(dS_csc, 1)
@@ -80,4 +81,4 @@ end
     A2 = typ(A)
 
     @test dot(x, A, y) ≈ dot(x2, A2, y2)
-end
+end