Clean-ups.

Author: maleadt

src/host/abstractarray.jl

@@ -23,37 +23,17 @@ backend(::Type{<:AbstractGPUDevice}) = error("Not implemented") # COV_EXCL_LINE
 
 ## serialization
 
-import Serialization: AbstractSerializer, serialize, deserialize, serialize_type
+using Serialization: AbstractSerializer, serialize_type
 
-function serialize(s::AbstractSerializer, t::T) where T <: AbstractGPUArray
+function Serialization.serialize(s::AbstractSerializer, t::T) where T <: AbstractGPUArray
     serialize_type(s, T)
     serialize(s, Array(t))
 end
-function deserialize(s::AbstractSerializer, ::Type{T}) where T <: AbstractGPUArray
+function Serialization.deserialize(s::AbstractSerializer, ::Type{T}) where T <: AbstractGPUArray
     A = deserialize(s)
     T(A)
 end
 
-function to_cartesian(A, indices::Tuple)
-    start = CartesianIndex(ntuple(length(indices)) do i
-        val = indices[i]
-        isa(val, Integer) && return val
-        isa(val, UnitRange) && return first(val)
-        isa(val, Colon) && return 1
-        isa(val, Base.Slice{Base.OneTo{Int}}) && return 1
-        error("GPU indexing only defined for integers or unit ranges. Found: $val")
-    end)
-    stop = CartesianIndex(ntuple(length(indices)) do i
-        val = indices[i]
-        isa(val, Integer) && return val
-        isa(val, UnitRange) && return last(val)
-        isa(val, Colon) && return size(A, i)
-        isa(val, Base.Slice{Base.OneTo{Int}}) && return size(A, i)
-        error("GPU indexing only defined for integers or unit ranges. Found: $val")
-    end)
-    CartesianIndices(start, stop)
-end
-
 ## convert to CPU (keeping wrapper type)
 
 Adapt.adapt_storage(::Type{<:Array}, xs::AbstractArray) = convert(Array, xs)

src/host/base.jl

@@ -19,12 +19,6 @@ Base.map!(f, y::AbstractGPUArray, x::AbstractGPUArray) =
 Base.map!(f, y::AbstractGPUArray, x1::AbstractGPUArray, x2::AbstractGPUArray) =
     invoke(map!, Tuple{Any,AbstractGPUArray, Vararg{AbstractGPUArray}}, f, y, x1, x2)
 
-# This is pretty ugly, but I feel bad to add those to device arrays, since
-# we're never bound checking... So getindex(a::AbstractGPUVector, 10, 10) would silently go unnoticed
-# we need this here for easier implementation of repeat
-@inline Base.@propagate_inbounds getidx_2d1d(x::AbstractVector, i, j) = x[i]
-@inline Base.@propagate_inbounds getidx_2d1d(x::AbstractMatrix, i, j) = x[i, j]
-
 function Base.repeat(a::AbstractGPUVecOrMat, m::Int, n::Int = 1)
     o, p = size(a, 1), size(a, 2)
     b = similar(a, o*m, p*n)
@@ -36,7 +30,7 @@ function Base.repeat(a::AbstractGPUVecOrMat, m::Int, n::Int = 1)
             c = (i - 1) * o + 1
             for r in 1:p
                 for k in 1:o
-                    b[k - 1 + c, r - 1 + d] = getidx_2d1d(a, k, r)
+                    b[k - 1 + c, r - 1 + d] = a[k, r]
                 end
             end
         end

src/host/linalg.jl

@@ -41,41 +41,35 @@ function Base.copyto!(A::AbstractGPUArray, B::Adjoint{T, <: AbstractGPUArray}) w
 end
 
 function LinearAlgebra.tril!(A::AbstractGPUMatrix{T}, d::Integer = 0) where T
-  function kernel!(ctx, _A, _d)
+  gpu_call(A, d) do ctx, _A, _d
     I = @cartesianidx _A
     i, j = Tuple(I)
     if i < j - _d
       _A[i, j] = 0
     end
-    return nothing
+    return
   end
-
-  gpu_call(kernel!, A, d)
   return A
 end
 
 function LinearAlgebra.triu!(A::AbstractGPUMatrix{T}, d::Integer = 0) where T
-  function kernel!(ctx, _A, _d)
+  gpu_call(A, d) do ctx, _A, _d
     I = @cartesianidx _A
     i, j = Tuple(I)
     if j < i + _d
       _A[i, j] = 0
     end
-    return nothing
+    return
   end
-
-  gpu_call(kernel!, A, d)
   return A
 end
 
 function LinearAlgebra.copy_transpose!(dst::AbstractGPUArray, src::AbstractGPUArray)
-  function kernel(ctx, dst, src)
+  gpu_call(st, src) do ctx, dst, src
     I = @cartesianidx dst
     dst[I...] = src[reverse(I)...]
     return
   end
-
-  gpu_call(kernel, dst, src)
   return dst
 end
 
@@ -93,7 +87,7 @@ function generic_matmatmul!(C::AbstractVecOrMat{R}, A::AbstractVecOrMat{T}, B::A
         return fill!(C, zero(R))
     end
 
-    function kernel(ctx, C, A, B)
+    gpu_call(C, A, B) do ctx, C, A, B
         idx = @linearidx C
         i, j = Tuple(CartesianIndices(C)[idx])
 
@@ -109,8 +103,6 @@ function generic_matmatmul!(C::AbstractVecOrMat{R}, A::AbstractVecOrMat{T}, B::A
         return
     end
 
-    gpu_call(kernel, C, A, B)
-
     C
 end
 
@@ -125,25 +117,23 @@ LinearAlgebra.mul!(C::AbstractGPUVecOrMat, A::LinearAlgebra.Adjoint{<:Any, <:Abs
 LinearAlgebra.mul!(C::AbstractGPUVecOrMat, A::LinearAlgebra.Transpose{<:Any, <:AbstractGPUVecOrMat}, B::LinearAlgebra.Transpose{<:Any, <:AbstractGPUVecOrMat}) = generic_matmatmul!(C, A, B)
 
 function generic_rmul!(X::AbstractGPUArray, s::Number)
-    function kernel(ctx, X, s)
+    gpu_call(X, s) do ctx, X, s
         i = @linearidx X
         @inbounds X[i] *= s
         return
     end
-    gpu_call(kernel, X, s)
-    X
+    return X
 end
 
 LinearAlgebra.rmul!(A::AbstractGPUArray, b::Number) = generic_rmul!(A, b)
 
 function generic_lmul!(s::Number, X::AbstractGPUArray)
-    function kernel(ctx, X, s)
+    gpu_call(X, s) do ctx, X, s
         i = @linearidx X
         @inbounds X[i] = s*X[i]
         return
     end
-    gpu_call(kernel, X, s)
-    X
+    return X
 end
 
 LinearAlgebra.lmul!(a::Number, B::AbstractGPUArray) = generic_lmul!(a, B)

src/host/math.jl

@@ -1,11 +1,10 @@
-import Base.clamp!
+# Base mathematical operations
 
 function Base.clamp!(A::AbstractGPUArray, low, high)
-    function kernel(state, A, low, high)
-        I = @cartesianidx A state
+    gpu_call(A, low, high) do ctx, A, low, high
+        I = @cartesianidx A ctx
         A[I] = clamp(A[I], low, high)
         return
     end
-    gpu_call(kernel, A, low, high)
     return A
 end