Rename MtlPointer to MtlPtr

For consistency with `Ptr` and `CuPtr`

Author: christiangnrd

src/array.jl

@@ -169,7 +169,7 @@ Base.sizeof(x::MtlArray) = Base.elsize(x) * length(x)
 
 @inline function Base.pointer(x::MtlArray{T}, i::Integer=1; storage=Private) where {T}
   PT = if storage == Private
-    MtlPointer{T}
+    MtlPtr{T}
   elseif storage == Shared || storage == Managed
     Ptr{T}
   else
@@ -179,9 +179,9 @@ Base.sizeof(x::MtlArray) = Base.elsize(x) * length(x)
 end
 
 
-function Base.unsafe_convert(::Type{MtlPointer{T}}, x::MtlArray) where {T}
+function Base.unsafe_convert(::Type{MtlPtr{T}}, x::MtlArray) where {T}
    buf = x.data[]
-   MtlPointer{T}(buf, x.offset*Base.elsize(x))
+   MtlPtr{T}(buf, x.offset*Base.elsize(x))
  end
 
 function Base.unsafe_convert(::Type{Ptr{S}}, x::MtlArray{T}) where {S, T}
@@ -487,7 +487,7 @@ function Base.unsafe_wrap(t::Type{<:Array{T}}, buf::MTLBuffer, dims; own=false)
     return unsafe_wrap(t, ptr, dims; own)
 end
 
-function Base.unsafe_wrap(t::Type{<:Array{T}}, ptr::MtlPointer{T}, dims; own=false) where T
+function Base.unsafe_wrap(t::Type{<:Array{T}}, ptr::MtlPtr{T}, dims; own=false) where T
     return unsafe_wrap(t, convert(Ptr{T}, ptr), dims; own)
 end
 
@@ -513,7 +513,7 @@ function Base.resize!(A::MtlVector{T}, n::Integer) where T
   # replace the data with a new one. this 'unshares' the array.
   # as a result, we can safely support resizing unowned buffers.
   buf = alloc(device(A), bufsize; storage=storagemode(A))
-  ptr = MtlPointer{T}(buf)
+  ptr = MtlPtr{T}(buf)
   m = min(length(A), n)
   if m > 0
     unsafe_copyto!(device(A), ptr, pointer(A), m)

src/compiler/execution.jl

@@ -112,7 +112,7 @@ function Adapt.adapt_storage(to::Adaptor, buf::MTLBuffer)
     end
     reinterpret(Core.LLVMPtr{Nothing,AS.Device}, buf.gpuAddress)
 end
-function Adapt.adapt_storage(to::Adaptor, ptr::MtlPointer{T}) where {T}
+function Adapt.adapt_storage(to::Adaptor, ptr::MtlPtr{T}) where {T}
     reinterpret(Core.LLVMPtr{T,AS.Device}, adapt(to, ptr.buffer)) + ptr.offset
 end
 
@@ -209,7 +209,7 @@ const _kernel_instances = Dict{UInt, Any}()
     end
 
     # the arguments passed into this function have not been `mtlconvert`ed, because we need
-    # to retain the top-level MTLBuffer and MtlPointer objects. eager conversion of nested
+    # to retain the top-level MTLBuffer and MtlPtr objects. eager conversion of nested
     # such objects to LLVMPtr seems fine, somehow.
     # TODO: can we just convert everything eagerly and support top-level LLVMPtrs?
 
@@ -219,7 +219,7 @@ const _kernel_instances = Dict{UInt, Any}()
         if argtyp <: MTLBuffer
             # top-level buffers are passed as a pointer-valued argument
             push!(ex.args, :(set_buffer!(cce, $argex, 0, $idx)))
-        elseif argtyp <: MtlPointer
+        elseif argtyp <: MtlPtr
             # the same as a buffer, but with an offset
             push!(ex.args, :(set_buffer!(cce, $argex.buffer, $argex.offset, $idx)))
         elseif isghosttype(argtyp) || Core.Compiler.isconstType(argtyp)

src/memory.jl

@@ -7,30 +7,30 @@
 # we cannot take a MTLBuffer's handle and work with that as it were a pointer to memory.
 # instead, the Metal APIs always take the original handle and an offset parameter.
 
-struct MtlPointer{T}
+struct MtlPtr{T}
     buffer::MTLBuffer
     offset::UInt    # in bytes
 
-    function MtlPointer{T}(buffer::MTLBuffer, offset=0) where {T}
+    function MtlPtr{T}(buffer::MTLBuffer, offset=0) where {T}
         new(buffer, offset)
     end
 end
 
-Base.eltype(::Type{<:MtlPointer{T}}) where {T} = T
+Base.eltype(::Type{<:MtlPtr{T}}) where {T} = T
 
 # limited arithmetic
-Base.:(+)(x::MtlPointer{T}, y::Integer) where {T} = MtlPointer{T}(x.buffer, x.offset+y)
-Base.:(-)(x::MtlPointer{T}, y::Integer) where {T} = MtlPointer{T}(x.buffer, x.offset-y)
-Base.:(+)(x::Integer, y::MtlPointer{T}) where {T} = MtlPointer{T}(x.buffer, y+x.offset)
+Base.:(+)(x::MtlPtr{T}, y::Integer) where {T} = MtlPtr{T}(x.buffer, x.offset+y)
+Base.:(-)(x::MtlPtr{T}, y::Integer) where {T} = MtlPtr{T}(x.buffer, x.offset-y)
+Base.:(+)(x::Integer, y::MtlPtr{T}) where {T} = MtlPtr{T}(x.buffer, y+x.offset)
 
-Base.convert(::Type{Ptr{T}}, ptr::MtlPointer) where {T} =
+Base.convert(::Type{Ptr{T}}, ptr::MtlPtr) where {T} =
     convert(Ptr{T}, ptr.buffer) + ptr.offset
 
 
 ## operations
 
 # CPU -> GPU
-function Base.unsafe_copyto!(dev::MTLDevice, dst::MtlPointer{T}, src::Ptr{T}, N::Integer;
+function Base.unsafe_copyto!(dev::MTLDevice, dst::MtlPtr{T}, src::Ptr{T}, N::Integer;
                              queue::MTLCommandQueue=global_queue(dev), async::Bool=false) where T
     storage_type = dst.buffer.storageMode
     if storage_type == MTL.MTLStorageModePrivate
@@ -39,7 +39,7 @@ function Base.unsafe_copyto!(dev::MTLDevice, dst::MtlPointer{T}, src::Ptr{T}, N:
         # 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)
-        unsafe_copyto!(dev, MtlPointer{T}(dst.buffer, dst.offset), MtlPointer{T}(tmp_buf, 0), N; queue, async=false) # GPU (Shared) -> GPU (Private)
+        unsafe_copyto!(dev, MtlPtr{T}(dst.buffer, dst.offset), MtlPtr{T}(tmp_buf, 0), N; queue, async=false) # GPU (Shared) -> GPU (Private)
         free(tmp_buf)
     elseif storage_type == MTL.MTLStorageModeShared
         unsafe_copyto!(convert(Ptr{T}, dst), src, N)
@@ -51,13 +51,13 @@ function Base.unsafe_copyto!(dev::MTLDevice, dst::MtlPointer{T}, src::Ptr{T}, N:
 end
 
 # GPU -> CPU
-function Base.unsafe_copyto!(dev::MTLDevice, dst::Ptr{T}, src::MtlPointer{T}, N::Integer;
+function Base.unsafe_copyto!(dev::MTLDevice, dst::Ptr{T}, src::MtlPtr{T}, N::Integer;
                              queue::MTLCommandQueue=global_queue(dev), async::Bool=false) where T
     storage_type = src.buffer.storageMode
     if storage_type ==  MTL.MTLStorageModePrivate
         # stage through a shared buffer
         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!(dev, MtlPtr{T}(shared, 0), MtlPtr{T}(src.buffer, src.offset), N; queue, async=false)
         unsafe_copyto!(dst, convert(Ptr{T}, shared), N)
         free(shared)
     elseif storage_type ==  MTL.MTLStorageModeShared
@@ -69,8 +69,8 @@ function Base.unsafe_copyto!(dev::MTLDevice, dst::Ptr{T}, src::MtlPointer{T}, N:
 end
 
 # GPU -> GPU
-@autoreleasepool function Base.unsafe_copyto!(dev::MTLDevice, dst::MtlPointer{T},
-                                              src::MtlPointer{T}, N::Integer;
+@autoreleasepool function Base.unsafe_copyto!(dev::MTLDevice, dst::MtlPtr{T},
+                                              src::MtlPtr{T}, N::Integer;
                                               queue::MTLCommandQueue=global_queue(dev),
                                               async::Bool=false) where T
     cmdbuf = MTLCommandBuffer(queue)
@@ -81,7 +81,7 @@ end
     async || wait_completed(cmdbuf)
 end
 
-@autoreleasepool function unsafe_fill!(dev::MTLDevice, ptr::MtlPointer{T},
+@autoreleasepool function unsafe_fill!(dev::MTLDevice, ptr::MtlPtr{T},
                                        value::Union{UInt8,Int8}, N::Integer) where T
     cmdbuf = MTLCommandBuffer(global_queue(dev))
     MTLBlitCommandEncoder(cmdbuf) do enc

test/metal.jl

@@ -454,7 +454,7 @@ end
         arr = Metal.zeros(T, 4)
 
         buf = Base.unsafe_convert(MTL.MTLBuffer, arr)
-        Metal.unsafe_fill!(current_device(), Metal.MtlPointer{T}(buf, 0), T(val), 4)
+        Metal.unsafe_fill!(current_device(), Metal.MtlPtr{T}(buf, 0), T(val), 4)
 
         @test all(Array(arr) .== val)
     end