WIP: Refactor memory hierarchy.

Author: maleadt

LocalPreferences.toml

@@ -1,7 +1,7 @@
 [OpenCL]
 # Which memory back-end to use for unspecified CLArray allocations. This can be:
 # - "usm": Unified Shared Memory (`cl_intel_unified_shared_memory`)
-# - "bda": Buffer Device Address (`cl_mem` + `cl_ext_buffer_device_address`)
+# - "bda": plain buffers (`cl_mem` + `cl_ext_buffer_device_address`)
 # - "svm": Shared Virtual Memory (coarse-grained)
 # If unspecified, the default will be used based on the platform and device capabilities.
 #default_memory_backend="..."

lib/cl/CL.jl

@@ -20,8 +20,7 @@ include("device.jl")
 include("context.jl")
 include("cmdqueue.jl")
 include("event.jl")
-include("buffer.jl")
-include("memory/memory.jl")
+include("memory.jl")
 include("program.jl")
 include("kernel.jl")
 

lib/cl/kernel.jl

@@ -79,7 +79,7 @@ function set_arg!(k::Kernel, idx::Integer, arg::AbstractMemory)
         clSetKernelArgSVMPointer(k, idx - 1, pointer(arg))
     elseif arg isa UnifiedMemory
         clSetKernelArgMemPointerINTEL(k, idx - 1, pointer(arg))
-    elseif arg isa BufferDeviceMemory
+    elseif arg isa Buffer
         clSetKernelArgDevicePointerEXT(k, idx - 1, pointer(arg))
     else
         error("Unknown memory type")
@@ -203,7 +203,7 @@ function call(
 
             if memory isa SharedVirtualMemory
                 push!(svm_pointers, ptr)
-            elseif memory isa BufferDeviceMemory
+            elseif memory isa Buffer
                 push!(bda_pointers, ptr)
             elseif memory isa UnifiedDeviceMemory
                 device_access = true

lib/cl/memory.jl

@@ -0,0 +1,99 @@
+# Raw memory management
+
+abstract type AbstractMemoryObject <: CLObject end
+abstract type AbstractPointerMemory end
+const AbstractMemory = Union{AbstractMemoryObject, AbstractPointerMemory}
+
+# this will be specialized for each memory type
+Base.convert(T::Type{<:Union{Ptr, CLPtr}}, mem::AbstractMemory) =
+    throw(ArgumentError("Illegal conversion of a $(typeof(mem)) to a $T"))
+
+# ccall integration
+#
+# taking the pointer of a memory object means returning the underlying pointer,
+# and not the pointer of the object itself.
+Base.unsafe_convert(P::Type{<:Union{Ptr, CLPtr}}, mem::AbstractMemory) = convert(P, mem)
+
+
+## opaque memory objects
+
+# This should be implemented by all subtypes
+#type MemoryType <: AbstractMemoryObject
+#    id::cl_mem
+#    ...
+#end
+
+Base.sizeof(mem::AbstractMemoryObject) = mem.size
+
+release(mem::AbstractMemoryObject) = clReleaseMemObject(mem)
+
+function Base.getproperty(mem::AbstractMemoryObject, s::Symbol)
+    if s == :type
+        result = Ref{cl_mem_object_type}()
+        clGetMemObjectInfo(mem, CL_MEM_TYPE, sizeof(cl_mem_object_type), result, C_NULL)
+        return result[]
+    elseif s == :flags
+        result = Ref{cl_mem_flags}()
+        clGetMemObjectInfo(mem, CL_MEM_FLAGS, sizeof(cl_mem_flags), result, C_NULL)
+        mf = result[]
+        flags = Symbol[]
+        if (mf & CL_MEM_READ_WRITE) != 0
+            push!(flags, :rw)
+        end
+        if (mf & CL_MEM_WRITE_ONLY) != 0
+            push!(flags, :w)
+        end
+        if (mf & CL_MEM_READ_ONLY) != 0
+            push!(flags, :r)
+        end
+        if (mf & CL_MEM_USE_HOST_PTR) != 0
+            push!(flags, :use)
+        end
+        if (mf & CL_MEM_ALLOC_HOST_PTR) != 0
+            push!(flags, :alloc)
+        end
+        if (mf & CL_MEM_COPY_HOST_PTR) != 0
+            push!(flags, :copy)
+        end
+        return tuple(flags...)
+    elseif s == :size
+        result = Ref{Csize_t}()
+        clGetMemObjectInfo(mem, CL_MEM_SIZE, sizeof(Csize_t), result, C_NULL)
+        return result[]
+    elseif s == :reference_count
+        result = Ref{Cuint}()
+        clGetMemObjectInfo(mem, CL_MEM_REFERENCE_COUNT, sizeof(Cuint), result, C_NULL)
+        return Int(result[])
+    elseif s == :map_count
+        result = Ref{Cuint}()
+        clGetMemObjectInfo(mem, CL_MEM_MAP_COUNT, sizeof(Cuint), result, C_NULL)
+        return Int(result[])
+    elseif s == :device_address
+        result = Ref{cl_mem_device_address_ext}()
+        clGetMemObjectInfo(mem, CL_MEM_DEVICE_ADDRESS_EXT, sizeof(cl_mem_device_address_ext), result, C_NULL)
+        return CLPtr{Cvoid}(result[])
+    else
+        return getfield(mem, s)
+    end
+end
+
+# for passing buffers to OpenCL APIs: use the underlying handle
+Base.unsafe_convert(::Type{cl_mem}, mem::AbstractMemoryObject) = mem.id
+
+# for passing buffers to kernels: pass the private device pointer
+Base.convert(::Type{CLPtr{T}}, mem::AbstractMemoryObject) where {T} =
+    convert(CLPtr{T}, pointer(mem))
+# XXX: for passing buffers directly, we can support non-BDA drivers
+#      by postponing the conversion to `cl.set_arg!`
+#Base.unsafe_convert(::Type{<:Ptr}, mem::AbstractMemoryObject) = mem
+
+include("memory/buffer.jl")
+
+#TODO: enqueue_migrate_mem_objects(queue, mem_objects, flags=0, wait_for=None)
+#TODO: enqueue_migrate_mem_objects_ext(queue, mem_objects, flags=0, wait_for=None)
+
+
+## pointer-based memory
+
+include("memory/usm.jl")
+include("memory/svm.jl")

lib/cl/memory/bda.jl

@@ -1,92 +1,17 @@
-# OpenCL Memory Object
-
-abstract type AbstractMemoryObject <: CLObject end
-
-#This should be implemented by all subtypes
-# type MemoryType <: AbstractMemoryObject
-#     id::cl_mem
-#     ...
-# end
-
-# for passing buffers to OpenCL APIs: use the underlying handle
-Base.unsafe_convert(::Type{cl_mem}, mem::AbstractMemoryObject) = mem.id
-
-# for passing buffers to kernels: keep the buffer, it's handled by `cl.set_arg!`
-Base.unsafe_convert(::Type{<:Ptr}, mem::AbstractMemoryObject) = mem
-
-Base.sizeof(mem::AbstractMemoryObject) = mem.size
-
-release(mem::AbstractMemoryObject) = clReleaseMemObject(mem)
-
-function Base.getproperty(mem::AbstractMemoryObject, s::Symbol)
-    if s == :context
-        param = Ref{cl_context}()
-        clGetMemObjectInfo(mem, CL_MEM_CONTEXT, sizeof(cl_context), param, C_NULL)
-        return Context(param[], retain = true)
-    elseif s == :mem_type
-        result = Ref{cl_mem_object_type}()
-        clGetMemObjectInfo(mem, CL_MEM_TYPE, sizeof(cl_mem_object_type), result, C_NULL)
-        return result[]
-    elseif s == :mem_flags
-        result = Ref{cl_mem_flags}()
-        clGetMemObjectInfo(mem, CL_MEM_FLAGS, sizeof(cl_mem_flags), result, C_NULL)
-        mf = result[]
-        flags = Symbol[]
-        if (mf & CL_MEM_READ_WRITE) != 0
-            push!(flags, :rw)
-        end
-        if (mf & CL_MEM_WRITE_ONLY) != 0
-            push!(flags, :w)
-        end
-        if (mf & CL_MEM_READ_ONLY) != 0
-            push!(flags, :r)
-        end
-        if (mf & CL_MEM_USE_HOST_PTR) != 0
-            push!(flags, :use)
-        end
-        if (mf & CL_MEM_ALLOC_HOST_PTR) != 0
-            push!(flags, :alloc)
-        end
-        if (mf & CL_MEM_COPY_HOST_PTR) != 0
-            push!(flags, :copy)
-        end
-        return tuple(flags...)
-    elseif s == :size
-        result = Ref{Csize_t}()
-        clGetMemObjectInfo(mem, CL_MEM_SIZE, sizeof(Csize_t), result, C_NULL)
-        return result[]
-    elseif s == :reference_count
-        result = Ref{Cuint}()
-        clGetMemObjectInfo(mem, CL_MEM_REFERENCE_COUNT, sizeof(Cuint), result, C_NULL)
-        return Int(result[])
-    elseif s == :map_count
-        result = Ref{Cuint}()
-        clGetMemObjectInfo(mem, CL_MEM_MAP_COUNT, sizeof(Cuint), result, C_NULL)
-        return Int(result[])
-    elseif s == :device_address
-        result = Ref{cl_mem_device_address_ext}()
-        clGetMemObjectInfo(mem, CL_MEM_DEVICE_ADDRESS_EXT, sizeof(cl_mem_device_address_ext), result, C_NULL)
-        return CLPtr{Cvoid}(result[])
-    else
-        return getfield(mem, s)
-    end
-end
-
-# convenience functions
-context(mem::AbstractMemoryObject) = mem.context
-Base.pointer(mem::AbstractMemoryObject) = mem.pointer
-
-#TODO: enqueue_migrate_mem_objects(queue, mem_objects, flags=0, wait_for=None)
-#TODO: enqueue_migrate_mem_objects_ext(queue, mem_objects, flags=0, wait_for=None)
-
 # OpenCL.Buffer
 
 struct Buffer <: AbstractMemoryObject
     id::cl_mem
+    ptr::Union{Nothing,CLPtr{Cvoid}}
     bytesize::Int
+    context::Context
 end
 
+Buffer() = Buffer(C_NULL, nothing, 0, context())
+
+Base.pointer(buf::Buffer) = @something buf.ptr error("Buffer does not have a device private address")
 Base.sizeof(buf::Buffer) = buf.bytesize
+context(buf::Buffer) = buf.context
 
 
 ## constructors
@@ -130,7 +55,16 @@ function Buffer(sz::Int, flags::Integer, hostbuf=nothing;
     if err_code[] != CL_SUCCESS
         throw(CLError(err_code[]))
     end
-    return Buffer(mem_id, sz)
+
+    ptr = if device_private_address
+        ptr_ref = Ref{cl_mem_device_address_ext}()
+        clGetMemObjectInfo(mem_id, CL_MEM_DEVICE_ADDRESS_EXT, sizeof(cl_mem_device_address_ext), ptr_ref, C_NULL)
+        CLPtr{Cvoid}(ptr_ref[])
+    else
+        nothing
+    end
+
+    return Buffer(mem_id, ptr, sz, context())
 end
 
 # allocated buffer

lib/cl/buffer.jl renamed to lib/cl/memory/buffer.jl

@@ -1,4 +1,4 @@
-struct SharedVirtualMemory <: AbstractMemory
+struct SharedVirtualMemory <: AbstractPointerMemory
     ptr::CLPtr{Cvoid}
     bytesize::Int
     context::Context

lib/cl/memory/memory.jl

@@ -1,4 +1,4 @@
-abstract type UnifiedMemory <: AbstractMemory end
+abstract type UnifiedMemory <: AbstractPointerMemory end
 
 function usm_free(mem::UnifiedMemory; blocking::Bool = false)
     if blocking

lib/cl/memory/svm.jl

@@ -199,10 +199,10 @@ function default_memory_backend(dev::Device)
 
     backend = if backend_str == "usm"
         USMBackend()
-    elseif backend_str == "bda"
-        BDABackend()
     elseif backend_str == "svm"
         SVMBackend()
+    elseif backend_str == "bda"
+        BDABackend()
     else
         error("Unknown memory backend '$backend_str' requested")
     end