Merge pull request #49 from JuliaGPU/fbot/deps

Fix deprecations

Author: SimonDanisch

src/abstractarray.jl

@@ -13,7 +13,7 @@ const GPUVecOrMat{T} = Union{GPUArray{T, 1}, GPUArray{T, 2}}
 # GPU Local Memory
 struct LocalMemory{T} <: GPUArray{T, 1}
     size::Int
-    (::Type{LocalMemory{T}})(x::Integer) where T = new{T}(x)
+    LocalMemory{T}(x::Integer) where T = new{T}(x)
 end
 
 #=
@@ -40,11 +40,11 @@ else
     error("No Serialization type found. Probably unsupported Julia version")
 end
 
-function Base.serialize{T <: GPUArray}(s::BaseSerializer, t::T)
+function Base.serialize(s::BaseSerializer, t::T) where T <: GPUArray
     Base.serialize_type(s, T)
     serialize(s, Array(t))
 end
-function Base.deserialize{T <: GPUArray}(s::BaseSerializer, ::Type{T})
+function Base.deserialize(s::BaseSerializer, ::Type{T}) where T <: GPUArray
     A = deserialize(s)
     T(A)
 end
@@ -88,18 +88,18 @@ for (D, S) in ((GPUArray, AbstractArray), (AbstractArray, GPUArray), (GPUArray,
                 unpack_buffer(src), soffset, amount
             )
         end
-        function copy!{T, N}(
+        function copy!(
                 dest::$D{T, N}, rdest::NTuple{N, UnitRange},
                 src::$S{T, N}, ssrc::NTuple{N, UnitRange},
-            )
+            ) where {T, N}
             drange = crange(start.(rdest), last.(rdest))
             srange = crange(start.(ssrc), last.(ssrc))
             copy!(dest, drange, src, srange)
         end
-        function copy!{T}(
+        function copy!(
                 dest::$D{T}, d_range::CartesianRange{CartesianIndex{1}},
                 src::$S{T}, s_range::CartesianRange{CartesianIndex{1}},
-            )
+            ) where T
             amount = length(d_range)
             if length(s_range) != amount
                 throw(ArgumentError("Copy range needs same length. Found: dest: $amount, src: $(length(s_range))"))
@@ -109,9 +109,9 @@ for (D, S) in ((GPUArray, AbstractArray), (AbstractArray, GPUArray), (GPUArray,
             s_offset = first(s_range)[1]
             copy!(dest, d_offset, src, s_offset, amount)
         end
-        function copy!{T, N}(
+        function copy!(
                 dest::$D{T, N}, src::$S{T, N}
-            )
+            ) where {T, N}
             len = length(src)
             len == 0 && return dest
             if length(dest) > len
@@ -134,10 +134,10 @@ function copy_kernel!(state, dest, dest_offsets, src, src_offsets, shape, shape_
     return
 end
 
-function copy!{T, N}(
+function copy!(
         dest::GPUArray{T, N}, destcrange::CartesianRange{CartesianIndex{N}},
         src::GPUArray{T, N}, srccrange::CartesianRange{CartesianIndex{N}}
-    )
+    ) where {T, N}
     shape = size(destcrange)
     if shape != size(srccrange)
         throw(DimensionMismatch("Ranges don't match their size. Found: $shape, $(size(srccrange))"))
@@ -155,10 +155,10 @@ function copy!{T, N}(
 end
 
 
-function copy!{T, N}(
+function copy!(
         dest::GPUArray{T, N}, destcrange::CartesianRange{CartesianIndex{N}},
         src::AbstractArray{T, N}, srccrange::CartesianRange{CartesianIndex{N}}
-    )
+    ) where {T, N}
     # Is this efficient? Maybe!
     # TODO: compare to a pure intrinsic copy implementation!
     # this would mean looping over linear sections of memory and
@@ -170,10 +170,10 @@ function copy!{T, N}(
 end
 
 
-function copy!{T, N}(
+function copy!(
         dest::AbstractArray{T, N}, destcrange::CartesianRange{CartesianIndex{N}},
         src::GPUArray{T, N}, srccrange::CartesianRange{CartesianIndex{N}}
-    )
+    ) where {T, N}
     # Is this efficient? Maybe!
     dest_gpu = similar(src, size(destcrange))
     nrange = CartesianRange(one(CartesianIndex{N}), CartesianIndex(size(dest_gpu)))

src/base.jl

@@ -61,29 +61,29 @@ map!(f, y::GPUArray, x1::GPUArray, x2::GPUArray) =
 
 
 # Base functions that are sadly not fit for the the GPU yet (they only work for Int64)
-@pure @inline function gpu_ind2sub{T}(A::AbstractArray, ind::T)
+@pure @inline function gpu_ind2sub(A::AbstractArray, ind::T) where T
     _ind2sub(size(A), ind - T(1))
 end
-@pure @inline function gpu_ind2sub{N, T}(dims::NTuple{N}, ind::T)
+@pure @inline function gpu_ind2sub(dims::NTuple{N}, ind::T) where {N, T}
     _ind2sub(NTuple{N, T}(dims), ind - T(1))
 end
-@pure @inline _ind2sub{T}(::Tuple{}, ind::T) = (ind + T(1),)
-@pure @inline function _ind2sub{T}(indslast::NTuple{1}, ind::T)
+@pure @inline _ind2sub(::Tuple{}, ind::T) where {T} = (ind + T(1),)
+@pure @inline function _ind2sub(indslast::NTuple{1}, ind::T) where T
     ((ind + T(1)),)
 end
-@pure @inline function _ind2sub{T}(inds, ind::T)
+@pure @inline function _ind2sub(inds, ind::T) where T
     r1 = inds[1]
     indnext = div(ind, r1)
     f = T(1); l = r1
     (ind-l*indnext+f, _ind2sub(Base.tail(inds), indnext)...)
 end
 
-@pure function gpu_sub2ind{N, N2, T}(dims::NTuple{N}, I::NTuple{N2, T})
+@pure function gpu_sub2ind(dims::NTuple{N}, I::NTuple{N2, T}) where {N, N2, T}
     Base.@_inline_meta
     _sub2ind(NTuple{N, T}(dims), T(1), T(1), I...)
 end
 _sub2ind(x, L, ind) = ind
-function _sub2ind{T}(::Tuple{}, L, ind, i::T, I::T...)
+function _sub2ind(::Tuple{}, L, ind, i::T, I::T...) where T
     Base.@_inline_meta
     ind + (i - T(1)) * L
 end

src/blas.jl

@@ -28,10 +28,10 @@ end
 
 for elty in (Float64, Float32)
     @eval begin
-        function Base.BLAS.scal!{N}(
+        function Base.BLAS.scal!(
                 n::Integer, DA::$elty,
                 DX::GPUArray{$elty, N}, incx::Integer
-            )
+            ) where N
             blasmod = blas_module(DX)
             blasmod.scal!(n, DA, blasbuffer(DX), incx)
             DX

src/broadcast.jl

@@ -111,7 +111,7 @@ arg_length(x) = ()
 
 abstract type BroadcastDescriptor{Typ} end
 
-immutable BroadcastDescriptorN{Typ, N} <: BroadcastDescriptor{Typ}
+struct BroadcastDescriptorN{Typ, N} <: BroadcastDescriptor{Typ}
     size::NTuple{N, UInt32}
     keep::NTuple{N, UInt32}
     idefault::NTuple{N, UInt32}
@@ -208,7 +208,7 @@ for N = 0:10
 
 end
 
-function mapidx{N}(f, A::GPUArray, args::NTuple{N, Any})
+function mapidx(f, A::GPUArray, args::NTuple{N, Any}) where N
     gpu_call(mapidx_kernel, A, (f, A, UInt32(length(A)), args...))
 end
 
@@ -225,7 +225,7 @@ end
 end
 
 # differently shaped arrays
-@generated function newindex{N, T}(I, ilin::T, keep::NTuple{N}, Idefault, size)
+@generated function newindex(I, ilin::T, keep::NTuple{N}, Idefault, size) where {N, T}
     exprs = Expr(:tuple)
     for i = 1:N
         push!(exprs.args, :(T(Bool(keep[$i]) ? T(I[$i]) : T(Idefault[$i]))))

src/construction.jl

@@ -9,7 +9,7 @@ function fill(X::Type{<: GPUArray}, val::T, dims::NTuple{N, Integer}) where {T,
     fill!(res, val)
 end
 
-function fill!{T, N}(A::GPUArray{T, N}, val)
+function fill!(A::GPUArray{T, N}, val) where {T, N}
     valconv = T(val)
     gpu_call(const_kernel2, A, (A, valconv, UInt32(length(A))))
     A

src/convolution.jl

@@ -71,7 +71,7 @@ function convolution!(a, out, k)
     out
 end
 
-immutable FFTKernel{T}
+struct FFTKernel{T}
     kernel::T
     irfftplan
     rfftplan

src/fft.jl

@@ -9,9 +9,9 @@ import CLFFT
 #const plan_dict = Dict()
 import Base: *, plan_ifft!, plan_fft!, plan_fft, plan_ifft, size, plan_bfft, plan_bfft!
 
-immutable CLFFTPlan{Direction, Inplace, T, N} <: Base.FFTW.FFTWPlan{T, Direction, Inplace}
+struct CLFFTPlan{Direction, Inplace, T, N} <: Base.FFTW.FFTWPlan{T, Direction, Inplace}
     plan::CLFFT.Plan{T}
-    function (::Type{CLFFTPlan{Direction, Inplace}})(A::CLArray{T, N}) where {T, N, Direction, Inplace}
+    function CLFFTPlan{Direction, Inplace}(A::CLArray{T, N}) where {T, N, Direction, Inplace}
         ctx = context(A)
         p = CLFFT.Plan(T, ctx.context, size(A))
         CLFFT.set_layout!(p, :interleaved, :interleaved)

src/jlbackend.jl

@@ -10,7 +10,7 @@ end
 """
 Thread group local memory
 """
-immutable LocalMem{N, T}
+struct LocalMem{N, T}
     x::NTuple{N, Vector{T}}
 end
 
@@ -27,7 +27,7 @@ to_blocks(state, x) = x
 # unpacks local memory for each block
 to_blocks(state, x::LocalMem) = x.x[blockidx_x(state)]
 
-function (::Type{JLArray{T, N}})(size::NTuple{N, Integer}) where {T, N}
+function JLArray{T, N}(size::NTuple{N, Integer}) where {T, N}
     JLArray{T, N}(Array{T, N}(size), size)
 end
 
@@ -37,23 +37,23 @@ function unsafe_reinterpret(::Type{T}, A::JLArray{ET}, size::NTuple{N, Integer})
     JLArray(collect(reshape(reinterpret(T, A.data), size)))
 end
 
-function copy!{T}(
+function copy!(
         dest::Array{T}, d_offset::Integer,
         source::JLArray{T}, s_offset::Integer, amount::Integer
-    )
+    ) where T
     copy!(dest, d_offset, source.data, s_offset, amount)
 end
-function copy!{T}(
+function copy!(
         dest::JLArray{T}, d_offset::Integer,
         source::Array{T}, s_offset::Integer, amount::Integer
-    )
+    ) where T
     copy!(dest.data, d_offset, source, s_offset, amount)
     dest
 end
-function copy!{T}(
+function copy!(
         dest::JLArray{T}, d_offset::Integer,
         source::JLArray{T}, s_offset::Integer, amount::Integer
-    )
+    ) where T
     copy!(dest.data, d_offset, source.data, s_offset, amount)
     dest
 end
@@ -99,10 +99,10 @@ function LocalMemory(state::JLState, ::Type{T}, ::Val{N}, ::Val{C}) where {T, N,
     end
 end
 
-function (::Type{AbstractDeviceArray})(ptr::Array, shape::NTuple{N, Integer}) where N
+function AbstractDeviceArray(ptr::Array, shape::NTuple{N, Integer}) where N
     reshape(ptr, Int.(shape))
 end
-function (::Type{AbstractDeviceArray})(ptr::Array, shape::Vararg{Integer, N}) where N
+function AbstractDeviceArray(ptr::Array, shape::Vararg{Integer, N}) where N
     reshape(ptr, Int.(shape))
 end
 
@@ -158,7 +158,7 @@ blasbuffer(A::JLArray) = A.data
 
 import Base: *, plan_ifft!, plan_fft!, plan_fft, plan_ifft, size, plan_bfft, plan_bfft!
 # defining our own plan type is the easiest way to pass around the plans in Base interface without ambiguities
-immutable FFTPlan{T}
+struct FFTPlan{T}
     p::T
 end
 function plan_fft(A::JLArray; kw_args...)

src/linalg.jl

@@ -53,7 +53,7 @@ function transpose_blocks!(
     return
 end
 
-function transpose!{T}(At::GPUArray{T, 2}, A::GPUArray{T, 2})
+function transpose!(At::GPUArray{T, 2}, A::GPUArray{T, 2}) where T
     if size(A, 1) == size(A, 2) && all(x-> x % 32 == 0, size(A))
         outsize = UInt32.(size(At))
         TDIM = UInt32(32); BLOCK_ROWS = UInt32(8)

src/mapreduce.jl

@@ -20,18 +20,18 @@ startvalue(::typeof(Base.scalarmin), T) = typemax(T)
 startvalue(::typeof(Base.scalarmax), T) = typemin(T)
 
 # TODO widen and support Int64 and use Base.r_promote_type
-gpu_promote_type{T}(op, ::Type{T}) = T
-gpu_promote_type{T<:Base.WidenReduceResult}(op, ::Type{T}) = T
-gpu_promote_type{T<:Base.WidenReduceResult}(::typeof(+), ::Type{T}) = T
-gpu_promote_type{T<:Base.WidenReduceResult}(::typeof(*), ::Type{T}) = T
-gpu_promote_type{T<:Number}(::typeof(+), ::Type{T}) = typeof(zero(T)+zero(T))
-gpu_promote_type{T<:Number}(::typeof(*), ::Type{T}) = typeof(one(T)*one(T))
-gpu_promote_type{T<:Base.WidenReduceResult}(::typeof(Base.scalarmax), ::Type{T}) = T
-gpu_promote_type{T<:Base.WidenReduceResult}(::typeof(Base.scalarmin), ::Type{T}) = T
-gpu_promote_type{T<:Base.WidenReduceResult}(::typeof(max), ::Type{T}) = T
-gpu_promote_type{T<:Base.WidenReduceResult}(::typeof(min), ::Type{T}) = T
+gpu_promote_type(op, ::Type{T}) where {T} = T
+gpu_promote_type(op, ::Type{T}) where {T<:Base.WidenReduceResult} = T
+gpu_promote_type(::typeof(+), ::Type{T}) where {T<:Base.WidenReduceResult} = T
+gpu_promote_type(::typeof(*), ::Type{T}) where {T<:Base.WidenReduceResult} = T
+gpu_promote_type(::typeof(+), ::Type{T}) where {T<:Number} = typeof(zero(T)+zero(T))
+gpu_promote_type(::typeof(*), ::Type{T}) where {T<:Number} = typeof(one(T)*one(T))
+gpu_promote_type(::typeof(Base.scalarmax), ::Type{T}) where {T<:Base.WidenReduceResult} = T
+gpu_promote_type(::typeof(Base.scalarmin), ::Type{T}) where {T<:Base.WidenReduceResult} = T
+gpu_promote_type(::typeof(max), ::Type{T}) where {T<:Base.WidenReduceResult} = T
+gpu_promote_type(::typeof(min), ::Type{T}) where {T<:Base.WidenReduceResult} = T
 
-function Base.mapreduce{T, N}(f::Function, op::Function, A::GPUArray{T, N})
+function Base.mapreduce(f::Function, op::Function, A::GPUArray{T, N}) where {T, N}
     OT = gpu_promote_type(op, T)
     v0 = startvalue(op, OT) # TODO do this better
     mapreduce(f, op, v0, A)
@@ -117,9 +117,9 @@ end
 to_cpu(x) = x
 to_cpu(x::GPUArray) = Array(x)
 
-function acc_mapreduce{T, OT, N}(
+function acc_mapreduce(
         f, op, v0::OT, A::GPUArray{T, N}, rest::Tuple
-    )
+    ) where {T, OT, N}
     dev = device(A)
     blocksize = 80
     threads = 256