fix bugs and #5

Author: SimonDanisch

src/array.jl

@@ -9,14 +9,14 @@ import Base: pointer, similar, size, copy!, convert
 using Base: RefValue
 
 mutable struct CLArray{T, N} <: GPUArray{T, N}
-    ptr::OwnedPtr{T}
     size::NTuple{N, Cuint}
+    ptr::OwnedPtr{T}
 end
 
 
 # arguments are swapped to not override default constructor
-function (::Type{CLArray{T, N}})(size::NTuple{N, Integer}, ptr::OwnedPtr{T}) where {T, N}
-    arr = CLArray{T, N}(ptr, size)
+function (::Type{CLArray{T, N}})(ptr::OwnedPtr{T}, size::NTuple{N, Integer}) where {T, N}
+    arr = CLArray{T, N}(size, ptr)
     finalizer(arr, unsafe_free!)
     arr
 end
@@ -32,14 +32,14 @@ module Shorthands
     cl(xs::AbstractArray) = isbits(xs) ? xs : CLArrays.CLArray(xs)
 end
 
-function (::Type{CLArray{T, N}})(size::NTuple{N, Integer}, ctx = global_context()) where {T, N}
+function (::Type{CLArray{T, N}})(size::NTuple{N, Integer}, ctx::cl.Context = global_context()) where {T, N}
     # element type has different padding from cl type in julia
     # for fixedsize arrays we use vload/vstore, so we can use it packed
-    clT = !Transpiler.is_fixedsize_array(T) ? cl.packed_convert(T) : T
+    clT = T #!Transpiler.is_fixedsize_array(T) ? cl.packed_convert(T) : T
     elems = prod(size)
     elems = elems == 0 ? 1 : elems # OpenCL can't allocate 0 sized buffers
     ptr = Mem.alloc(clT, elems, ctx)
-    CLArray{clT, N}(size, ptr)
+    CLArray{clT, N}(ptr, size)
 end
 
 raw_print(msg::AbstractString...) =

src/compilation.jl

@@ -84,15 +84,15 @@ function contains_pointer(
             push!(pointer_fields, (parent_field..., fname))
             hasptr = true
         else
-            _hasptr, pointer_fields = contains_pointer(FT, (fname,), pointer_fields)
+            _hasptr, pointer_fields = contains_pointer(FT, (parent_field..., fname), pointer_fields)
             hasptr |= _hasptr
         end
     end
     hasptr, pointer_fields
 end
 
 get_fields_type(T, fields::Tuple{X}) where X = fieldtype(T, first(fields))
-get_fields_type(T, fields::Tuple{Vararg{Any, N}}) where N = get_fields_type(fieldtype(T, first(fields)), Base.tail(fields))
+get_fields_type(T, fields::NTuple{N, Any}) where N = get_fields_type(fieldtype(T, first(fields)), Base.tail(fields))
 
 get_fields(x, fields::NTuple{1}) = getfield(x, first(fields))
 get_fields(x, fields::NTuple{N, Any}) where N = get_fields(getfield(x, first(fields)), Base.tail(fields))
@@ -250,6 +250,7 @@ function CLFunction(f::F, args::T, ctx = global_context()) where {T, F}
     get!(compiled_functions, (ctx.id, f, cltypes)) do # TODO make this faster
         method = CLMethod((f, cltypes))
         source, fname, ptr_extract = assemble_kernel(method)
+        # println(source)
         options = "-cl-denorms-are-zero -cl-mad-enable -cl-unsafe-math-optimizations"
         if version > v"1.2"
             options *= " -cl-std=CL1.2"

src/ondevice.jl

@@ -14,8 +14,8 @@ using GPUArrays: AbstractDeviceArray
 Array type on the device
 """
 struct DeviceArray{T, N, Ptr} <: AbstractDeviceArray{T, N}
-    ptr::Ptr
     size::NTuple{N, Cuint}
+    ptr::Ptr
 end
 # shaninagans for uploading CLArrays to OpenCL as a DeviceArray
 # (spoiler alert: they can't contain pointers while uploading, but can on the device)
@@ -52,11 +52,13 @@ function setindex!(x::OnDeviceArray{T, N}, val, i::Vararg{Integer, N}) where {T,
 end
 
 
+predevice_type(::Type{T}) where T = T
+
 
-kernel_convert(A::CLArray{T, N}) where {T, N} = PreDeviceArray{T, N}(HostPtr{T}(), A.size)
+kernel_convert(A::CLArray{T, N}) where {T, N} = PreDeviceArray{T, N}(A.size, HostPtr{T}())
 predevice_type(::Type{GlobalArray{T, N}}) where {T, N} = PreDeviceArray{T, N}
 device_type(::CLArray{T, N}) where {T, N} = GlobalArray{T, N}
-reconstruct(x::PreDeviceArray{T, N}, ptr::GlobalPointer{T}) where {T, N} = GlobalArray{T, N}(ptr, x.size)
+reconstruct(x::PreDeviceArray{T, N}, ptr::GlobalPointer{T}) where {T, N} = GlobalArray{T, N}(x.size, ptr)
 
 # some converts to inline CLArrays into tuples and refs
 kernel_convert(x::RefValue{T}) where T <: CLArray = RefValue(kernel_convert(x[]))
@@ -123,8 +125,8 @@ synchronize_threads(::KernelState) = cli.barrier(CLK_LOCAL_MEM_FENCE)
 LocalMemory(state::KernelState, ::Type{T}, ::Val{N}, ::Val{C}) where {T, N, C} = Transpiler.cli.LocalPointer{T}()
 
 function (::Type{AbstractDeviceArray})(ptr::PtrT, shape::Vararg{Integer, N}) where PtrT <: Transpiler.cli.LocalPointer{T} where {T, N}
-    DeviceArray{T, N, PtrT}(ptr, shape)
+    DeviceArray{T, N, PtrT}(shape, ptr)
 end
 function (::Type{AbstractDeviceArray})(ptr::PtrT, shape::NTuple{N, Integer}) where PtrT <: Transpiler.cli.LocalPointer{T} where {T, N}
-    DeviceArray{T, N, PtrT}(ptr, shape)
+    DeviceArray{T, N, PtrT}(shape, ptr)
 end

test/runtests.jl

@@ -1,8 +1,10 @@
 using CLArrays
 using GPUArrays.TestSuite, Base.Test
+
 for dev in CLArrays.devices()
     CLArrays.init(dev)
     @testset "Device: $dev" begin
+
         TestSuite.run_tests(CLArray)
 
         @testset "muladd & abs" begin
@@ -31,15 +33,98 @@ for dev in CLArrays.devices()
     end
 end
 
-# The above is equal to:
-# Typ = CuArray
+# #The above is equal to:
+# Typ = CLArray
 # GPUArrays.allowslow(false)
 # TestSuite.run_gpuinterface(Typ)
 # TestSuite.run_base(Typ)
 # TestSuite.run_blas(Typ)
-# TestSuite.run_broadcasting(Typ)
+# TestSuite.run_broadcasting(CLArray)
 # TestSuite.run_construction(Typ)
 # TestSuite.run_fft(Typ)
 # TestSuite.run_linalg(Typ)
 # TestSuite.run_mapreduce(Typ)
 # TestSuite.run_indexing(Typ)
+#
+# function test_sizes6(state, out)
+#     x1 = (1, 2, 3)
+#     out[1] = sizeof(x1)
+#
+#     x2 = (1f0, 2f0, 3f0)
+#     out[2] = sizeof(x2)
+#
+#     x3 = ((1f0, 2f0), 1.0)
+#     out[3] = sizeof(x3)
+#
+#     x4 = ((1f0, 2f0, 3f0), 1.0)
+#     out[4] = sizeof(x4)
+#
+#     x5 = ((1f0, 2f0, 3f0, 4f0), 1.0)
+#     out[5] = sizeof(x5)
+#
+#     x6 = (1.0, (1f0, 2f0))
+#     out[6] = sizeof(x6)
+#
+#     x7 = (1.0, (1f0, 2f0, 3f0))
+#     out[7] = sizeof(x7)
+#
+#     x8 = (1.0, (1f0, 2f0, 3f0, 4f0))
+#     out[8] = sizeof(x8)
+#
+#     x9 = ((1f0, 2f0), UInt32(1), 1.0)
+#     out[9] = sizeof(x9)
+#
+#     return
+# end
+#
+# function test_sizes6(state, out)
+#     x1 = 1
+#     out[1] = sizeof(x1)
+#
+#     x2 = (1, 2)
+#     out[2] = sizeof(x2)
+#
+#     x3 = (1, 2, 3)
+#     out[3] = sizeof(x3)
+#
+#     x4 = 1f0
+#     out[4] = sizeof(x4)
+#
+#     x5 = (1f0, 2f0)
+#     out[5] = sizeof(x5)
+#
+#     x6 = (1f0, 2f0, 3f0)
+#     out[6] = sizeof(x6)
+#
+#     x7 = (1f0, 2f0, 3f0, 4f0, 5f0)
+#     out[7] = sizeof(x7)
+#
+#     x8 =  (1f0, 2f0, 3f0, 4f0, 5f0, 6f0)
+#     out[8] = sizeof(x8)
+#
+#     x9 = (1, 2, 3, 4, 5, 6)
+#     out[9] = sizeof(x9)
+#
+#     x10 = UInt8(1)
+#     out[10] = sizeof(x10)
+#
+#     x11 = (x10, x10)
+#     out[11] = sizeof(x11)
+#
+#     x12 = (x10, x10, x10)
+#     out[12] = sizeof(x12)
+#
+#
+#     x13 = CLArrays.DeviceArray{Complex{Float64},3,CLArrays.HostPtr{Complex{Float64}}}(
+#         CLArrays.HostPtr{Complex{Float64}}(),
+#         (Cuint(2), Cuint(2), Cuint(2))
+#     )
+#     out[13] = sizeof(x13)
+#     #
+#     # x14 = (x13, x13)
+#     # out[14] = sizeof(x14)
+#     #
+#     # x15 = (x13, x13, x13)
+#     # out[15] = sizeof(x15)
+#     return
+# end