Remove support for s backed by managed storage. (#649)

Author: christiangnrd

.buildkite/pipeline.yml

@@ -37,10 +37,10 @@ steps:
               soft_fail: true
 
   # special tests
-  - group: ":floppy_disk: Storage Modes"
+  - group: ":floppy_disk: Shared (unified) Storage"
     depends_on: "julia"
     steps:
-      - label: "{{matrix.storage}} array storage"
+      - label: "shared array storage"
         plugins:
           - JuliaCI/julia#v1:
               version: "1.11"
@@ -57,13 +57,8 @@ steps:
             build.message !~ /\[skip tests\]/ &&
             build.message !~ /\[skip storage\]/
         timeout_in_minutes: 60
-        matrix:
-          setup:
-            storage:
-              - "shared"
-              - "managed"
         commands: |
-          echo -e "[Metal]\ndefault_storage = \"{{matrix.storage}}\"" >LocalPreferences.toml
+          echo -e "[Metal]\ndefault_storage = \"shared\"" >LocalPreferences.toml
 
   # special tests
   - group: ":eyes: Special"

lib/mtl/storage_type.jl

@@ -5,7 +5,7 @@ export ReadUsage, WriteUsage, ReadWriteUsage
 # SharedStorage  -> Buffer in Host memory, accessed by the GPU. Requires no sync
 # ManagedStorage -> Mirrored memory buffers in host and GPU. Requires syncing
 # PrivateStorage -> Memory in Device, not accessible by Host.
-# Memoryless -> iOS stuff. ignore it
+# Memoryless -> render pipeline stuff. ignore it (for now)
 
 abstract type StorageMode end
 
@@ -16,7 +16,7 @@ Used to indicate that the resource is stored using `MTLStorageModeShared` in mem
 
 For more information on Metal storage modes, refer to the official Metal documentation.
 
-See also [`Metal.PrivateStorage`](@ref) and [`Metal.ManagedStorage`](@ref).
+See also [`Metal.PrivateStorage`](@ref).
 """
 struct SharedStorage  <: StorageMode end
 
@@ -27,6 +27,9 @@ Used to indicate that the resource is stored using `MTLStorageModeManaged` in me
 
 For more information on Metal storage modes, refer to the official Metal documentation.
 
+!!! warning
+    `ManagedStorage` is no longer supported with `MtlArray`s. Instead, use `SharedStorage` or use the Metal api directly from `Metal.MTL`.
+
 See also [`Metal.SharedStorage`](@ref) and [`Metal.PrivateStorage`](@ref).
 """
 struct ManagedStorage <: StorageMode end
@@ -38,15 +41,14 @@ Used to indicate that the resource is stored using `MTLStorageModePrivate` in me
 
 For more information on Metal storage modes, refer to the official Metal documentation.
 
-See also [`Metal.SharedStorage`](@ref) and [`Metal.ManagedStorage`](@ref).
+See also [`Metal.SharedStorage`](@ref).
 """
 struct PrivateStorage <: StorageMode end
 struct Memoryless     <: StorageMode end
 
 # Remove the ".MTL" when printing
 Base.show(io::IO, ::Type{<:PrivateStorage}) = print(io, "Metal.PrivateStorage")
 Base.show(io::IO, ::Type{<:SharedStorage}) = print(io, "Metal.SharedStorage")
-Base.show(io::IO, ::Type{<:ManagedStorage}) = print(io, "Metal.ManagedStorage")
 
 """
     MTL.CPUStorage

src/array.jl

@@ -39,7 +39,7 @@ end
 
 `N`-dimensional Metal array with storage mode `S` and elements of type `T`.
 
-`S` can be `Metal.PrivateStorage` (default), `Metal.SharedStorage`, or `Metal.ManagedStorage`.
+`S` can be `Metal.PrivateStorage` (default), `Metal.SharedStorage`.
 
 See the Array Programming section of the Metal.jl docs for more details.
 """
@@ -96,6 +96,7 @@ mutable struct MtlArray{T,N,S} <: AbstractGPUArray{T,N}
         obj = if storagemode == MTL.MTLStorageModeShared
             new{T,N,SharedStorage}(copy(data), maxsize, offset, dims)
         elseif storagemode == MTL.MTLStorageModeManaged
+            @warn "`ManagedStorage` is no longer supported with `MtlArray`s. Instead, use `SharedStorage` or use the Metal api directly from `Metal.MTL`."
             new{T,N,ManagedStorage}(copy(data), maxsize, offset, dims)
         elseif storagemode == MTL.MTLStorageModePrivate
             new{T,N,PrivateStorage}(copy(data), maxsize, offset, dims)
@@ -140,6 +141,9 @@ is_shared(A::MtlArray) = storagemode(A) == SharedStorage
 
 Returns true if `A` has storage mode [`Metal.ManagedStorage`](@ref).
 
+!!! warning
+    `ManagedStorage` is no longer supported with `MtlArray`s. Instead, use `SharedStorage` or use the Metal api directly from `Metal.MTL`.
+
 See also [`is_shared`](@ref) and [`is_private`](@ref).
 """
 is_managed(A::MtlArray) = storagemode(A) == ManagedStorage
@@ -149,7 +153,7 @@ is_managed(A::MtlArray) = storagemode(A) == ManagedStorage
 
 Returns true if `A` has storage mode [`Metal.PrivateStorage`](@ref).
 
-See also [`is_shared`](@ref) and [`is_managed`](@ref).
+See also [`is_shared`](@ref).
 """
 is_private(A::MtlArray) = storagemode(A) == PrivateStorage
 
@@ -192,8 +196,6 @@ const DefaultStorageMode = let str = @load_preference("default_storage", "privat
         PrivateStorage
     elseif str == "shared"
         SharedStorage
-    elseif str == "managed"
-        ManagedStorage
     else
         error("unknown default storage mode: $default_storage")
     end
@@ -247,7 +249,7 @@ Base.sizeof(x::MtlArray) = Base.elsize(x) * length(x)
 @inline function Base.pointer(x::MtlArray{T}, i::Integer=1; storage=PrivateStorage) where {T}
     PT = if storage == PrivateStorage
         MtlPtr{T}
-    elseif storage == SharedStorage || storage == ManagedStorage
+    elseif storage == SharedStorage
         Ptr{T}
     else
         error("unknown memory type")
@@ -272,12 +274,12 @@ end
 
 
 ## indexing
-function Base.getindex(x::MtlArray{T,N,S}, I::Int) where {T,N,S<:Union{SharedStorage,ManagedStorage}}
+function Base.getindex(x::MtlArray{T,N,S}, I::Int) where {T,N,S<:SharedStorage}
     @boundscheck checkbounds(x, I)
     unsafe_load(pointer(x, I; storage=S))
 end
 
-function Base.setindex!(x::MtlArray{T,N,S}, v, I::Int) where {T,N,S<:Union{SharedStorage,ManagedStorage}}
+function Base.setindex!(x::MtlArray{T,N,S}, v, I::Int) where {T,N,S<:SharedStorage}
     @boundscheck checkbounds(x, I)
     unsafe_store!(pointer(x, I; storage=S), v)
 end
@@ -481,7 +483,7 @@ Adapt.adapt_storage(::MtlArrayAdaptor{S}, xs::AbstractArray{T,N}) where {T<:Comp
 """
     mtl(A; storage=Metal.PrivateStorage)
 
-`storage` can be `Metal.PrivateStorage` (default), `Metal.SharedStorage`, or `Metal.ManagedStorage`.
+`storage` can be `Metal.PrivateStorage` (default) or `Metal.SharedStorage`.
 
 Opinionated GPU array adaptor, which may alter the element type `T` of arrays:
 * For `T<:AbstractFloat`, it makes a `MtlArray{Float32}` for performance and compatibility

src/memory.jl

@@ -44,9 +44,6 @@ function Base.unsafe_copyto!(dev::MTLDevice, dst::MtlPtr{T}, src::Ptr{T}, N::Int
         free(tmp_buf)
     elseif storage_type == MTL.MTLStorageModeShared
         unsafe_copyto!(convert(Ptr{T}, dst), src, N)
-    elseif storage_type == MTL.MTLStorageModeManaged
-        unsafe_copyto!(convert(Ptr{T}, dst), src, N)
-        MTL.DidModifyRange!(dst.buffer, 1:N)
     end
     return dst
 end
@@ -73,14 +70,6 @@ function Base.unsafe_copyto!(dev::MTLDevice, dst::Ptr{T}, src::MtlPtr{T}, N::Int
         free(tmp_buf)
     elseif storage_type ==  MTL.MTLStorageModeShared
         unsafe_copyto!(dst, convert(Ptr{T}, src), N)
-    elseif storage_type ==  MTL.MTLStorageModeManaged
-        cmdbuf = MTLCommandBuffer(queue) do cmdbuf
-            MTLBlitCommandEncoder(cmdbuf) do enc
-                append_sync!(enc, src.buffer)
-            end
-        end
-        wait_completed(cmdbuf)
-        unsafe_copyto!(dst, convert(Ptr{T}, src), N)
     end
     return dst
 end

src/pool.jl

@@ -35,7 +35,7 @@ const alloc_stats = AllocStats()
     alloc(device, bytesize, [ptr=nothing];
           storage=Default, hazard_tracking=Default, cache_mode=Default)
 
-Allocates a Metal buffer on `device` of`bytesize` bytes. If a CPU-pointer is passed as last
+Allocates a Metal buffer on `device` of `bytesize` bytes. If a CPU-pointer is passed as last
 argument, then the buffer is initialized with the content of the memory starting at `ptr`,
 otherwise it's zero-initialized.
 
@@ -44,9 +44,7 @@ otherwise it's zero-initialized.
 The storage kwarg controls where the buffer is stored. Possible values are:
  - PrivateStorage : Residing on the device
  - SharedStorage  : Residing on the host
- - ManagedStorage : Keeps two copies of the buffer, on device and on host. Explicit calls must be
-   given to syncronize the two
- - Memoryless : an iOS specific thing that won't work on Mac.
+ - Memoryless : A render pipeline exclusive mode. Render pipelines are not yet supported on Metal.jl.
 
 Note that `PrivateStorage` buffers can't be directly accessed from the CPU, therefore you cannot
 use this option if you pass a ptr to initialize the memory.

test/array.jl

@@ -1,4 +1,4 @@
-STORAGEMODES = [Metal.PrivateStorage, Metal.SharedStorage, Metal.ManagedStorage]
+STORAGEMODES = [Metal.PrivateStorage, Metal.SharedStorage]
 
 @testset "array" begin
 
@@ -158,7 +158,7 @@ check_storagemode(arr, smode) = Metal.storagemode(arr) == smode
     # private storage errors.
     if SM == Metal.PrivateStorage
         let arr_mtl = Metal.zeros(Float32, dim...; storage=Metal.PrivateStorage)
-            @test is_private(arr_mtl) && !is_shared(arr_mtl) && !is_managed(arr_mtl)
+            @test is_private(arr_mtl) && !is_shared(arr_mtl)
             @test_throws "Cannot access the contents of a private buffer" arr_cpu = unsafe_wrap(Array{Float32}, arr_mtl, dim)
         end
 
@@ -169,24 +169,14 @@ check_storagemode(arr, smode) = Metal.storagemode(arr) == smode
         end
     elseif SM == Metal.SharedStorage
         let arr_mtl = Metal.zeros(Float32, dim...; storage=Metal.SharedStorage)
-            @test !is_private(arr_mtl) && is_shared(arr_mtl) && !is_managed(arr_mtl)
+            @test !is_private(arr_mtl) && is_shared(arr_mtl)
             @test unsafe_wrap(Array{Float32}, arr_mtl) isa Array{Float32}
         end
 
         let b = rand(Float32, 10)
             arr_mtl = mtl(b; storage=Metal.SharedStorage)
             @test arr_mtl[1] == b[1]
         end
-    elseif SM == Metal.ManagedStorage
-        let arr_mtl = Metal.zeros(Float32, dim...; storage=Metal.ManagedStorage)
-            @test !is_private(arr_mtl) && !is_shared(arr_mtl) && is_managed(arr_mtl)
-            @test unsafe_wrap(Array{Float32}, arr_mtl) isa Array{Float32}
-        end
-
-        let b = rand(Float32, 10)
-            arr_mtl = mtl(b; storage=Metal.ManagedStorage)
-            @test arr_mtl[1] == b[1]
-        end
     end
 end