Merge branch 'master' into sd/tuple_brc

Author: SimonDanisch

src/blas.jl

@@ -42,8 +42,9 @@ end
 Base.scale!(s::Real, X::GPUArray) = scale!(X, s)
 function Base.scale!(X::GPUArray{T}, s::Real) where T <: BLAS.BlasComplex
     R = typeof(real(zero(T)))
-    buff = reinterpret(R, vec(X))
-    BLAS.scal!(2*length(X), R(s), buff, 1)
+    N = 2*length(X)
+    buff = unsafe_reinterpret(R, X, (N,))
+    BLAS.scal!(N, R(s), buff, 1)
     X
 end
 function Base.scale!(X::GPUArray{T}, s::Real) where T <: Union{Float32, Float64}

src/broadcast.jl

@@ -104,10 +104,17 @@ function Base.foreach(func, over::GPUArray, Bs...)
 end
 
 
-arg_length(x::Array) = error("No array in GPU Broadcast supported. Try converting it to a gpu array")
+function arg_length(x::AbstractArray)
+    if !Base.datatype_pointerfree(x)
+        error("Arrays type contains pointer - this doesn't work on the GPU (So arrays that don't contain pointers to memory, e.g. UnitRanges, would work).
+            Try converting it to a gpu array. Found: $(typeof(x))"
+        )
+    end
+    UInt32.(size(x))
+end
 arg_length(x::Tuple) = (UInt32(length(x)),)
 arg_length(x::GPUArray) = UInt32.(size(x))
-arg_length(x) = ()
+arg_length(x) = () # Scalar
 
 struct BInfo{Typ, N}
     size::NTuple{N, UInt32}

src/construction.jl

@@ -45,8 +45,8 @@ function convert(AT::Type{<: GPUArray{T, N}}, A::DenseArray{T, N}) where {T, N}
     copy!(AT(Base.size(A)), A)
 end
 
-function convert(AT::Type{<: GPUArray{T1}}, A::DenseArray{T2}) where {T1, T2}
-    copy!(similar(AT, T1, size(A)), T1.(A))
+function convert(AT::Type{<: GPUArray{T1}}, A::DenseArray{T2, N}) where {T1, T2, N}
+    copy!(similar(AT, T1, size(A)), convert(Array{T1, N}, A))
 end
 function convert(AT::Type{<: GPUArray}, A::DenseArray{T2, N}) where {T2, N}
     copy!(similar(AT, T2, size(A)), A)

src/jlbackend.jl

@@ -34,7 +34,7 @@ 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}
-    JLArray(collect(reshape(reinterpret(T, A.data), size)))
+    JLArray{T, N}(reinterpret(T, A.data, size), size)
 end
 
 function copy!(

src/testsuite/blas.jl

@@ -9,12 +9,16 @@ function run_blas(Typ)
             against_base(*, T, (5, 5), (5, 5))
             against_base(*, T, (5, 5), (5,))
             against_base(A_mul_Bt, T, (5, 5), (5, 5))
+            against_base(A_mul_Bt!, T, (10, 32), (10, 60), (32, 60))
             against_base(At_mul_B, T, (5, 5), (5, 5))
+            against_base(At_mul_Bt, T, (10, 15), (1, 10))
+            against_base(At_mul_B, T, (10, 15), (10,))
+            against_base(A_mul_B!, T, (15,), (15, 10), (10,))
+        end
+        for T in (Complex64, Float32)
+            @testset "scale! $T" begin
+                against_base(scale!, Typ{T}, (13, 23), 77f0)
+            end
         end
-        # for T in (Complex64, Float32)
-        #     @testset "scale!" begin
-        #         against_base(scale!, Typ{T}, (13, 23), 77f0)
-        #     end
-        # end
     end
 end

src/testsuite/testsuite.jl

@@ -8,6 +8,7 @@ module TestSuite
 using Base.Test
 
 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

test/convolution.jl

@@ -1,16 +1,3 @@
-using GPUArrays, Colors, FileIO, ImageFiltering
-using CLArrays
-using GPUArrays: synchronize_threads
-import GPUArrays: LocalMemory
-using CLArrays
-
-
-img = RGB{Float32}.(load(homedir()*"/Desktop/backround.jpg"));
-
-a = CLArray(img);
-out = similar(a);
-k = CLArray(Float32.(collect(Kernel.gaussian(3))));
-imgc = similar(img)
 
 # convolution!(a, out, k);
 # Array(out)