Consistency

Author: christiangnrd

src/array.jl

@@ -479,7 +479,7 @@ Base.unsafe_convert(::Type{MTL.MTLBuffer}, A::PermutedDimsArray) =
 ## unsafe_wrap
 
 function Base.unsafe_wrap(::Type{<:Array}, arr::MtlArray{T,N}, dims=size(arr); own=false) where {T,N}
-  return unsafe_wrap(Array{T,N}, arr.data[], dims; own=own)
+  return unsafe_wrap(Array{T,N}, arr.data[], dims; own)
 end
 
 function Base.unsafe_wrap(t::Type{<:Array{T}}, buf::MTLBuffer, dims; own=false) where T

src/compiler/execution.jl

@@ -253,7 +253,7 @@ end
     end
 
     # pass by reference, in an argument buffer
-    argument_buffer = alloc(kernel.pipeline.device, sizeof(argtyp), storage=Shared)
+    argument_buffer = alloc(kernel.pipeline.device, sizeof(argtyp); storage=Shared)
     argument_buffer.label = "MTLBuffer for kernel argument"
     unsafe_store!(convert(Ptr{argtyp}, argument_buffer), arg)
     return argument_buffer

src/memory.jl

@@ -35,10 +35,10 @@ function Base.unsafe_copyto!(dev::MTLDevice, dst::MtlPointer{T}, src::Ptr{T}, N:
     storage_type = dst.buffer.storageMode
     if storage_type == MTL.MTLStorageModePrivate
         # stage through a shared buffer
-        # shared = alloc(dev, N*sizeof(T), src, storage=Shared)
+        # shared = alloc(dev, N*sizeof(T), src; storage=Shared)
         # unsafe_copyto!(dev, dst, pointer(shared), N; queue, async=false)
         # free(shared)
-        tmp_buf = alloc(dev, N*sizeof(T), src, storage=Shared) #CPU -> GPU (Shared)
+        tmp_buf = alloc(dev, N*sizeof(T), src; storage=Shared) #CPU -> GPU (Shared)
         unsafe_copyto!(dev, MtlPointer{T}(dst.buffer, dst.offset), MtlPointer{T}(tmp_buf, 0), N; queue, async=false) # GPU (Shared) -> GPU (Private)
         free(tmp_buf)
     elseif storage_type == MTL.MTLStorageModeShared
@@ -56,7 +56,7 @@ function Base.unsafe_copyto!(dev::MTLDevice, dst::Ptr{T}, src::MtlPointer{T}, N:
     storage_type = src.buffer.storageMode
     if storage_type ==  MTL.MTLStorageModePrivate
         # stage through a shared buffer
-        shared = alloc(dev, N*sizeof(T), storage=Shared)
+        shared = alloc(dev, N*sizeof(T); storage=Shared)
         unsafe_copyto!(dev, MtlPointer{T}(shared, 0), MtlPointer{T}(src.buffer, src.offset), N; queue, async=false)
         unsafe_copyto!(dst, convert(Ptr{T}, shared), N)
         free(shared)

test/array.jl

@@ -72,7 +72,7 @@ check_storagemode(arr, smode) = Metal.storagemode(arr) == smode
     N = length(dim)
 
     # mtl
-    let arr = mtl(rand(2,2), storage= SM)
+    let arr = mtl(rand(2,2); storage= SM)
         @test check_storagemode(arr,  SM)
     end
 
@@ -134,7 +134,7 @@ check_storagemode(arr, smode) = Metal.storagemode(arr) == smode
         end
 
         let b = rand(Float32, 10)
-            arr_mtl = mtl(b, storage=Private)
+            arr_mtl = mtl(b; storage=Private)
             @test_throws ErrorException arr_mtl[1]
             @test Metal.@allowscalar arr_mtl[1] == b[1]
         end
@@ -145,7 +145,7 @@ check_storagemode(arr, smode) = Metal.storagemode(arr) == smode
         end
 
         let b = rand(Float32, 10)
-            arr_mtl = mtl(b, storage=Shared)
+            arr_mtl = mtl(b; storage=Shared)
             @test arr_mtl[1] == b[1]
         end
     elseif SM == Metal.Managed
@@ -155,7 +155,7 @@ check_storagemode(arr, smode) = Metal.storagemode(arr) == smode
         end
 
         let b = rand(Float32, 10)
-            arr_mtl = mtl(b, storage=Managed)
+            arr_mtl = mtl(b; storage=Managed)
             @test arr_mtl[1] == b[1]
         end
     end