Keep minimal support for non-BDA capable drivers.

Author: maleadt

.github/workflows/Test.yml

@@ -26,7 +26,7 @@ jobs:
         os: [ubuntu-24.04, ubuntu-24.04-arm, macOS-13, macOS-15, windows-2025]
         arch: [x64, arm64]
         pocl: [jll, local]
-        memory_backend: [usm, bda, svm]
+        memory_backend: [usm, svm, buffer]
         exclude:
           # unsupported combinations
           - os: ubuntu-24.04

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": plain buffers (`cl_mem` + `cl_ext_buffer_device_address`)
-# - "svm": Shared Virtual Memory (coarse-grained)
+# - "buffer": plain buffers (using pointers if `cl_ext_buffer_device_address` is available)
+# - "usm": Unified Shared Memory (requiring `cl_intel_unified_shared_memory`)
+# - "svm": Shared Virtual Memory (requiring coarse-grained SVM support)
 # If unspecified, the default will be used based on the platform and device capabilities.
 #default_memory_backend="..."

lib/cl/device.jl

@@ -190,15 +190,7 @@ function exec_capabilities(d::Device)
     )
 end
 
-function bda_supported(d::Device)
-    "cl_ext_buffer_device_address" in d.extensions || return false
-    return true
-end
-
-function usm_supported(d::Device)
-    "cl_intel_unified_shared_memory" in d.extensions || return false
-    return true
-end
+usm_supported(d::Device) = "cl_intel_unified_shared_memory" in d.extensions
 
 function usm_capabilities(d::Device)
     usm_supported(d) || throw(ArgumentError("Unified Shared Memory not supported on this device"))
@@ -261,6 +253,8 @@ function svm_capabilities(d::Device)
     )
 end
 
+bda_supported(d::Device) = false#"cl_ext_buffer_device_address" in d.extensions
+
 function cl_device_type(dtype::Symbol)
     if dtype == :all
         cl_dtype = CL_DEVICE_TYPE_ALL

lib/cl/kernel.jl

@@ -69,7 +69,7 @@ function set_arg!(k::Kernel, idx::Integer, arg::CLPtr{T}) where {T}
 end
 
 # raw memory
-function set_arg!(k::Kernel, idx::Integer, arg::AbstractMemory)
+function set_arg!(k::Kernel, idx::Integer, arg::AbstractPointerMemory)
     # XXX: this assumes that the receiving argument is pointer-typed, which is not the case
     #      with Julia's `Ptr` ABI. Instead, one should reinterpret the pointer as a
     #      `Core.LLVMPtr`, which _is_ pointer-valued. We retain this handling for `Ptr` for

lib/cl/memory.jl

@@ -83,9 +83,6 @@ 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")
 

lib/cl/memory/buffer.jl

@@ -9,7 +9,7 @@ end
 
 Buffer() = Buffer(C_NULL, CL_NULL, 0, context())
 
-Base.pointer(buf::Buffer) = @something buf.ptr error("Buffer does not have a device private address")
+Base.pointer(buf::Buffer) = @something buf.ptr error("Conversion of a buffer to a pointer is not supported by this device")
 Base.sizeof(buf::Buffer) = buf.bytesize
 context(buf::Buffer) = buf.context
 
@@ -18,7 +18,7 @@ context(buf::Buffer) = buf.context
 
 # for internal use
 function Buffer(sz::Int, flags::Integer, hostbuf=nothing;
-                device=:rw, host=:rw, device_private_address=false)
+                device=:rw, host=:rw, device_private_address=bda_supported(cl.device()))
     if device == :rw
         flags |= CL_MEM_READ_WRITE
     elseif device == :r

lib/cl/state.jl

@@ -161,7 +161,7 @@ end
 abstract type AbstractMemoryBackend end
 struct SVMBackend <: AbstractMemoryBackend end
 struct USMBackend <: AbstractMemoryBackend end
-struct BDABackend <: AbstractMemoryBackend end
+struct BufferBackend <: AbstractMemoryBackend end
 
 function supported_memory_backends(dev::Device)
     backends = AbstractMemoryBackend[]
@@ -175,10 +175,10 @@ function supported_memory_backends(dev::Device)
         end
     end
 
-    # plain old device buffers are second choice, but require an extension to support being
-    # referenced by raw pointers.
+    # plain old buffers are always supported, but we only want to use them if we have the
+    # buffer device address extension, which allows us to reference them by raw pointers.
     if bda_supported(dev)
-        push!(backends, BDABackend())
+        push!(backends, BufferBackend())
     end
 
     # shared virtual memory is last, because it comes at a performance cost.
@@ -187,12 +187,17 @@ function supported_memory_backends(dev::Device)
         push!(backends, SVMBackend())
     end
 
+    if isempty(backends)
+        # as a last resort, use plain buffers without the ability to reference by pointer.
+        # this severely limits compatibility, but it's better than nothing.
+        push!(backends, BufferBackend())
+    end
+
     return backends
 end
 
 function default_memory_backend(dev::Device)
     supported_backends = supported_memory_backends(dev)
-    isempty(supported_backends) && return nothing
 
     backend_str = load_preference(OpenCL, "default_memory_backend")
     backend_str === nothing && return first(supported_backends)
@@ -201,8 +206,8 @@ function default_memory_backend(dev::Device)
         USMBackend()
     elseif backend_str == "svm"
         SVMBackend()
-    elseif backend_str == "bda"
-        BDABackend()
+    elseif backend_str == "buffer"
+        BufferBackend()
     else
         error("Unknown memory backend '$backend_str' requested")
     end
@@ -212,9 +217,14 @@ end
 
 function memory_backend()
     return get!(task_local_storage(), :CLMemoryBackend) do
-        backend = default_memory_backend(device())
+        dev = device()
+        backend = default_memory_backend(dev)
         if backend === nothing
-            error("Device $(device()) does not support any of the available memory backends")
+            error("Device $(dev) does not support any of the available memory backends")
+        end
+        if backend === BufferBackend() && !bda_supported(dev)
+            @warn """Your device $(dev.name) does not support the necessary extensions for OpenCL.jl's memory management (requiring either USM, coarse-grained SVM, or BDA).
+                     Falling back to plain OpenCL buffers, which severely limits compatibility with other OpenCL.jl, only supporting OpenCL C kernels.""" maxlog=1 _id="memory_backend_$(dev.name)"
         end
         backend
     end

src/array.jl

@@ -98,7 +98,7 @@ function memory_type()
         return cl.UnifiedDeviceMemory
     elseif cl.memory_backend() == cl.SVMBackend()
         return cl.SharedVirtualMemory
-    elseif cl.memory_backend() == cl.BDABackend()
+    elseif cl.memory_backend() == cl.BufferBackend()
         return cl.Buffer
     end
 end

src/memory.jl

@@ -144,7 +144,7 @@ end
 
 function alloc(::Type{cl.Buffer}, bytes::Int; alignment::Int = 0)
     # TODO: use alignment
-    buf = cl.Buffer(bytes; device_private_address = true)
+    buf = cl.Buffer(bytes)
     return Managed(buf)
 end
 

src/util.jl

@@ -87,8 +87,8 @@ function versioninfo(io::IO=stdout)
                     push!(tags, "svm"*suffix)
                 elseif backend isa cl.USMBackend
                     push!(tags, "usm"*suffix)
-                elseif backend isa cl.BDABackend
-                    push!(tags, "bda"*suffix)
+                elseif backend isa cl.BufferBackend
+                    push!(tags, "buffer"*suffix)
                 end
             end
             ## relevant extensions