Don't call rand without RNG, and add Float16 support.

Author: maleadt

src/host/random.jl

@@ -16,6 +16,8 @@ LCGStep(z::Unsigned, A::Unsigned, C::Unsigned) = A * z + C
 
 make_rand_num(::Type{Float64}, tmp) = 2.3283064365387e-10 * Float64(tmp)
 make_rand_num(::Type{Float32}, tmp) = 2.3283064f-10 * Float32(tmp)
+# NOTE: the rng state is often not representable as Float16, so perform this in Float32.
+make_rand_num(::Type{Float16}, tmp) = Float16(2.3283064f-10 * Float32(tmp))
 
 function next_rand(state::NTuple{4, T}) where {T <: Unsigned}
     state = (

test/jlarray.jl

@@ -322,13 +322,21 @@ Base.copyto!(dest::DenseJLArray{T}, source::DenseJLArray{T}) where {T} =
     copyto!(dest, 1, source, 1, length(source))
 
 
-## Random
+## random number generation
 
 using Random
 
-# JLArray only supports generating random numbers with the GPUArrays RNG
-Random.rand!(A::AnyJLArray) = Random.rand!(GPUArrays.default_rng(JLArray), A)
-Random.randn!(A::AnyJLArray) = Random.randn!(GPUArrays.default_rng(JLArray), A)
+const GLOBAL_RNG = Ref{Union{Nothing,GPUArrays.RNG}}(nothing)
+function GPUArrays.default_rng(::Type{<:JLArray})
+    if GLOBAL_RNG[] === nothing
+        N = MAXTHREADS
+        state = JLArray{NTuple{4, UInt32}}(undef, N)
+        rng = GPUArrays.RNG(state)
+        Random.seed!(rng)
+        GLOBAL_RNG[] = rng
+    end
+    GLOBAL_RNG[]
+end
 
 
 ## GPUArrays interfaces
@@ -346,16 +354,4 @@ function GPUArrays.mapreducedim!(f, op, R::AnyJLArray, A::Union{AbstractArray,Br
     @allowscalar Base.reducedim!(op, R.data, map(f, A))
 end
 
-const GLOBAL_RNG = Ref{Union{Nothing,GPUArrays.RNG}}(nothing)
-function GPUArrays.default_rng(::Type{<:JLArray})
-    if GLOBAL_RNG[] === nothing
-        N = MAXTHREADS
-        state = JLArray{NTuple{4, UInt32}}(undef, N)
-        rng = GPUArrays.RNG(state)
-        Random.seed!(rng)
-        GLOBAL_RNG[] = rng
-    end
-    GLOBAL_RNG[]
-end
-
 end

test/testsuite/linalg.jl

@@ -47,18 +47,18 @@ end
             gpu_a = AT{Float32}(undef, 128, 128)
             gpu_b = AT{Float32}(undef, 128, 128)
 
-            rand!(gpu_a)
+            copyto!(gpu_a, rand(Float32, (128,128)))
             copyto!(cpu_a, TR(gpu_a))
             @test cpu_a == Array(collect(TR(gpu_a)))
 
-            rand!(gpu_a)
+            copyto!(gpu_a, rand(Float32, (128,128)))
             gpu_c = copyto!(gpu_b, TR(gpu_a))
             @test all(Array(gpu_b) .== TR(Array(gpu_a)))
             @test gpu_c isa AT
         end
 
         for TR in (UpperTriangular, LowerTriangular, UnitUpperTriangular, UnitLowerTriangular)
-            gpu_a = AT{Float32}(undef, 128, 128) |> rand! |> TR
+            gpu_a = AT(rand(Float32, (128,128))) |> TR
             gpu_b = AT{Float32}(undef, 128, 128) |> TR
 
             gpu_c = copyto!(gpu_b, gpu_a)
@@ -72,10 +72,8 @@ end
 @testsuite "linalg/diagonal" AT->begin
     @testset "Array + Diagonal" begin
         n = 128
-        A = AT{Float32}(undef, n, n)
-        d = AT{Float32}(undef, n)
-        rand!(A)
-        rand!(d)
+        A = AT(rand(Float32, (n,n)))
+        d = AT(rand(Float32, n))
         D = Diagonal(d)
         B = A + D
         @test collect(B) ≈ collect(A) + collect(D)

test/testsuite/random.jl

@@ -1,19 +1,21 @@
 @testsuite "random" AT->begin
+    rng = if AT <: AbstractGPUArray
+        GPUArrays.default_rng(AT)
+    else
+        Random.default_rng()
+    end
+
     @testset "rand" begin  # uniform
-        for T in (Int8, Float32, Float64, Int64, Int32,
-                  Complex{Float32}, Complex{Float64},
-                  Complex{Int64}, Complex{Int32}), d in (10, (10,10))
+        for T in (Int16, Int32, Int64,
+                  Float16, Float32, Float64,
+                  Complex{Float16}, Complex{Float32}, Complex{Float64},
+                  Complex{Int32}, Complex{Int64}), d in (10, (10,10))
             A = AT{T}(undef, d)
             B = copy(A)
-            rand!(A)
-            rand!(B)
+            rand!(rng, A)
+            rand!(rng, B)
             @test Array(A) != Array(B)
 
-            rng = if AT <: AbstractGPUArray
-                GPUArrays.default_rng(AT)
-            else
-                Random.default_rng()
-            end
             Random.seed!(rng)
             Random.seed!(rng, 1)
             rand!(rng, A)
@@ -24,26 +26,21 @@
 
         A = AT{Bool}(undef, 1024)
         fill!(A, false)
-        rand!(A)
+        rand!(rng, A)
         @test true in Array(A)
         fill!(A, true)
-        rand!(A)
+        rand!(rng, A)
         @test false in Array(A)
     end
 
-    @testset "randn" begin  # uniform
-        for T in (Float32, Float64), d in (2, (2,2))
+    @testset "randn" begin  # normally-distributed
+        for T in (Float16, Float32, Float64), d in (2, (2,2))
             A = AT{T}(undef, d)
             B = copy(A)
-            randn!(A)
-            randn!(B)
+            randn!(rng, A)
+            randn!(rng, B)
             @test !any(Array(A) .== Array(B))
 
-            rng = if AT <: AbstractGPUArray
-                GPUArrays.default_rng(AT)
-            else
-                Random.default_rng()
-            end
             Random.seed!(rng)
             Random.seed!(rng, 1)
             randn!(rng, A)