Merge pull request #136 from JuliaGPU/tb/one

Rework for 1.0

Author: MikeInnes

LICENSE.md

@@ -1,40 +1,23 @@
-The GPUArrays.jl package is licensed under the MIT "Expat" License:
+The MIT License (MIT)
 
-> Copyright (c) 2016: Simon Danisch.
-> 
-> 
-> Permission is hereby granted, free of charge, to any person obtaining a copy
-> 
-> of this software and associated documentation files (the "Software"), to deal
-> 
-> in the Software without restriction, including without limitation the rights
-> 
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-> 
-> copies of the Software, and to permit persons to whom the Software is
-> 
-> furnished to do so, subject to the following conditions:
-> 
-> 
-> 
-> The above copyright notice and this permission notice shall be included in all
-> 
-> copies or substantial portions of the Software.
-> 
-> 
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-> 
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-> 
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-> 
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-> 
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-> 
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-> 
-> SOFTWARE.
-> 
-> 
+Copyright © 2016 Simon Danisch
+
+Copyright © 2018 JuliaGPU developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

src/GPUArrays.jl

@@ -1,20 +1,18 @@
-__precompile__(true)
 module GPUArrays
 
 using Serialization
 using Random
 using LinearAlgebra
 using Printf
-import Base: copyto!
 
 import Random: rand, rand!
 using LinearAlgebra.BLAS
-using FFTW
-import FFTW: *, plan_ifft!, plan_fft!, plan_fft, plan_ifft, size, plan_bfft, plan_bfft!
 import Base: pointer, similar, size, convert
 using Base: @propagate_inbounds, @pure, RefValue
 using Base.Cartesian
-using Random
+
+using FFTW
+import FFTW: *, plan_ifft!, plan_fft!, plan_fft, plan_ifft, size, plan_bfft, plan_bfft!
 
 include("abstractarray.jl")
 include("abstract_gpu_interface.jl")
@@ -30,10 +28,12 @@ include("linalg.jl")
 include("mapreduce.jl")
 include("vectors.jl")
 include("convolution.jl")
-include("testsuite/testsuite.jl")
-include("jlbackend.jl")
 include("random.jl")
 
+include("array.jl")
+
+include("testsuite.jl")
+
 export GPUArray, gpu_call, thread_blocks_heuristic, global_size, synchronize_threads
 export linear_index, @linearidx, @cartesianidx, convolution!, device, synchronize
 export JLArray

src/jlbackend.jl renamed to src/array.jl

@@ -1,5 +1,8 @@
-# Very simple Julia backend which is just for testing the implementation
-# and can be used as a reference implementation
+# 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}
@@ -12,6 +15,22 @@ 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))
+
+function JLArray{T, N}(size::NTuple{N, Integer}) where {T, N}
+    JLArray{T, N}(Array{T, N}(undef, size), size)
+end
+
+
+## getters
+
+size(x::JLArray) = x.size
+
+pointer(x::JLArray) = pointer(x.data)
+
+
+## I/O
+
 Base.show(io::IO, x::JLArray) = show(io, collect(x))
 Base.show(io::IO, x::LinearAlgebra.Adjoint{<:Any,<:JLArray}) = show(io, LinearAlgebra.adjoint(collect(x.parent)))
 Base.show(io::IO, x::LinearAlgebra.Transpose{<:Any,<:JLArray}) = show(io, LinearAlgebra.transpose(collect(x.parent)))
@@ -20,15 +39,16 @@ Base.show(io::IO, ::MIME"text/plain", x::JLArray) = show(io, MIME"text/plain"(),
 Base.show(io::IO, ::MIME"text/plain", x::LinearAlgebra.Adjoint{<:Any,<:JLArray}) = show(io, MIME"text/plain"(), LinearAlgebra.adjoint(collect(x.parent)))
 Base.show(io::IO, ::MIME"text/plain", x::LinearAlgebra.Transpose{<:Any,<:JLArray}) = show(io, MIME"text/plain"(), LinearAlgebra.transpose(collect(x.parent)))
 
+
+## other
+
 """
 Thread group local memory
 """
 struct LocalMem{N, T}
     x::NTuple{N, Vector{T}}
 end
 
-size(x::JLArray) = x.size
-pointer(x::JLArray) = pointer(x.data)
 to_device(state, x::JLArray) = x.data
 to_device(state, x::Tuple) = to_device.(Ref(state), x)
 to_device(state, x::RefValue{<: JLArray}) = RefValue(to_device(state, x[]))
@@ -40,12 +60,6 @@ to_blocks(state, x) = x
 # unpacks local memory for each block
 to_blocks(state, x::LocalMem) = x.x[blockidx_x(state)]
 
-(::Type{<: JLArray{T}})(x::AbstractArray) where T = JLArray(convert(Array{T}, x), size(x))
-
-function JLArray{T, N}(size::NTuple{N, Integer}) where {T, N}
-    JLArray{T, N}(Array{T, N}(undef, size), size)
-end
-
 similar(::Type{<: JLArray}, ::Type{T}, size::Base.Dims{N}) where {T, N} = JLArray{T, N}(size)
 
 function unsafe_reinterpret(::Type{T}, A::JLArray{ET}, size::NTuple{N, Integer}) where {T, ET, N}
@@ -131,7 +145,8 @@ function _gpu_call(f, A::JLArray, args::Tuple, blocks_threads::Tuple{T, T}) wher
         block_args = to_blocks.(Ref(state), device_args)
         for threadidx in CartesianIndices(threads)
             thread_state = JLState(state, threadidx.I)
-            tasks[threadidx] = @async f(thread_state, block_args...)
+            tasks[threadidx] = @async @allowscalar f(thread_state, block_args...)
+            # TODO: @async obfuscates the trace to any exception which happens during f
         end
         for t in tasks
             fetch(t)
@@ -146,7 +161,6 @@ device(x::JLArray) = JLDevice()
 threads(dev::JLDevice) = 256
 blocks(dev::JLDevice) = (256, 256, 256)
 
-
 @inline function synchronize_threads(::JLState)
     #=
     All threads are getting started asynchronously,so a yield will
@@ -168,8 +182,9 @@ end
 blas_module(::JLArray) = LinearAlgebra.BLAS
 blasbuffer(A::JLArray) = A.data
 
+# defining our own plan type is the easiest way to pass around the plans in Base interface
+# without ambiguities
 
-# defining our own plan type is the easiest way to pass around the plans in Base interface without ambiguities
 struct FFTPlan{T}
     p::T
 end
@@ -192,7 +207,6 @@ function plan_ifft(A::JLArray; kw_args...)
     FFTPlan(plan_ifft(A.data; kw_args...))
 end
 
-
 function *(plan::FFTPlan, A::JLArray)
     x = plan.p * A.data
     JLArray(x)

src/indexing.jl

@@ -1,10 +1,20 @@
-const _allowslow = Ref(true)
+const _allowscalar = Ref(true)
 
-allowslow(flag = true) = (_allowslow[] = flag)
+allowscalar(flag = true) = (_allowscalar[] = flag)
 
-function assertslow(op = "Operation")
-    # _allowslow[] || error("$op is disabled")
-    return
+function assertscalar(op = "Operation")
+  _allowscalar[] || error("$op is disabled")
+  return
+end
+
+macro allowscalar(ex)
+    quote
+        local prev = _allowscalar[]
+        _allowscalar[] = true
+        local ret = $(esc(ex))
+        _allowscalar[] = prev
+        ret
+    end
 end
 
 Base.IndexStyle(::Type{<:GPUArray}) = Base.IndexLinear()
@@ -16,7 +26,7 @@ function _getindex(xs::GPUArray{T}, i::Integer) where T
 end
 
 function Base.getindex(xs::GPUArray{T}, i::Integer) where T
-    assertslow("getindex")
+  ndims(xs) > 0 && assertscalar("scalar getindex")
     _getindex(xs, i)
 end
 
@@ -27,12 +37,13 @@ function _setindex!(xs::GPUArray{T}, v::T, i::Integer) where T
 end
 
 function Base.setindex!(xs::GPUArray{T}, v::T, i::Integer) where T
-    assertslow("setindex!")
+  assertscalar("scalar setindex!")
     _setindex!(xs, v, i)
 end
 
 Base.setindex!(xs::GPUArray, v, i::Integer) = xs[i] = convert(eltype(xs), v)
 
+
 # Vector indexing
 
 to_index(a, x) = x

src/testsuite.jl

@@ -0,0 +1,74 @@
+# Abstract test suite that can be used for all packages inheriting from GPUArray
+
+module TestSuite
+
+using GPUArrays
+using GPUArrays: mapidx, gpu_sub2ind
+
+using LinearAlgebra
+using Random
+using Test
+
+using FFTW
+using FillArrays
+using StaticArrays
+
+toarray(T, x::Tuple{X, Vararg{Int}}) where X = fill(first(x), Base.tail(x))
+toarray(::Type{T}, x::NTuple{N, Int}) where {T <: Bool, N} = rand(T, x)
+toarray(::Type{T}, x::NTuple{N, Int}) where {T <: Integer, N} = rand(T(1):T(10), x)
+toarray(T, x::NTuple{N, Int}) where N = rand(T, x)
+toarray(T, x) = x
+togpu(T, x::AbstractArray) = T(x)
+togpu(T, x) = x
+
+"""
+Calls function `f` on input arrays generated by `sizes` as Base.Array and converted to
+`Typ`. Compares the result of `f` and tests if they agree. `sizes` can be the shape of the
+array, a value or a tuple `(val, shape...)` which will create a `fill(val, shape...)`.
+"""
+function against_base(f, Typ, sizes...)
+    jl_arrays = toarray.(eltype(Typ), sizes)
+    gpu_arrays = togpu.(Typ, jl_arrays)
+    res_jl = f(jl_arrays...)
+    res_gpu = f(gpu_arrays...)
+    @test res_jl ≈ Array(res_gpu)
+end
+
+
+include("testsuite/blas.jl")
+include("testsuite/broadcasting.jl")
+include("testsuite/construction.jl")
+include("testsuite/fft.jl")
+include("testsuite/gpuinterface.jl")
+include("testsuite/linalg.jl")
+include("testsuite/mapreduce.jl")
+include("testsuite/base.jl")
+include("testsuite/indexing.jl")
+include("testsuite/vector.jl")
+include("testsuite/random.jl")
+
+function supported_eltypes()
+    (Float32, Float64, Int32, Int64, ComplexF32, ComplexF64)
+end
+
+export against_base, run_tests, supported_eltypes
+
+end
+
+
+"""
+Runs the entire GPUArrays test suite on array type `Typ`
+"""
+function test(Typ)
+    TestSuite.test_gpuinterface(Typ)
+    TestSuite.test_base(Typ)
+    TestSuite.test_blas(Typ)
+    TestSuite.test_broadcasting(Typ)
+    TestSuite.test_construction(Typ)
+    TestSuite.test_fft(Typ)
+    TestSuite.test_linalg(Typ)
+    TestSuite.test_mapreduce(Typ)
+    TestSuite.test_indexing(Typ)
+    #TestSuite.test_vectors(Typ)
+    TestSuite.test_random(Typ)
+end

src/testsuite/base.jl

@@ -26,7 +26,7 @@ function ntuple_closure(state, result, ::Val{N}, testval) where N
     return
 end
 
-function run_base(Typ)
+function test_base(Typ)
     @testset "base functionality" begin
         @testset "mapidx" begin
             a = rand(ComplexF32, 77)
@@ -68,9 +68,6 @@ function run_base(Typ)
             @test Array(a) == x
         end
 
-        GPUArrays.allowslow(true)
-        # right now in CLArrays we fallback to geindex since on some hardware
-        # somehow the vcat kernel segfaults -.-
         @testset "vcat + hcat" begin
             x = fill(0f0, (10, 10))
             y = rand(Float32, 20, 10)
@@ -84,7 +81,6 @@ function run_base(Typ)
             against_base(hcat, Typ{Float32}, (3, 3), (3, 3))
             against_base(vcat, Typ{Float32}, (3, 3), (3, 3))
         end
-        GPUArrays.allowslow(false)
 
         @testset "reinterpret" begin
             a = rand(ComplexF32, 22)

src/testsuite/blas.jl

@@ -1,6 +1,4 @@
-using LinearAlgebra
-
-function run_blas(Typ)
+function test_blas(Typ)
     @testset "BLAS" begin
         T = Typ{Float32}
         @testset "matmul" begin