Merge pull request #169 from JuliaGPU/tb/simplify

Simplify array constructors.

Author: maleadt

src/array.jl

@@ -1,37 +1,79 @@
 # Very simple Julia back-end which is just for testing the implementation and can be used as
 # a reference implementation
 
-
-## construction
-
 struct JLArray{T, N} <: GPUArray{T, N}
     data::Array{T, N}
-    size::Dims{N}
+    dims::Dims{N}
 
-    function JLArray{T,N}(data::Array{T, N}, size::NTuple{N, Int}) where {T,N}
-        new(data, size)
+    function JLArray{T,N}(data::Array{T, N}, dims::Dims{N}) where {T,N}
+        new(data, dims)
     end
 end
 
-JLArray(data::AbstractArray{T, N}, size::Dims{N}) where {T,N} = JLArray{T,N}(data, size)
 
-(::Type{<: JLArray{T}})(x::AbstractArray) where T = JLArray(convert(Array{T}, x), size(x))
+## construction
+
+# type and dimensionality specified, accepting dims as tuples of Ints
+JLArray{T,N}(::UndefInitializer, dims::Dims{N}) where {T,N} =
+  JLArray{T,N}(Array{T, N}(undef, dims), dims)
 
-function JLArray{T, N}(size::NTuple{N, Integer}) where {T, N}
-    JLArray{T, N}(Array{T, N}(undef, size), size)
-end
+# type and dimensionality specified, accepting dims as series of Ints
+JLArray{T,N}(::UndefInitializer, dims::Integer...) where {T,N} = JLArray{T,N}(undef, dims)
 
-struct JLBackend <: GPUBackend end
-backend(::Type{<:JLArray}) = JLBackend()
+# type but not dimensionality specified
+JLArray{T}(::UndefInitializer, dims::Dims{N}) where {T,N} = JLArray{T,N}(undef, dims)
+JLArray{T}(::UndefInitializer, dims::Integer...) where {T} =
+  JLArray{T}(undef, convert(Tuple{Vararg{Int}}, dims))
+
+# empty vector constructor
+JLArray{T,1}() where {T} = JLArray{T,1}(undef, 0)
+
+
+Base.similar(a::JLArray{T,N}) where {T,N} = JLArray{T,N}(undef, size(a))
+Base.similar(a::JLArray{T}, dims::Base.Dims{N}) where {T,N} = JLArray{T,N}(undef, dims)
+Base.similar(a::JLArray, ::Type{T}, dims::Base.Dims{N}) where {T,N} = JLArray{T,N}(undef, dims)
+
+
+## array interface
+
+Base.elsize(::Type{<:JLArray{T}}) where {T} = sizeof(T)
+
+Base.size(x::JLArray) = x.dims
+Base.sizeof(x::JLArray) = Base.elsize(x) * length(x)
 
-## getters
 
-Base.size(x::JLArray) = x.size
+## interop with other arrays
 
-Base.pointer(x::JLArray) = pointer(x.data)
+JLArray{T,N}(x::AbstractArray{S,N}) where {T,N,S} =
+    JLArray{T,N}(convert(Array{T}, x), size(x))
 
+# underspecified constructors
+JLArray{T}(xs::AbstractArray{S,N}) where {T,N,S} = JLArray{T,N}(xs)
+(::Type{JLArray{T,N} where T})(x::AbstractArray{S,N}) where {S,N} = JLArray{S,N}(x)
+JLArray(A::AbstractArray{T,N}) where {T,N} = JLArray{T,N}(A)
 
-## other
+# idempotency
+JLArray{T,N}(xs::JLArray{T,N}) where {T,N} = xs
+
+
+## conversions
+
+Base.convert(::Type{T}, x::T) where T <: JLArray = x
+
+
+## broadcast
+
+BroadcastStyle(::Type{<:JLArray}) = ArrayStyle{JLArray}()
+
+function Base.similar(bc::Broadcasted{ArrayStyle{JLArray}}, ::Type{T}) where T
+    similar(JLArray{T}, axes(bc))
+end
+
+
+## gpuarray interface
+
+struct JLBackend <: GPUBackend end
+backend(::Type{<:JLArray}) = JLBackend()
 
 """
 Thread group local memory
@@ -51,8 +93,6 @@ to_blocks(state, x) = x
 # unpacks local memory for each block
 to_blocks(state, x::LocalMem) = x.x[blockidx_x(state)]
 
-Base.similar(::Type{<: JLArray}, ::Type{T}, size::Base.Dims{N}) where {T, N} = JLArray{T, N}(size)
-
 unsafe_reinterpret(::Type{T}, A::JLArray, size::Tuple) where T =
     reshape(reinterpret(T, A.data), size)
 

src/broadcast.jl

@@ -31,12 +31,6 @@ const GPUDestArray = Union{GPUArray,
                            LinearAlgebra.Adjoint{<:Any,<:GPUArray},
                            SubArray{<:Any,<:Any,<:GPUArray}}
 
-# This method is responsible for selection the output type of broadcast
-function Base.similar(bc::Broadcasted{<:ArrayStyle{GPU}}, ::Type{ElType}) where
-                     {GPU <: GPUArray, ElType}
-    similar(GPU, ElType, axes(bc))
-end
-
 # We purposefully only specialize `copyto!`, dependent packages need to make sure that they
 # can handle:
 # - `bc::Broadcast.Broadcasted{Style}`

src/construction.jl

@@ -1,9 +1,9 @@
 function Base.fill(X::Type{<: GPUArray}, val::T, dims::NTuple{N, Integer}) where {T, N}
-    res = similar(X, T, dims)
+    res = similar(X{T}, dims)
     fill!(res, val)
 end
 function Base.fill(X::Type{<: GPUArray{T}}, val, dims::NTuple{N, Integer}) where {T, N}
-    res = similar(X, T, dims)
+    res = similar(X, dims)
     fill!(res, convert(T, val))
 end
 function Base.fill!(A::GPUArray{T}, x) where T
@@ -33,17 +33,6 @@ function (T::Type{<: GPUArray})(s::UniformScaling, dims::Dims{2})
 end
 (T::Type{<: GPUArray})(s::UniformScaling, m::Integer, n::Integer) = T(s, Dims((m, n)))
 
-(T::Type{<: GPUArray})(x) = convert(T, x)
-(T::Type{<: GPUArray})(dims::Integer...) = T(dims)
-(T::Type{<: GPUArray})(dims::NTuple{N, Base.OneTo{Int}}) where N = T(undef, length.(dims))
-(T::Type{<: GPUArray{X} where X})(dims::NTuple{N, Integer}) where N = similar(T, eltype(T), dims)
-(T::Type{<: GPUArray{X} where X})(::UndefInitializer, dims::NTuple{N, Integer}) where N = similar(T, eltype(T), dims)
-
-Base.similar(x::X, ::Type{T}, size::Base.Dims{N}) where {X <: GPUArray, T, N} = similar(X, T, size)
-Base.similar(::Type{X}, ::Type{T}, size::NTuple{N, Base.OneTo{Int}}) where {X <: GPUArray, T, N} = similar(X, T, length.(size))
-
-Base.convert(AT::Type{<: GPUArray{T, N}}, A::GPUArray{T, N}) where {T, N} = A
-
 function indexstyle(x::T) where T
     style = try
         Base.IndexStyle(x)
@@ -84,15 +73,15 @@ function Base.convert(AT::Type{<: GPUArray}, iter)
 end
 
 function Base.convert(AT::Type{<: GPUArray{T, N}}, A::DenseArray{T, N}) where {T, N}
-    copyto!(AT(Base.size(A)), A)
+    copyto!(AT(undef, size(A)), A)
 end
 
 function Base.convert(AT::Type{<: GPUArray{T1}}, A::DenseArray{T2, N}) where {T1, T2, N}
-    copyto!(similar(AT, T1, size(A)), convert(Array{T1, N}, A))
+    copyto!(similar(AT, size(A)), convert(Array{T1, N}, A))
 end
 
 function Base.convert(AT::Type{<: GPUArray}, A::DenseArray{T2, N}) where {T2, N}
-    copyto!(similar(AT, T2, size(A)), A)
+    copyto!(similar(AT{T2}, size(A)), A)
 end
 
 function Base.convert(AT::Type{Array{T, N}}, A::GPUArray{CT, CN}) where {T, N, CT, CN}

src/random.jl

@@ -51,21 +51,16 @@ end
 
 struct RNG <: AbstractRNG
     state::GPUArray{NTuple{4,UInt32},1}
-
-    function RNG(A::GPUArray)
-        dev = GPUArrays.device(A)
-        N = GPUArrays.threads(dev)
-        state = similar(A, NTuple{4, UInt32}, N)
-        copyto!(state, [ntuple(i-> rand(UInt32), 4) for i=1:N])
-        new(state)
-    end
 end
 
 const GLOBAL_RNGS = Dict()
 function global_rng(A::GPUArray)
     dev = GPUArrays.device(A)
     get!(GLOBAL_RNGS, dev) do
-        RNG(A)
+        N = GPUArrays.threads(dev)
+        state = similar(A, NTuple{4, UInt32}, N)
+        copyto!(state, [ntuple(i-> rand(UInt32), 4) for i=1:N])
+        RNG(state)
     end
 end
 

src/testsuite/construction.jl

@@ -10,22 +10,22 @@ end
 function constructors(AT)
     @testset "constructors + similar" begin
         for T in supported_eltypes()
-            B = AT{T}(10)
+            B = AT{T}(undef, 10)
             @test B isa AT{T,1}
             @test size(B) == (10,)
             @test eltype(B) == T
 
-            B = AT{T}(10, 10)
+            B = AT{T}(undef, 10, 10)
             @test B isa AT{T,2}
             @test size(B) == (10, 10)
             @test eltype(B) == T
 
-            B = AT{T}((10, 10))
+            B = AT{T}(undef, (10, 10))
             @test B isa AT{T,2}
             @test size(B) == (10, 10)
             @test eltype(B) == T
 
-            B = similar(B, Int32, (11, 15))
+            B = similar(B, Int32, 11, 15)
             @test B isa AT{Int32,2}
             @test size(B) == (11, 15)
             @test eltype(B) == Int32
@@ -50,11 +50,6 @@ function constructors(AT)
             @test size(B) == (11, 15)
             @test eltype(B) == Int32
 
-            B = similar(AT{Int32, 2}, T, (11, 15))
-            @test B isa AT{T,2}
-            @test size(B) == (11, 15)
-            @test eltype(B) == T
-
             B = similar(AT{T}, (5,))
             @test B isa AT{T,1}
             @test size(B) == (5,)
@@ -66,6 +61,34 @@ function constructors(AT)
             @test eltype(B) == T
         end
     end
+    @testset "comparison against Array" begin
+        for typs in [(), (Int,), (Int,1), (Int,2), (Float32,), (Float32,1), (Float32,2)],
+            args in [(), (1,), (1,2), ((1,),), ((1,2),),
+                     (undef,), (undef, 1,), (undef, 1,2), (undef, (1,),), (undef, (1,2),),
+                     (Int,), (Int, 1,), (Int, 1,2), (Int, (1,),), (Int, (1,2),),
+                     ([1,2],), ([1 2],)]
+            cpu = try
+                Array{typs...}(args...)
+            catch ex
+                isa(ex, MethodError) || rethrow()
+                nothing
+            end
+
+            gpu = try
+                AT{typs...}(args...)
+            catch ex
+                isa(ex, MethodError) || rethrow()
+                cpu == nothing || rethrow()
+                nothing
+            end
+
+            if cpu == nothing
+                @test gpu == nothing
+            else
+                @test typeof(cpu) == typeof(convert(Array, gpu))
+            end
+        end
+    end
 end
 
 function conversion(AT)
@@ -127,7 +150,7 @@ function value_constructor(AT)
             @test Array(x3) ≈ x
 
             fill!(x1, 2f0)
-            x2 = fill!(AT{Int32}((4, 4, 4)), 77f0)
+            x2 = fill!(AT{Int32}(undef, (4, 4, 4)), 77f0)
             @test all(x-> x == 2f0, Array(x1))
             @test all(x-> x == Int32(77), Array(x2))
 
@@ -152,7 +175,7 @@ function iterator_constructors(AT)
                 x = AT{Float32}(Fill(T(0), (10, 10)))
                 @test eltype(x) == Float32
                 @test AT(Eye{T}((10))) == AT{T}(I, 10, 10)
-                x = AT{Float32}(Eye{T}((10)))
+                x = AT{Float32}(Eye{T}(10))
                 @test eltype(x) == Float32
             end
         end

src/testsuite/indexing.jl

@@ -13,7 +13,7 @@ function test_indexing(AT)
             end
             @testset "multi dim, sliced setindex" begin
                 x = fill(AT{T}, T(0), (10, 10, 10, 10))
-                y = AT{T}(5, 5, 10, 10)
+                y = AT{T}(undef, 5, 5, 10, 10)
                 rand!(y)
                 x[2:6, 2:6, :, :] = y
                 x[2:6, 2:6, :, :] == y

src/testsuite/random.jl

@@ -2,7 +2,7 @@ function test_random(AT)
     @testset "Random" begin
         @testset "rand" begin  # uniform
             for T in (Float32, Float64, Int64, Int32), d in (2, (2,2))
-                A = AT{T}(d)
+                A = AT{T}(undef, d)
                 B = copy(A)
                 rand!(A)
                 rand!(B)