Merge pull request #2079 from JuliaGPU/tb/tests

maleadt · web-flow · commit fa5c389f9252 · 2023-09-12T17:08:01.000+02:00
Test improvements
diff --git a/Manifest.toml b/Manifest.toml
@@ -2,7 +2,7 @@
 
 julia_version = "1.8.5"
 manifest_format = "2.0"
-project_hash = "668ed29932abfaac250cb6c23a1bfa769a4b4fcf"
+project_hash = "bd7ca8996e1ea58c0718ac9f8390b825e95848f9"
 
 [[deps.AbstractFFTs]]
 deps = ["ChainRulesCore", "LinearAlgebra", "Test"]
@@ -158,9 +158,9 @@ version = "0.1.5"
 
 [[deps.GPUCompiler]]
 deps = ["ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "Scratch", "TimerOutputs", "UUIDs"]
-git-tree-sha1 = "8573c39f9c4e99720ab5ea44104efb3ed07a58b0"
+git-tree-sha1 = "e5e0f07db5c325860b21cadeb6e4271b0ff364c5"
 uuid = "61eb1bfa-7361-4325-ad38-22787b887f55"
-version = "0.23.0"
+version = "0.24.1"
 
 [[deps.InlineStrings]]
 deps = ["Parsers"]
diff --git a/Project.toml b/Project.toml
@@ -52,7 +52,7 @@ Crayons = "4"
 DataFrames = "1"
 ExprTools = "0.1"
 GPUArrays = "9"
-GPUCompiler = "0.23"
+GPUCompiler = "0.24"
 KernelAbstractions = "0.9.2"
 LLVM = "6"
 NVTX = "0.3.2"
diff --git a/lib/cudadrv/error.jl b/lib/cudadrv/error.jl
@@ -3,18 +3,38 @@
 export CuError
 
 
+# an optional struct, used to represent e.g. optional error logs.
+# this is to make CuErrors with/without additional logs compare equal
+# (so that we can simply reuse `@test_throws CuError(code)`).
+struct Optional{T}
+    data::Union{Nothing,T}
+    Optional{T}(data::Union{Nothing,T}=nothing) where {T} = new{T}(data)
+end
+Base.getindex(s::Optional) = s.data
+function Base.isequal(a::Optional, b::Optional)
+    if a.data === nothing || b.data === nothing
+        return true
+    else
+        return isequal(a.data, b.data)
+    end
+end
+Base.convert(::Type{Optional{T}}, ::Nothing) where T = Optional{T}()
+Base.convert(::Type{Optional{T}}, x) where T = Optional{T}(convert(T, x))
+Base.convert(::Type{Optional{T}}, x::Optional) where T = convert(Optional{T}, x[])
+
+
 """
     CuError(code)
-    CuError(code, meta)
+    CuError(code, details)
 
-Create a CUDA error object with error code `code`. The optional `meta` parameter indicates
-whether extra information, such as error logs, is known.
+Create a CUDA error object with error code `code`. The optional `details` parameter
+indicates whether extra information, such as error logs, is known.
 """
 struct CuError <: Exception
     code::CUresult
-    meta::Any
+    details::Optional{String}
 
-    CuError(code, meta=nothing) = new(code, meta)
+    CuError(code, details=nothing) = new(code, details)
 end
 
 Base.convert(::Type{CUresult}, err::CuError) = err.code
@@ -63,9 +83,9 @@ function Base.showerror(io::IO, err::CuError)
         print(io, "CUDA error: $(description(err)) (code $(reinterpret(Int32, err.code)), $(name(err)))")
     end
 
-    if err.meta !== nothing
+    if err.details[] !== nothing
         print(io, "\n")
-        print(io, err.meta)
+        print(io, err.details[])
     end
 end
 
diff --git a/lib/cudadrv/state.jl b/lib/cudadrv/state.jl
@@ -470,7 +470,7 @@ function Base.get(x::PerDevice, dev::CuDevice, val)
     end
 end
 
-function Base.get!(constructor::F, x::PerDevice{T}, dev::CuDevice) where {F, T}
+function Base.get!(constructor::F, x::PerDevice{T}, dev::CuDevice) where {F <: Base.Callable, T}
     y = get_values(x)
     id = deviceid(dev)+1
     ctx = device_context(id)    # may be nothing
diff --git a/lib/cudadrv/synchronization.jl b/lib/cudadrv/synchronization.jl
@@ -43,7 +43,7 @@ function Base.put!(c::BidirectionalChannel{T}, v::T) where T
     end
 end
 
-function Base.take!(f, c::BidirectionalChannel{T}) where T
+function Base.take!(f::Base.Callable, c::BidirectionalChannel{T}) where T
     lock(c)
     try
         # notify the producer that we're ready to accept a value
diff --git a/lib/utils/threading.jl b/lib/utils/threading.jl
@@ -23,7 +23,7 @@ end
 LazyInitialized{T}(validator=nothing) where {T} =
     LazyInitialized{T,typeof(validator)}(Threads.Atomic{Int}(0), Ref{T}(), validator)
 
-@inline function Base.get!(constructor, x::LazyInitialized)
+@inline function Base.get!(constructor::Base.Callable, x::LazyInitialized)
     while x.guard[] != 2
         initialize!(x, constructor)
     end
diff --git a/src/device/texture.jl b/src/device/texture.jl
@@ -56,11 +56,15 @@ end
 Base.Tuple(x::Vec4) = tuple(x.a, x.b, x.c, x.d)
 
 for (dispatch_rettyp, julia_rettyp, llvm_rettyp) in
-        ((:Signed,        :(Vec4{UInt32}),  :v4u32),
-         (:Unsigned,      :(Vec4{Int32}),   :v4s32),
+        ((:Signed,        :(Vec4{Int32}),   :v4u32),
+         (:Unsigned,      :(Vec4{UInt32}),  :v4s32),
          (:AbstractFloat, :(Vec4{Float32}), :v4f32))
 
-    eltyp = :(Union{$dispatch_rettyp, NTuple{<:Any,$dispatch_rettyp}})
+    eltyp = :(Union{$dispatch_rettyp,
+                    NTuple{1,$dispatch_rettyp},
+                    NTuple{2,$dispatch_rettyp},
+                    NTuple{3,$dispatch_rettyp},
+                    NTuple{4,$dispatch_rettyp}})
 
     # tex1D only supports array memory
     @eval tex(texObject::CuDeviceTexture{<:$eltyp,1,ArrayMemory}, x::Number) =
@@ -74,7 +78,7 @@ for (dispatch_rettyp, julia_rettyp, llvm_rettyp) in
         julia_sig = ntuple(_->Float32, dims)
         julia_params = ntuple(i->:($(julia_args[i])::Number), dims)
 
-        @eval tex(texObject::CuDeviceTexture{<:$eltyp,$dims,}, $(julia_params...)) =
+        @eval tex(texObject::CuDeviceTexture{<:$eltyp,$dims}, $(julia_params...)) =
             Tuple(ccall($("llvm.nvvm.tex.unified.$llvm_dim.$llvm_rettyp.f32"), llvmcall,
                         $julia_rettyp, (CUtexObject, $(julia_sig...)), texObject, $(julia_args...)))
     end
diff --git a/test/base/aqua.jl b/test/base/aqua.jl
@@ -9,7 +9,7 @@ let ambs = Aqua.detect_ambiguities(CUDA; recursive=true)
     pkg_match(pkgname, pkgdir::Nothing) = false
     pkg_match(pkgname, pkgdir::AbstractString) = occursin(pkgname, pkgdir)
     filter!(x -> pkg_match("CUDA", pkgdir(last(x).module)), ambs)
-    @test length(ambs) ≤ 51
+    @test length(ambs) ≤ 18
 end
 
 Aqua.test_undefined_exports(CUDA)
diff --git a/test/core/cudadrv.jl b/test/core/cudadrv.jl
@@ -705,7 +705,7 @@ let
     @test md != md2
 end
 
-@test_throws_cuerror CUDA.ERROR_INVALID_IMAGE CuModule("foobar")
+@test_throws CuError(CUDA.ERROR_INVALID_IMAGE) CuModule("foobar")
 
 @testset "globals" begin
     md = CuModuleFile(joinpath(@__DIR__, "ptx/global.ptx"))
@@ -735,7 +735,7 @@ end
     # TODO: test with valid object code
     # NOTE: apparently, on Windows cuLinkAddData! _does_ accept object data containing \0
     if !Sys.iswindows()
-        @test_throws_cuerror CUDA.ERROR_UNKNOWN add_data!(link, "vadd_parent", UInt8[0])
+        @test_throws CuError(CUDA.ERROR_UNKNOWN) add_data!(link, "vadd_parent", UInt8[0])
     end
 end
 
@@ -744,10 +744,12 @@ end
         .version 3.1
         .target sm_999
         .address_size 64"""
-    @test_throws_message contains("ptxas fatal") CuError CuModule(invalid_code)
+    @test_throws CuError(CUDA.ERROR_INVALID_PTX) CuModule(invalid_code)
+    @test_throws "ptxas fatal"                   CuModule(invalid_code)
 
     link = CuLink()
-    @test_throws_message contains("ptxas fatal") CuError add_data!(link, "dummy", invalid_code)
+    @test_throws CuError(CUDA.ERROR_INVALID_PTX) add_data!(link, "dummy", invalid_code)
+    @test_throws                                 "ptxas fatal" add_data!(link, "dummy", invalid_code)
 end
 
 let
diff --git a/test/core/execution.jl b/test/core/execution.jl
@@ -88,8 +88,8 @@ end
     # make sure invalid kernels can be partially reflected upon
     let
         invalid_kernel() = throw()
-        @test_throws CUDA.KernelError @cuda invalid_kernel()
-        @test_throws CUDA.KernelError @grab_output @device_code_warntype @cuda invalid_kernel()
+        @test_throws CUDA.InvalidIRError @cuda invalid_kernel()
+        @test_throws CUDA.InvalidIRError @grab_output @device_code_warntype @cuda invalid_kernel()
         out, err = @grab_output begin
             try
                 @device_code_warntype @cuda invalid_kernel()
diff --git a/test/core/utils.jl b/test/core/utils.jl
@@ -1,26 +1,6 @@
 using BFloat16s: BFloat16
 import CUDA: cudaDataType
 
-@testset "test utilities" begin
-    mutable struct NoThrowTestSet <: Test.AbstractTestSet
-        results::Vector
-        NoThrowTestSet(desc) = new([])
-    end
-    Test.record(ts::NoThrowTestSet, t::Test.Result) = (push!(ts.results, t); t)
-    Test.finish(ts::NoThrowTestSet) = ts.results
-    fails = @testset NoThrowTestSet begin
-        # OK
-        @test_throws_cuerror CUDA.ERROR_UNKNOWN throw(CuError(CUDA.ERROR_UNKNOWN))
-        # Fail, wrong CuError
-        @test_throws_cuerror CUDA.ERROR_UNKNOWN throw(CuError(CUDA.ERROR_INVALID_VALUE))
-        # Fail, wrong Exception
-        @test_throws_cuerror CUDA.ERROR_UNKNOWN error()
-    end
-    @test isa(fails[1], Test.Pass)
-    @test isa(fails[2], Test.Fail)
-    @test isa(fails[3], Test.Fail)
-end
-
 @testset "@sync" begin
   t = Base.@elapsed ret = CUDA.@sync begin
     # TODO: do something that takes a while on the GPU
diff --git a/test/libraries/cusolver/sparse.jl b/test/libraries/cusolver/sparse.jl
@@ -126,7 +126,7 @@ end
         tol   = 10^2*eps(real(elty))
         d_x   = CUSOLVER.csrlsvchol!(d_A,d_b,d_x,tol,zero(Cint),'O')
         h_x   = collect(d_x)
-        @test_maybe_broken h_x ≈ Array(A)\b
+        @test h_x ≈ Array(A)\b
         b     = rand(elty,m)
         d_b   = CuArray(b)
         @test_throws DimensionMismatch CUSOLVER.csrlsvchol!(d_A,d_b,d_x,tol,zero(Cint),'O')
diff --git a/test/setup.jl b/test/setup.jl
@@ -136,45 +136,6 @@ macro grab_output(ex)
     end
 end
 
-# variant on @test_throws that checks the CuError error code
-macro test_throws_cuerror(code, ex)
-    # generate a test only returning CuError if it is the correct one
-    test = quote
-        try
-            $(esc(ex))
-        catch err
-            isa(err, CuError) || rethrow()
-            err.code == $code || error("Wrong CuError: ", err.code, " instead of ", $code)
-            rethrow()
-        end
-    end
-
-    # now re-use @test_throws (which ties into @testset, etc)
-    quote
-        @test_throws CuError $test
-    end
-end
-
-# @test_throw, with additional testing for the exception message
-macro test_throws_message(f, typ, ex...)
-    @gensym msg
-    quote
-        $msg = ""
-        @test_throws $(esc(typ)) try
-            $(esc(ex...))
-        catch err
-            $msg = sprint(showerror, err)
-            rethrow()
-        end
-
-        if !$(esc(f))($msg)
-            # @test should return its result, but doesn't
-            @error "Failed to validate error message\n" * $msg
-        end
-        @test $(esc(f))($msg)
-    end
-end
-
 # Run some code on-device
 macro on_device(ex...)
     code = ex[end]
@@ -219,24 +180,4 @@ function julia_exec(args::Cmd, env...)
     proc, read(out, String), read(err, String)
 end
 
-# some tests are mysteriously broken with certain hardware/software.
-# use a horrible macro to mark those tests as "potentially broken"
-@eval Test begin
-    export @test_maybe_broken
-
-    macro test_maybe_broken(ex, kws...)
-        test_expr!("@test_maybe_broken", ex, kws...)
-        orig_ex = Expr(:inert, ex)
-        result = get_test_result(ex, __source__)
-        quote
-            x = $result
-            if x.value
-                do_test(x, $orig_ex)
-            else
-                do_broken_test(x, $orig_ex)
-            end
-        end
-    end
-end
-
 nothing # File is loaded via a remotecall to "include". Ensure it returns "nothing".
