More clean-up and reorganization.

Author: maleadt

src/GPUArrays.jl

@@ -1,9 +1,5 @@
 module GPUArrays
 
-export GPUArray, gpu_call, thread_blocks_heuristic, global_size, synchronize_threads
-export linear_index, @linearidx, @cartesianidx, convolution!, device, synchronize
-export JLArray
-
 using Serialization
 using Random
 using LinearAlgebra
@@ -17,18 +13,18 @@ using AbstractFFTs
 using Adapt
 
 # GPU interface
+## core definition
 include("abstractarray.jl")
-include("abstract_gpu_interface.jl")
+include("devices.jl")
+include("execution.jl")
 include("ondevice.jl")
-include("base.jl")
 include("construction.jl")
-include("blas.jl")
-include("broadcast.jl")
-include("devices.jl")
-include("heuristics.jl")
+## integrations and specialized functionality
+include("base.jl")
 include("indexing.jl")
-include("linalg.jl")
+include("broadcast.jl")
 include("mapreduce.jl")
+include("linalg.jl")
 include("random.jl")
 
 # CPU implementation

src/abstractarray.jl

@@ -1,5 +1,7 @@
 # core definition of the GPUArray type
 
+export GPUArray
+
 abstract type GPUArray{T, N} <: DenseArray{T, N} end
 
 # Sampler type that acts like a texture/image and allows interpolated access

src/array.jl

@@ -1,5 +1,6 @@
-# Very simple Julia back-end which is just for testing the implementation and can be used as
-# a reference implementation
+# CPU implementation of the GPUArray interface
+
+export JLArray
 
 struct JLArray{T, N} <: GPUArray{T, N}
     data::Array{T, N}

src/base.jl

@@ -1,3 +1,5 @@
+# common Base functionality
+
 allequal(x) = true
 allequal(x, y, z...) = x == y && allequal(y, z...)
 function Base.map!(f, y::GPUArray, xs::GPUArray...)
@@ -18,45 +20,6 @@ Base.map!(f, y::GPUArray, x1::GPUArray, x2::GPUArray) =
     invoke(map!, Tuple{Any,GPUArray, Vararg{GPUArray}}, f, y, x1, x2)
 
 
-# TODO find out why this segfaults julia without stack trace on AMD
-# produces wrong results on Titan X and passes on GTX 950..........
-
-# @generated function nindex(i::T, ls::NTuple{N}) where {T, N}
-#     quote
-#         Base.@_inline_meta
-#         $(foldr(:($T(0), $T(0)), T(1):T(N)) do n, els
-#             :(i ≤ ls[$n] ? ($T($n), i) : (i -= $T(ls[$n]); $els))
-#         end)
-#     end
-# end
-# function catindex(dim, I::NTuple{N, T}, shapes) where {T, N}
-#     xi = nindex(I[dim], map(s-> s[dim], shapes))
-#     x = xi[1]; i = xi[2]
-#     x, ntuple(n -> n == dim ? i : I[n], Val{N})
-# end
-#
-# function _cat(dim, dest, xs...)
-#     gpu_call(dest, (Int(dim), dest, xs)) do state, dim, dest, xs
-#         I = @cartesianidx dest state
-#         nI = catindex(dim, I, size.(xs))
-#         n = nI[1]; I′ = nI[2]
-#         @inbounds dest[I...] = xs[n][I′...]
-#         return
-#     end
-#     return dest
-# end
-#
-# function Base.cat_t(dims::Integer, T::Type, x::GPUArray, xs::GPUArray...)
-#     catdims = Base.dims2cat(dims)
-#     shape = Base.cat_shape(catdims, (), size.((x, xs...))...)
-#     dest = Base.cat_similar(x, T, shape)
-#     _cat(dims, dest, x, xs...)
-# end
-#
-# Base.vcat(xs::GPUArray...) = cat(1, xs...)
-# Base.hcat(xs::GPUArray...) = cat(2, xs...)
-
-
 # Base functions that are sadly not fit for the the GPU yet (they only work for Int64)
 Base.@pure @inline function gpu_ind2sub(A::AbstractArray, ind::T) where T
     _ind2sub(size(A), ind - T(1))

src/blas.jl

@@ -1,3 +1,5 @@
+# broadcasting operations
+
 using Base.Broadcast
 
 import Base.Broadcast: BroadcastStyle, Broadcasted, ArrayStyle

src/broadcast.jl

@@ -1,3 +1,5 @@
+# constructors and conversions
+
 function Base.fill(X::Type{<: GPUArray}, val::T, dims::NTuple{N, Integer}) where {T, N}
     res = similar(X{T}, dims)
     fill!(res, val)

src/construction.jl

@@ -1,4 +1,11 @@
-# device properties
+# device management and properties
+
+"""
+    device(A::AbstractArray)
+
+Gets the device associated to the Array `A`
+"""
+device(A::AbstractArray) = error("Not implemented") # COV_EXCL_LINE
 
 """
 Hardware threads of device

src/devices.jl

@@ -1,4 +1,9 @@
+# kernel execution
+
+export gpu_call, synchronize, thread_blocks_heuristic
+
 abstract type GPUBackend end
+
 backend(::Type{T}) where T = error("Can't choose GPU backend for $T")
 
 """
@@ -46,17 +51,6 @@ end
 # Internal GPU call function, that needs to be overloaded by the backends.
 _gpu_call(::Any, f, A, args, thread_blocks) = error("Not implemented") # COV_EXCL_LINE
 
-
-"""
-    device(A::AbstractArray)
-
-Gets the device associated to the Array `A`
-"""
-function device(A::AbstractArray)
-    # fallback is a noop, for backends not needing synchronization. This
-    # makes it easier to write generic code that also works for AbstractArrays
-end
-
 """
     synchronize(A::AbstractArray)
 
@@ -66,3 +60,10 @@ function synchronize(A::AbstractArray)
     # fallback is a noop, for backends not needing synchronization. This
     # makes it easier to write generic code that also works for AbstractArrays
 end
+
+function thread_blocks_heuristic(len::Integer)
+    # TODO better threads default
+    threads = clamp(len, 1, 256)
+    blocks = max(ceil(Int, len / threads), 1)
+    (blocks,), (threads,)
+end