Start implementing a direct pocl backend

Author: vchuravy

Project.toml

@@ -10,11 +10,23 @@ EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
+OpenCL_jll = "6cb37087-e8b6-5417-8430-1f242f1e46e4"
 PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+pocl_jll = "627d6b7a-bbe6-5189-83e7-98cc0a5aeadd"
+
+[weakdeps]
+EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+
+[extensions]
+EnzymeExt = "EnzymeCore"
+LinearAlgebraExt = "LinearAlgebra"
+SparseArraysExt = "SparseArrays"
 
 [compat]
 Adapt = "0.4, 1.0, 2.0, 3.0, 4"
@@ -30,17 +42,7 @@ StaticArrays = "0.12, 1.0"
 UUIDs = "<0.0.1, 1.6"
 julia = "1.6"
 
-[extensions]
-EnzymeExt = "EnzymeCore"
-LinearAlgebraExt = "LinearAlgebra"
-SparseArraysExt = "SparseArrays"
-
 [extras]
 EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
-
-[weakdeps]
-EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"
-LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"

src/nanoOpenCL.jl

@@ -0,0 +1,278 @@
+module nanoOpenCL
+
+import OpenCL_jll
+import pocl_jll
+
+const libopencl = OpenCL_jll.libopencl # TODO directly use POCL
+
+"""
+    @checked function foo(...)
+        rv = ...
+        return rv
+    end
+
+Macro for wrapping a function definition returning a status code. Two versions of the
+function will be generated: `foo`, with the function body wrapped by an invocation of the
+`check` function (to be implemented by the caller of this macro), and `unchecked_foo` where no
+such invocation is present and the status code is returned to the caller.
+"""
+macro checked(ex)
+    # parse the function definition
+    @assert Meta.isexpr(ex, :function)
+    sig = ex.args[1]
+    @assert Meta.isexpr(sig, :call)
+    body = ex.args[2]
+    @assert Meta.isexpr(body, :block)
+
+    # we need to detect the first API call, so add an initialization check
+    body = quote
+        if !initialized[]
+            initialize()
+        end
+        $body
+    end
+
+    # generate a "safe" version that performs a check
+    safe_body = quote
+        check() do
+            $body
+        end
+    end
+    safe_sig = Expr(:call, sig.args[1], sig.args[2:end]...)
+    safe_def = Expr(:function, safe_sig, safe_body)
+
+    # generate a "unchecked" version that returns the error code instead
+    unchecked_sig = Expr(:call, Symbol("unchecked_", sig.args[1]), sig.args[2:end]...)
+    unchecked_def = Expr(:function, unchecked_sig, body)
+
+    return esc(:($safe_def, $unchecked_def))
+end
+
+const CL_SUCCESS = 0
+
+const CL_DEVICE_NOT_FOUND = -1
+
+const CL_DEVICE_NOT_AVAILABLE = -2
+
+const CL_PLATFORM_NOT_FOUND_KHR = -1001
+
+const CL_PLATFORM_PROFILE = 0x0900
+
+const CL_PLATFORM_VERSION = 0x0901
+
+const CL_PLATFORM_NAME = 0x0902
+
+const CL_PLATFORM_VENDOR = 0x0903
+
+const CL_PLATFORM_EXTENSIONS = 0x0904
+
+const CL_PLATFORM_HOST_TIMER_RESOLUTION = 0x0905
+
+const CL_PLATFORM_NUMERIC_VERSION = 0x0906
+
+const CL_PLATFORM_EXTENSIONS_WITH_VERSION = 0x0907
+
+const CL_DEVICE_TYPE_DEFAULT = 1 << 0
+
+const CL_DEVICE_TYPE_CPU = 1 << 1
+
+const CL_DEVICE_TYPE_GPU = 1 << 2
+
+const CL_DEVICE_TYPE_ACCELERATOR = 1 << 3
+
+const CL_DEVICE_TYPE_CUSTOM = 1 << 4
+
+const CL_DEVICE_TYPE_ALL = 0xffffffff
+
+const CL_DEVICE_TYPE = 0x1000
+
+
+function check(f)
+    res = f()
+
+    if res != CL_SUCCESS
+        throw_api_error(res)
+    end
+
+    return
+end
+
+const cl_int = Int32
+
+const cl_uint = UInt32
+
+const cl_ulong = UInt64
+
+mutable struct _cl_platform_id end
+
+mutable struct _cl_device_id end
+
+const cl_platform_id = Ptr{_cl_platform_id}
+
+const cl_device_id = Ptr{_cl_device_id}
+
+const cl_bitfield = cl_ulong
+
+const cl_device_type = cl_bitfield
+
+const cl_platform_info = cl_uint
+
+const cl_device_info = cl_uint
+
+
+
+@checked function clGetPlatformIDs(num_entries, platforms, num_platforms)
+    @ccall libopencl.clGetPlatformIDs(num_entries::cl_uint, platforms::Ptr{cl_platform_id},
+                                      num_platforms::Ptr{cl_uint})::cl_int
+end
+
+@checked function clGetPlatformInfo(platform, param_name, param_value_size, param_value,
+                                    param_value_size_ret)
+    @ccall libopencl.clGetPlatformInfo(platform::cl_platform_id,
+                                       param_name::cl_platform_info,
+                                       param_value_size::Csize_t, param_value::Ptr{Cvoid},
+                                       param_value_size_ret::Ptr{Csize_t})::cl_int
+end
+
+@checked function clGetDeviceIDs(platform, device_type, num_entries, devices, num_devices)
+    @ccall libopencl.clGetDeviceIDs(platform::cl_platform_id, device_type::cl_device_type,
+                                    num_entries::cl_uint, devices::Ptr{cl_device_id},
+                                    num_devices::Ptr{cl_uint})::cl_int
+end
+
+@checked function clGetDeviceInfo(device, param_name, param_value_size, param_value,
+                                  param_value_size_ret)
+    @ccall libopencl.clGetDeviceInfo(device::cl_device_id, param_name::cl_device_info,
+                                     param_value_size::Csize_t, param_value::Ptr{Cvoid},
+                                     param_value_size_ret::Ptr{Csize_t})::cl_int
+end
+
+# Init
+
+# lazy initialization
+const initialized = Ref{Bool}(false)
+@noinline function initialize()
+    initialized[] = true
+
+    @static if Sys.iswindows()
+        if is_high_integrity_level()
+            @warn """Running at high integrity level, preventing OpenCL.jl from loading drivers from JLLs.
+
+                     Only system drivers will be available. To enable JLL drivers, do not run Julia as an administrator."""
+        end
+    end
+
+    ocd_filenames = join(OpenCL_jll.drivers, ':')
+    if haskey(ENV, "OCL_ICD_FILENAMES")
+        ocd_filenames *= ":" * ENV["OCL_ICD_FILENAMES"]
+    end
+
+    withenv("OCL_ICD_FILENAMES"=>ocd_filenames) do
+        num_platforms = Ref{Cuint}()
+        @ccall libopencl.clGetPlatformIDs(
+            0::cl_uint, C_NULL::Ptr{cl_platform_id},
+            num_platforms::Ptr{cl_uint})::cl_int
+
+        if num_platforms[] == 0 && isempty(OpenCL_jll.drivers)
+            @error """No OpenCL drivers available, either system-wide or provided by a JLL.
+
+                      Please install a system-wide OpenCL driver, or load one together with OpenCL.jl,
+                      e.g., by doing `using OpenCL, pocl_jll`."""
+        end
+    end
+end
+
+# Julia API
+
+struct Platform
+    id::cl_platform_id
+end
+
+Base.unsafe_convert(::Type{cl_platform_id}, p::Platform) = p.id
+
+function platforms()
+    nplatforms = Ref{Cuint}()
+    res = unchecked_clGetPlatformIDs(0, C_NULL, nplatforms)
+    if res == CL_PLATFORM_NOT_FOUND_KHR || nplatforms[] == 0
+        return Platform[]
+    elseif res != CL_SUCCESS
+        throw(CLError(res))
+    end
+    cl_platform_ids = Vector{cl_platform_id}(undef, nplatforms[])
+    clGetPlatformIDs(nplatforms[], cl_platform_ids, C_NULL)
+    return [Platform(id) for id in cl_platform_ids]
+end
+
+
+function Base.getproperty(p::Platform, s::Symbol)
+    # simple string properties
+    version_re = r"OpenCL (?<major>\d+)\.(?<minor>\d+)(?<vendor>.+)"
+    @inline function get_string(prop)
+        sz = Ref{Csize_t}()
+        clGetPlatformInfo(p, prop, 0, C_NULL, sz)
+        chars = Vector{Cchar}(undef, sz[])
+        clGetPlatformInfo(p, prop, sz[], chars, C_NULL)
+        return GC.@preserve chars unsafe_string(pointer(chars))
+    end
+    if s === :profile
+        return get_string(CL_PLATFORM_PROFILE)
+    elseif s === :version
+        str = get_string(CL_PLATFORM_VERSION)
+        m = match(version_re, str)
+        if m === nothing
+            error("Could not parse OpenCL version string: $str")
+        end
+        return strip(m["vendor"])
+        elseif s === :opencl_version
+        str = get_string(CL_PLATFORM_VERSION)
+        m = match(version_re, str)
+        if m === nothing
+            error("Could not parse OpenCL version string: $str")
+        end
+        return VersionNumber(parse(Int, m["major"]), parse(Int, m["minor"]))
+    elseif s === :name
+        return get_string(CL_PLATFORM_NAME)
+    elseif s === :vendor
+        return get_string(CL_PLATFORM_VENDOR)
+    end
+    
+    if s == :extensions
+        size = Ref{Csize_t}()
+        clGetPlatformInfo(p, CL_PLATFORM_EXTENSIONS, 0, C_NULL, size)
+        result = Vector{Cchar}(undef, size[])
+        clGetPlatformInfo(p, CL_PLATFORM_EXTENSIONS, size[], result, C_NULL)
+        return GC.@preserve result split(unsafe_string(pointer(result)))
+    end
+    return getfield(p, s)
+end
+
+struct Device
+    id::cl_device_id
+end
+
+Base.unsafe_convert(::Type{cl_device_id}, d::Device) = d.id
+
+function devices(p::Platform, dtype)
+    ndevices = Ref{Cuint}()
+    ret = unchecked_clGetDeviceIDs(p, dtype, 0, C_NULL, ndevices)
+    if ret == CL_DEVICE_NOT_FOUND || ndevices[] == 0
+        return Device[]
+    elseif ret != CL_SUCCESS
+        throw(CLError(ret))
+    end
+    result = Vector{cl_device_id}(undef, ndevices[])
+    clGetDeviceIDs(p, dtype, ndevices[], result, C_NULL)
+    return Device[Device(id) for id in result]
+end
+
+function default_device(p::Platform)
+    devs = devices(p, CL_DEVICE_TYPE_DEFAULT)
+    isempty(devs) && return nothing
+    # XXX: clGetDeviceIDs documents CL_DEVICE_TYPE_DEFAULT should only return one device,
+    #      but it's been observed to return multiple devices on some platforms...
+    return first(devs)
+end
+
+devices(p::Platform) = devices(p, CL_DEVICE_TYPE_ALL)
+
+end

src/pocl.jl

@@ -0,0 +1,20 @@
+module POCL
+    include("nanoOpenCL.jl")
+
+    import .nanoOpenCL: nanoOpenCL
+
+    function platform()
+        for p in nanoOpenCL.platforms()
+            if p.vendor == "The pocl project"
+                return p
+            end
+        end
+        return nothing
+    end
+
+    function device()
+        p = platform()
+        return nanoOpenCL.default_device(p)
+    end
+
+end