KernelInterface

[christiangnrd]

Do not merge until KernelInterface has been reviewed and interface fully decided

[github-actions]

Your PR requires formatting changes to meet the project's style guidelines.
Please consider running Runic (git runic main) to apply these changes.

Click here to view the suggested changes.

diff --git a/lib/level-zero/synchronization.jl b/lib/level-zero/synchronization.jl
index 809a03b..0143c93 100644
--- a/lib/level-zero/synchronization.jl
+++ b/lib/level-zero/synchronization.jl
@@ -28,22 +28,24 @@ Base.isdone(queue::ZeCommandQueue) =
 # the blocking synchronization, marked GC-safe so that it doesn't keep the GC from running
 gcsafe_synchronize(list::ZeImmediateCommandList) =
     @gcsafe_ccall libze_loader.zeCommandListHostSynchronize(
-        list::ze_command_list_handle_t, typemax(UInt64)::UInt64)::ze_result_t
+    list::ze_command_list_handle_t, typemax(UInt64)::UInt64
+)::ze_result_t
 gcsafe_synchronize(queue::ZeCommandQueue) =
     @gcsafe_ccall libze_loader.zeCommandQueueSynchronize(
-        queue::ze_command_queue_handle_t, typemax(UInt64)::UInt64)::ze_result_t
+    queue::ze_command_queue_handle_t, typemax(UInt64)::UInt64
+)::ze_result_t
 
 
 ## bidirectional channel
 
 # custom, unbuffered channel that supports returning a value to the sender
 # without the need for a second channel
-struct BidirectionalChannel{I,O} <: AbstractChannel{I}
+struct BidirectionalChannel{I, O} <: AbstractChannel{I}
     cond_take::Threads.Condition                 # waiting for data to become available
     cond_put::Threads.Condition                  # waiting for a writeable slot
     cond_ret::Threads.Condition                  # waiting for a data to be returned
 
-    function BidirectionalChannel{I,O}() where {I,O}
+    function BidirectionalChannel{I, O}() where {I, O}
         lock = ReentrantLock()
         cond_put = Threads.Condition(lock)
         cond_take = Threads.Condition(lock)
@@ -53,9 +55,9 @@ struct BidirectionalChannel{I,O} <: AbstractChannel{I}
 end
 
 Base.put!(c::BidirectionalChannel{I}, v) where {I} = put!(c, convert(I, v))
-function Base.put!(c::BidirectionalChannel{I,O}, v::I) where {I,O}
+function Base.put!(c::BidirectionalChannel{I, O}, v::I) where {I, O}
     lock(c)
-    try
+    return try
         # wait for a slot to be available
         while isempty(c.cond_take)
             Base.wait(c.cond_put)
@@ -71,9 +73,9 @@ function Base.put!(c::BidirectionalChannel{I,O}, v::I) where {I,O}
     end
 end
 
-function Base.take!(f::Base.Callable, c::BidirectionalChannel{I,O}) where {I,O}
+function Base.take!(f::Base.Callable, c::BidirectionalChannel{I, O}) where {I, O}
     lock(c)
-    try
+    return try
         # notify the producer that we're ready to accept a value
         notify(c.cond_put, nothing, false, false)
 
@@ -123,7 +125,7 @@ end
 ## slow path: synchronize on a separate thread
 
 const MAX_SYNC_THREADS = 4
-const sync_channels = Array{BidirectionalChannel{SyncObject,ze_result_t}}(undef, MAX_SYNC_THREADS)
+const sync_channels = Array{BidirectionalChannel{SyncObject, ze_result_t}}(undef, MAX_SYNC_THREADS)
 const sync_channel_cursor = Threads.Atomic{UInt32}(1)
 const sync_channel_lock = Base.ReentrantLock()
 
@@ -135,6 +137,7 @@ function synchronization_worker(data)
         # wait for work
         take!(gcsafe_synchronize, chan)
     end
+    return
 end
 
 @noinline function create_synchronization_worker(i)
@@ -146,7 +149,7 @@ end
 
         # should be safe to assign before threads are running;
         # any user will just submit work that makes it block
-        sync_channels[i] = BidirectionalChannel{SyncObject,ze_result_t}()
+        sync_channels[i] = BidirectionalChannel{SyncObject, ze_result_t}()
 
         # we don't know what the size of uv_thread_t is, so reserve enough space
         tid = Ref{NTuple{32, UInt8}}(ntuple(i -> 0, 32))
diff --git a/src/compiler/compilation.jl b/src/compiler/compilation.jl
index 7305e04..3a9808f 100644
--- a/src/compiler/compilation.jl
+++ b/src/compiler/compilation.jl
@@ -1,7 +1,7 @@
 ## gpucompiler interface implementation
 
 Base.@kwdef struct oneAPICompilerParams <: AbstractCompilerParams
-    sub_group_size::Union{Nothing,Int} = nothing
+    sub_group_size::Union{Nothing, Int} = nothing
 end
 
 const oneAPICompilerConfig = CompilerConfig{SPIRVCompilerTarget, oneAPICompilerParams}
@@ -281,7 +281,7 @@ function _driver_supports_bfloat16_spirv(dev=device())
     end
 end
 
-@noinline function _compiler_config(dev; kernel=true, name=nothing, always_inline=false, sub_group_size=32, kwargs...)
+@noinline function _compiler_config(dev; kernel = true, name = nothing, always_inline = false, sub_group_size = 32, kwargs...)
     properties = oneL0.module_properties(dev)
     supports_fp16 = properties.fp16flags & oneL0.ZE_DEVICE_MODULE_FLAG_FP16 == oneL0.ZE_DEVICE_MODULE_FLAG_FP16
     supports_fp64 = properties.fp64flags & oneL0.ZE_DEVICE_MODULE_FLAG_FP64 == oneL0.ZE_DEVICE_MODULE_FLAG_FP64
diff --git a/src/context.jl b/src/context.jl
index 6c9e188..36f0cd0 100644
--- a/src/context.jl
+++ b/src/context.jl
@@ -401,7 +401,7 @@ println("GPU work completed")
 
 See also: [`global_stream`](@ref), [`context`](@ref), [`device`](@ref)
 """
-function oneL0.synchronize(s::oneStream; blocking::Bool=false)
+function oneL0.synchronize(s::oneStream; blocking::Bool = false)
     sync = blocking ? oneL0.synchronize : oneL0.nonblocking_synchronize
     sync(s.list)
     q = s.queue
@@ -412,8 +412,8 @@ function oneL0.synchronize(s::oneStream; blocking::Bool=false)
     return
 end
 
-function oneL0.synchronize(; blocking::Bool=false)
-    oneL0.synchronize(global_stream(context(), device()); blocking)
+function oneL0.synchronize(; blocking::Bool = false)
+    return oneL0.synchronize(global_stream(context(), device()); blocking)
 end
 
 # Julia → MKL ordering: everything Julia appended to the task's immediate list must be
diff --git a/src/oneAPIKernels.jl b/src/oneAPIKernels.jl
index 7346df2..4bd05f8 100644
--- a/src/oneAPIKernels.jl
+++ b/src/oneAPIKernels.jl
@@ -73,7 +73,7 @@ end
 
 KI.argconvert(::oneAPIBackend, arg) = kernel_convert(arg)
 
-function KI.kernel_function(backend::oneAPIBackend, f::F, tt::TT=Tuple{}; name = nothing, kwargs...) where {F,TT}
+function KI.kernel_function(backend::oneAPIBackend, f::F, tt::TT = Tuple{}; name = nothing, kwargs...) where {F, TT}
     # compile for the sub-group width that `KI.sub_group_size` promises
     sub_group_size = KI.sub_group_size(backend)
     kern = if sub_group_size > 0
@@ -81,7 +81,7 @@ function KI.kernel_function(backend::oneAPIBackend, f::F, tt::TT=Tuple{}; name =
     else
         zefunction(f, tt; name, backend.always_inline, kwargs...)
     end
-    KI.Kernel{oneAPIBackend, typeof(kern)}(backend, kern)
+    return KI.Kernel{oneAPIBackend, typeof(kern)}(backend, kern)
 end
 
 function KI.launch(obj::KI.Kernel{oneAPIBackend}, groups::Dims{3}, items::Dims{3}, args::Vararg{Any, N}; kwargs...) where {N}
@@ -114,19 +114,21 @@ function device_limits(dev::oneAPI.oneL0.ZeDevice = device())
     limits = get!(task_local_storage(), :oneAPIDeviceLimits) do
         Dict{oneAPI.oneL0.ZeDevice, DeviceLimits}()
     end::Dict{oneAPI.oneL0.ZeDevice, DeviceLimits}
-    get!(limits, dev) do
+    return get!(limits, dev) do
         props = oneAPI.oneL0.compute_properties(dev)
         module_props = oneAPI.oneL0.module_properties(dev)
         # the sub-group width that `kernel_function` compiles for: the width `@oneapi` defaults
         # to if the device supports it, and 0 if the device has no sub-groups
         sg_sizes = props.subGroupSizes
         sub_group_size = 32 in sg_sizes ? 32 : maximum(sg_sizes; init = 0)
-        (; max_work_group_size = props.maxTotalGroupSize,
-           max_work_group_dims = (props.maxGroupSizeX, props.maxGroupSizeY, props.maxGroupSizeZ),
-           max_num_groups = (props.maxGroupCountX, props.maxGroupCountY, props.maxGroupCountZ),
-           sub_group_size,
-           supports_float16 = module_props.flags & oneAPI.oneL0.ZE_DEVICE_MODULE_FLAG_FP16 != 0,
-           supports_float64 = module_props.flags & oneAPI.oneL0.ZE_DEVICE_MODULE_FLAG_FP64 != 0)
+        (;
+            max_work_group_size = props.maxTotalGroupSize,
+            max_work_group_dims = (props.maxGroupSizeX, props.maxGroupSizeY, props.maxGroupSizeZ),
+            max_num_groups = (props.maxGroupCountX, props.maxGroupCountY, props.maxGroupCountZ),
+            sub_group_size,
+            supports_float16 = module_props.flags & oneAPI.oneL0.ZE_DEVICE_MODULE_FLAG_FP16 != 0,
+            supports_float64 = module_props.flags & oneAPI.oneL0.ZE_DEVICE_MODULE_FLAG_FP64 != 0,
+        )
     end
 end
 KI.max_work_group_size(::oneAPIBackend)::Int = device_limits().max_work_group_size
@@ -134,7 +136,7 @@ KI.max_work_group_dims(::oneAPIBackend)::NTuple{3, Int} = device_limits().max_wo
 KI.max_num_groups(::oneAPIBackend)::NTuple{3, Int} = device_limits().max_num_groups
 KI.sub_group_size(::oneAPIBackend)::Int = device_limits().sub_group_size
 function KI.multiprocessor_count(::oneAPIBackend)::Int
-    oneAPI.oneL0.properties(device()).numSlices
+    return oneAPI.oneL0.properties(device()).numSlices
 end
 
 KI.supports_subgroups(::oneAPIBackend) = device_limits().sub_group_size > 0
@@ -199,7 +201,7 @@ end
     sub_group_barrier(SPIRVIntrinsics.LOCAL_MEM_FENCE | SPIRVIntrinsics.GLOBAL_MEM_FENCE)
 end
 
-@device_override function KI.shfl_down(val::T, offset::Integer) where T
+@device_override function KI.shfl_down(val::T, offset::Integer) where {T}
     sub_group_shuffle(val, get_sub_group_local_id() + offset)
 end
 
diff --git a/src/oneAPIKernelsOld.jl b/src/oneAPIKernelsOld.jl
index 854e8ab..a9ecfbb 100644
--- a/src/oneAPIKernelsOld.jl
+++ b/src/oneAPIKernelsOld.jl
@@ -49,7 +49,7 @@ end
 ## Memory Operations
 
 function KA.copyto!(::oneAPIBackend, A, B)
-    copyto!(A, B)
+    return copyto!(A, B)
     # TODO: Address device to host copies in jl being synchronizing
 end
 
@@ -75,11 +75,13 @@ end
 ## Kernel Launch
 
 function KA.mkcontext(kernel::KA.Kernel{oneAPIBackend}, _ndrange, iterspace)
-    KA.CompilerMetadata{KA.ndrange(kernel), KA.DynamicCheck}(_ndrange, iterspace)
+    return KA.CompilerMetadata{KA.ndrange(kernel), KA.DynamicCheck}(_ndrange, iterspace)
 end
-function KA.mkcontext(kernel::KA.Kernel{oneAPIBackend}, I, _ndrange, iterspace,
-                      ::Dynamic) where Dynamic
-    KA.CompilerMetadata{KA.ndrange(kernel), Dynamic}(I, _ndrange, iterspace)
+function KA.mkcontext(
+        kernel::KA.Kernel{oneAPIBackend}, I, _ndrange, iterspace,
+        ::Dynamic
+    ) where {Dynamic}
+    return KA.CompilerMetadata{KA.ndrange(kernel), Dynamic}(I, _ndrange, iterspace)
 end
 
 function KA.launch_config(kernel::KA.Kernel{oneAPIBackend}, ndrange, workgroupsize)
@@ -87,7 +89,7 @@ function KA.launch_config(kernel::KA.Kernel{oneAPIBackend}, ndrange, workgroupsi
         ndrange = (ndrange,)
     end
     if workgroupsize isa Integer
-        workgroupsize = (workgroupsize, )
+        workgroupsize = (workgroupsize,)
     end
 
     # partition checked that the ndrange's agreed
@@ -96,7 +98,7 @@ function KA.launch_config(kernel::KA.Kernel{oneAPIBackend}, ndrange, workgroupsi
     end
 
     iterspace, dynamic = if KA.workgroupsize(kernel) <: KA.DynamicSize &&
-        workgroupsize === nothing
+            workgroupsize === nothing
         # use ndrange as preliminary workgroupsize for autotuning
         # (clamped to 1, since an empty ndrange cannot serve as a workgroup size)
         KA.partition(kernel, ndrange, max.(ndrange, 1))
@@ -116,7 +118,7 @@ function threads_to_workgroupsize(threads, ndrange)
     end
 end
 
-function (obj::KA.Kernel{oneAPIBackend})(args...; ndrange=nothing, workgroupsize=nothing)
+function (obj::KA.Kernel{oneAPIBackend})(args...; ndrange = nothing, workgroupsize = nothing)
     backend = KA.backend(obj)
 
     ndrange, workgroupsize, iterspace, dynamic = KA.launch_config(obj, ndrange, workgroupsize)
diff --git a/src/utils.jl b/src/utils.jl
index 05bceb8..ce3dcac 100644
--- a/src/utils.jl
+++ b/src/utils.jl
@@ -31,13 +31,15 @@ function versioninfo(io::IO=stdout)
     get_module(name::Symbol) = (name, getfield(oneAPI, name))
     function get_module(pkg::Tuple{String, String})
         id = Base.PkgId(Base.UUID(pkg[1]), pkg[2])
-        (pkg[2], get(Base.loaded_modules, id, nothing))
+        return (pkg[2], get(Base.loaded_modules, id, nothing))
     end
 
     println(io, "Julia packages:")
     println(io, "- oneAPI.jl: $(Base.pkgversion(oneAPI))")
-    for pkg in [:GPUArrays, :GPUCompiler, ("63c18a36-062a-441e-b654-da1e3ab1ce7c", "KernelAbstractions"),
-                 :KernelInterface, :LLVM, :SPIRVIntrinsics]
+    for pkg in [
+            :GPUArrays, :GPUCompiler, ("63c18a36-062a-441e-b654-da1e3ab1ce7c", "KernelAbstractions"),
+            :KernelInterface, :LLVM, :SPIRVIntrinsics,
+        ]
         name, mod = get_module(pkg)
         isnothing(mod) || println(io, "- $(name): $(Base.pkgversion(mod))")
     end
diff --git a/test/execution.jl b/test/execution.jl
index 330a161..4df4759 100644
--- a/test/execution.jl
+++ b/test/execution.jl
@@ -756,7 +756,7 @@ end
 
 @testset "cooperative synchronize" begin
     a = oneArray{UInt32}(undef, 64)
-    slow(iters) = @oneapi items=64 slow_kernel(a, UInt32(iters))
+    slow(iters) = @oneapi items = 64 slow_kernel(a, UInt32(iters))
     slow(1)
     synchronize()
     # warm up the slow path of `synchronize`: compiling it would end the calibration early
@@ -785,7 +785,7 @@ end
 
     # blocking synchronization is still available
     slow(1)
-    @test synchronize(; blocking=true) === nothing
+    @test synchronize(; blocking = true) === nothing
 end
 
 ############################################################################################

[codecov]

Codecov Report

❌ Patch coverage is 88.58696% with 21 lines in your changes missing coverage. Please review.
✅ Project coverage is 80.56%. Comparing base (3a233d2) to head (f9acd84).

Files with missing lines	Patch %	Lines
src/oneAPIKernelsOld.jl	90.35%	11 Missing ⚠️
src/oneAPIKernels.jl	83.63%	9 Missing ⚠️
src/compiler/compilation.jl	87.50%	1 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##             main     #624      +/-   ##
==========================================
- Coverage   80.73%   80.56%   -0.18%     
==========================================
  Files          56       57       +1     
  Lines        4060     4147      +87     
==========================================
+ Hits         3278     3341      +63     
- Misses        782      806      +24     

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[maleadt]

#653