Put random functionality in own source and test file.

Author: maleadt

src/CUDA.jl

@@ -57,6 +57,7 @@ include("device/intrinsics.jl")
 include("device/llvm.jl")
 include("device/runtime.jl")
 include("device/texture.jl")
+include("device/random.jl")
 
 # array essentials
 include("pool.jl")

src/device/intrinsics.jl

@@ -41,7 +41,6 @@ include("intrinsics/memory_dynamic.jl")
 include("intrinsics/atomics.jl")
 include("intrinsics/misc.jl")
 include("intrinsics/wmma.jl")
-include("intrinsics/random.jl")
 
 # functionality from libdevice
 #

src/device/intrinsics/random.jl src/device/random.jlsrc/device/intrinsics/random.jl renamed to src/device/random.jl

@@ -1180,93 +1180,3 @@ end
 end
 
 end
-
-
-
-############################################################################################
-
-using Random
-
-@testset "random numbers" begin
-
-n = 256
-
-@testset "basic rand($T), seed $seed" for T in (Int32, UInt32, Int64, UInt64, Int128, UInt128,
-                                                Float32, Float64),
-                                          seed in (nothing, #=missing,=# 1234)
-
-    function apply_seed(seed)
-        if seed === missing
-            # should result in different numbers across launches
-            Random.seed!()
-            # XXX: this currently doesn't work, because of the definition in Base,
-            #      `seed!(r::MersenneTwister=default_rng())`, which breaks overriding
-            #      `default_rng` with a non-MersenneTwister RNG.
-        elseif seed !== nothing
-            # should result in the same numbers
-            Random.seed!(seed)
-        elseif seed === nothing
-            # should result in different numbers across launches,
-            # as determined by the seed set during module loading.
-        end
-    end
-
-    # different kernel invocations should get different numbers
-    @testset "across launches" begin
-        function kernel(A::AbstractArray{T}, seed) where {T}
-            apply_seed(seed)
-            tid = threadIdx().x
-            A[tid] = rand(T)
-            return nothing
-        end
-
-        a = CUDA.zeros(T, n)
-        b = CUDA.zeros(T, n)
-
-        @cuda threads=n kernel(a, seed)
-        @cuda threads=n kernel(b, seed)
-
-        if seed === nothing || seed === missing
-            @test all(Array(a) .!= Array(b))
-        else
-            @test Array(a) == Array(b)
-        end
-    end
-
-    # multiple calls to rand should get different numbers
-    @testset "across calls" begin
-        function kernel(A::AbstractArray{T}, B::AbstractArray{T}, seed) where {T}
-            apply_seed(seed)
-            tid = threadIdx().x
-            A[tid] = rand(T)
-            B[tid] = rand(T)
-            return nothing
-        end
-
-        a = CUDA.zeros(T, n)
-        b = CUDA.zeros(T, n)
-
-        @cuda threads=n kernel(a, b, seed)
-
-        @test all(Array(a) .!= Array(b))
-    end
-
-    # different threads should get different numbers
-    @testset "across threads" for active_dim in 1:6
-        function kernel(A::AbstractArray{T}, seed) where {T}
-            apply_seed(seed)
-            id = threadIdx().x*threadIdx().y*threadIdx().z*blockIdx().x*blockIdx().y*blockIdx().z
-            A[id] = rand(T)
-            return nothing
-        end
-
-        tx, ty, tz, bx, by, bz = [dim == active_dim ? 2 : 1 for dim in 1:6]
-        a = CUDA.zeros(T, 2)
-
-        @cuda threads=(tx, ty, tz) blocks=(bx, by, bz) kernel(a, seed)
-
-        @test Array(a)[1] != Array(a)[2]
-    end
-end
-
-end

test/device/intrinsics.jl

@@ -0,0 +1,81 @@
+using Random
+
+n = 256
+
+@testset "basic rand($T), seed $seed" for T in (Int32, UInt32, Int64, UInt64, Int128, UInt128,
+                                                Float32, Float64),
+                                          seed in (nothing, #=missing,=# 1234)
+
+    function apply_seed(seed)
+        if seed === missing
+            # should result in different numbers across launches
+            Random.seed!()
+            # XXX: this currently doesn't work, because of the definition in Base,
+            #      `seed!(r::MersenneTwister=default_rng())`, which breaks overriding
+            #      `default_rng` with a non-MersenneTwister RNG.
+        elseif seed !== nothing
+            # should result in the same numbers
+            Random.seed!(seed)
+        elseif seed === nothing
+            # should result in different numbers across launches,
+            # as determined by the seed set during module loading.
+        end
+    end
+
+    # different kernel invocations should get different numbers
+    @testset "across launches" begin
+        function kernel(A::AbstractArray{T}, seed) where {T}
+            apply_seed(seed)
+            tid = threadIdx().x
+            A[tid] = rand(T)
+            return nothing
+        end
+
+        a = CUDA.zeros(T, n)
+        b = CUDA.zeros(T, n)
+
+        @cuda threads=n kernel(a, seed)
+        @cuda threads=n kernel(b, seed)
+
+        if seed === nothing || seed === missing
+            @test all(Array(a) .!= Array(b))
+        else
+            @test Array(a) == Array(b)
+        end
+    end
+
+    # multiple calls to rand should get different numbers
+    @testset "across calls" begin
+        function kernel(A::AbstractArray{T}, B::AbstractArray{T}, seed) where {T}
+            apply_seed(seed)
+            tid = threadIdx().x
+            A[tid] = rand(T)
+            B[tid] = rand(T)
+            return nothing
+        end
+
+        a = CUDA.zeros(T, n)
+        b = CUDA.zeros(T, n)
+
+        @cuda threads=n kernel(a, b, seed)
+
+        @test all(Array(a) .!= Array(b))
+    end
+
+    # different threads should get different numbers
+    @testset "across threads" for active_dim in 1:6
+        function kernel(A::AbstractArray{T}, seed) where {T}
+            apply_seed(seed)
+            id = threadIdx().x*threadIdx().y*threadIdx().z*blockIdx().x*blockIdx().y*blockIdx().z
+            A[id] = rand(T)
+            return nothing
+        end
+
+        tx, ty, tz, bx, by, bz = [dim == active_dim ? 2 : 1 for dim in 1:6]
+        a = CUDA.zeros(T, 2)
+
+        @cuda threads=(tx, ty, tz) blocks=(bx, by, bz) kernel(a, seed)
+
+        @test Array(a)[1] != Array(a)[2]
+    end
+end

test/device/random.jl

@@ -171,6 +171,9 @@ if Sys.ARCH == :aarch64
     # CUFFT segfaults on ARM
     push!(skip_tests, "cufft")
 end
+if VERSION < v"1.6.1-"
+    push!(skip_tests, "device/random")
+end
 for (i, test) in enumerate(skip_tests)
     # we find tests by scanning the file system, so make sure the path separator matches
     skip_tests[i] = replace(test, '/'=>Base.Filesystem.path_separator)