don't export KI and fix POCL.synchronize

Author: vchuravy

examples/histogram.jl

@@ -1,6 +1,8 @@
 # INCLUDE ROCM
 using KernelAbstractions, Test
 using KernelAbstractions: @atomic, @atomicswap, @atomicreplace
+import KernelAbstractions.KernelIntrinsics as KI
+
 include(joinpath(dirname(pathof(KernelAbstractions)), "../examples/utils.jl")) # Load backend
 
 # Function to use as a baseline for CPU metrics

examples/performant_matmul.jl

@@ -1,7 +1,10 @@
 using KernelAbstractions
+import KernelAbstractions.KernelIntrinsics as KI
+
 using StaticArrays
 using Test
 using Random
+
 include(joinpath(dirname(pathof(KernelAbstractions)), "../examples/utils.jl")) # Load backend
 
 # We use a TILE_DIM of 16 as a safe value since while

src/KernelAbstractions.jl

@@ -200,8 +200,8 @@ Abstract type for all KernelAbstractions backends.
 abstract type Backend end
 
 include("intrinsics.jl")
-import .KernelIntrinsics: KernelIntrinsics, KI
-export KernelIntrinsics, KI
+import .KernelIntrinsics as KI
+export KernelIntrinsics
 
 ###
 # Kernel language

src/intrinsics.jl

@@ -1,7 +1,7 @@
 """
-# `KernelIntrinics`/`KI`
+# `KernelIntrinsics`
 
-The `KernelIntrinics` (or `KI`) module defines the API interface for backends to define various lower-level device and
+The `KernelIntrinsics` (or `KI`) module defines the API interface for backends to define various lower-level device and
 host-side functionality. The `KI` intrinsics are used to define the higher-level device-side
 intrinsics functionality in `KernelAbstractions`.
 
@@ -12,9 +12,6 @@ like allocating arrays on a backend.
 """
 module KernelIntrinsics
 
-const KI = KernelIntrinsics
-export KI
-
 import ..KernelAbstractions: Backend
 import GPUCompiler: split_kwargs, assign_args!
 

src/pocl/backend.jl

@@ -57,7 +57,14 @@ KA.functional(::POCLBackend) = true
 KA.pagelock!(::POCLBackend, x) = nothing
 
 KA.get_backend(::Array) = POCLBackend()
-KA.synchronize(::POCLBackend) = cl.finish(cl.queue())
+
+## Implementation note:
+## The POCL backend uses `Base.Array` as it's array type, so the external operations
+## `broadcast`, `*` and other high-level operations are handled by Julia. In order
+## to provide the same memory synchronization semantics as other backends, we
+## must synchronize upon kernel launch and can't rely on synchronization upon
+## array access. Therefore, `synchronize` is a no-op.
+KA.synchronize(::POCLBackend) = nothing
 KA.supports_float64(::POCLBackend) = true
 KA.supports_unified(::POCLBackend) = true
 
@@ -149,9 +156,9 @@ end
 function (obj::KI.Kernel{POCLBackend})(args...; numworkgroups = 1, workgroupsize = 1)
     KI.check_launch_args(numworkgroups, workgroupsize)
 
-    local_size = (workgroupsize..., ntuple(_->1, 3-length(workgroupsize))...,)
+    local_size = (workgroupsize..., ntuple(_ -> 1, 3 - length(workgroupsize))...)
 
-    numworkgroups = (numworkgroups..., ntuple(_->1, 3-length(numworkgroups))...,)
+    numworkgroups = (numworkgroups..., ntuple(_ -> 1, 3 - length(numworkgroups))...)
     global_size = local_size .* numworkgroups
 
     event = obj.kern(args...; local_size, global_size)

test/intrinsics.jl

@@ -1,3 +1,5 @@
+import KernelAbstractions.KernelIntrinsics as KI
+
 function test_intrinsics_kernel(results)
     # Test all intrinsics return NamedTuples with x, y, z fields
     global_size = KI.get_global_size()