Format

Author: christiangnrd

src/KernelAbstractions.jl

@@ -248,11 +248,8 @@ end
 Declare storage that is local to a workgroup.
 """
 macro localmem(T, dims)
-    # Stay in sync with CUDAnative
-    # id = gensym("static_shmem")
-
     return quote
-        $SharedMemory($(esc(T)), Val($(esc(dims))))#, Val($(QuoteNode(id))))
+        $SharedMemory($(esc(T)), Val($(esc(dims))))
     end
 end
 

src/intrinsics.jl

@@ -66,8 +66,7 @@ Declare memory that is local to a workgroup.
     ```
     As well as the on-device functionality.
 """
-localmemory(::Type{T}, dims) where T = localmemory(T, Val(dims))
-# @inline localmemory(::Type{T}, dims::Val{Dims}) where {T, Dims} = localmemory(T, dims, Val(gensym("static_shmem")))
+localmemory(::Type{T}, dims) where {T} = localmemory(T, Val(dims))
 
 """
     barrier()
@@ -110,7 +109,6 @@ end
 end
 
 
-
 """
     KIKernel{Backend, BKern}
 
@@ -235,7 +233,7 @@ There are a few keyword arguments that influence the behavior of `@kikernel`:
 """
 macro kikernel(backend, ex...)
     call = ex[end]
-    kwargs = map(ex[1:end-1]) do kwarg
+    kwargs = map(ex[1:(end - 1)]) do kwarg
         if kwarg isa Symbol
             :($kwarg = $kwarg)
         elseif Meta.isexpr(kwarg, :(=))
@@ -257,14 +255,14 @@ macro kikernel(backend, ex...)
     macro_kwargs, compiler_kwargs, call_kwargs, other_kwargs =
         split_kwargs(kwargs, MACRO_KWARGS, COMPILER_KWARGS, LAUNCH_KWARGS)
     if !isempty(other_kwargs)
-        key,val = first(other_kwargs).args
+        key, val = first(other_kwargs).args
         throw(ArgumentError("Unsupported keyword argument '$key'"))
     end
 
     # handle keyword arguments that influence the macro's behavior
     launch = true
     for kwarg in macro_kwargs
-        key,val = kwarg.args
+        key, val = kwarg.args
         if key === :launch
             isa(val, Bool) || throw(ArgumentError("`launch` keyword argument to @kikern should be a Bool"))
             launch = val::Bool
@@ -282,7 +280,8 @@ macro kikernel(backend, ex...)
 
     # convert the arguments, call the compiler and launch the kernel
     # while keeping the original arguments alive
-    push!(code.args,
+    push!(
+        code.args,
         quote
             $f_var = $f
             GC.@preserve $(vars...) $f_var begin
@@ -295,13 +294,16 @@ macro kikernel(backend, ex...)
                 end
                 $kernel
             end
-         end)
+        end
+    )
 
-    return esc(quote
-        let
-            $code
+    return esc(
+        quote
+            let
+                $code
+            end
         end
-    end)
+    )
 end
 
 end

src/pocl/backend.jl

@@ -141,32 +141,32 @@ end
 
 KI.kiconvert(::POCLBackend, arg) = clconvert(arg)
 
-function KI.kifunction(::POCLBackend, f::F, tt::TT=Tuple{}; name=nothing, kwargs...) where {F,TT}
+function KI.kifunction(::POCLBackend, f::F, tt::TT = Tuple{}; name=nothing, kwargs...) where {F, TT}
     kern = clfunction(f, tt; name, kwargs...)
     KI.KIKernel{POCLBackend, typeof(kern)}(POCLBackend(), kern)
 end
 
-function (obj::KI.KIKernel{POCLBackend})(args...; numworkgroups=nothing, workgroupsize=nothing)
+function (obj::KI.KIKernel{POCLBackend})(args...; numworkgroups = nothing, workgroupsize = nothing)
     local_size = isnothing(workgroupsize) ? 1 : workgroupsize
     global_size = if isnothing(numworkgroups)
         1
     else
-        numworkgroups*local_size
+        numworkgroups * local_size
     end
 
-    obj.kern(args...; local_size, global_size)
+    return obj.kern(args...; local_size, global_size)
 end
 
 
-function KI.kernel_max_work_group_size(::POCLBackend, kikern::KI.KIKernel{<:POCLBackend}; max_work_items::Int=typemax(Int))::Int
+function KI.kernel_max_work_group_size(::POCLBackend, kikern::KI.KIKernel{<:POCLBackend}; max_work_items::Int = typemax(Int))::Int
     wginfo = cl.work_group_info(kikern.kern.fun, device())
-    Int(min(wginfo.size, max_work_items))
+    return Int(min(wginfo.size, max_work_items))
 end
 function KI.max_work_group_size(::POCLBackend)::Int
-    Int(device().max_work_group_size)
+    return Int(device().max_work_group_size)
 end
 function KI.multiprocessor_count(::POCLBackend)::Int
-    Int(device().max_compute_units)
+    return Int(device().max_compute_units)
 end
 
 ## Indexing Functions

test/intrinsics.jl

@@ -30,10 +30,10 @@ function intrinsics_testsuite(backend, AT)
             # Test with small kernel
             N = 16
             results = AT(zeros(Int, 6, N))
-            kernel = KI.@kikernel backend() launch=false test_intrinsics_kernel(results)
+            kernel = KI.@kikernel backend() launch = false test_intrinsics_kernel(results)
 
             @test KI.kernel_max_work_group_size(backend(), kernel) isa Int
-            @test KI.kernel_max_work_group_size(backend(), kernel; max_work_items=1) == 1
+            @test KI.kernel_max_work_group_size(backend(), kernel; max_work_items = 1) == 1
 
             kernel(results, workgroupsize = 4, numworkgroups = 4)
             KernelAbstractions.synchronize(backend())
@@ -66,4 +66,5 @@ function intrinsics_testsuite(backend, AT)
             end
         end
     end
+    return nothing
 end