removing @atomic macro

Author: leios

lib/CUDAKernels/src/CUDAKernels.jl

@@ -320,7 +320,7 @@ else
 end
 
 import KernelAbstractions: ConstAdaptor, SharedMemory, Scratchpad, __synchronize, __size
-import KernelAbstractions: __atomic, atomic_add!, atomic_and!, atomic_cas!, atomic_dec!, atomic_inc!, atomic_max!, atomic_min!, atomic_op!, atomic_or!, atomic_sub!, atomic_xchg!, atomic_xor!
+import KernelAbstractions: atomic_add!, atomic_and!, atomic_cas!, atomic_dec!, atomic_inc!, atomic_max!, atomic_min!, atomic_op!, atomic_or!, atomic_sub!, atomic_xchg!, atomic_xor!
 
 ###
 # GPU implementation of shared memory
@@ -386,11 +386,6 @@ end
 # GPU implementation of atomics
 ###
 
-@inline function Cassette.overdub(::CUDACtx, ::typeof(__atomic), ex)
-    #CUDA.@atomic(ex)
-    KernelAbstractions.@print(ex)
-end
-
 afxs = Dict(
     atomic_add! => CUDA.atomic_add!,
     atomic_and! => CUDA.atomic_and!,

src/atomics.jl

@@ -2,7 +2,7 @@
 # Atomics
 ###
 
-export @atomic, atomic_add!, atomic_sub!, atomic_and!, atomic_or!, atomic_xor!,
+export atomic_add!, atomic_sub!, atomic_and!, atomic_or!, atomic_xor!,
        atomic_min!, atomic_max!, atomic_inc!, atomic_dec!, atomic_xchg!,
        atomic_op!, atomic_cas!
 
@@ -15,33 +15,6 @@ function inc(a::T,b::T) where T
     (a >= b) ? T(0) : (a+T(1))
 end
 
-"""
-    @atomic macro
-
-This is a unified atomic interface
-
-# Platform differences
-  - `GPU`: This uses standard `@atomic` calls from CUDA.jl
-  - `CPU`: This reorganized the command to use atomic pointer logic
-"""
-
-# TODO: Remove?
-#const atomic_acquire = LLVM.API.LLVMAtomicOrderingAcquire
-#const atomic_release = LLVM.API.LLVMAtomicOrderingRelease
-#const atomic_acquire_release = LLVM.API.LLVMAtomicOrderingAcquireRelease
-
-# NOTE: This only grabs the first symbol of the expression, not the entire expr
-macro atomic(ex)
-    quote
-        $__atomic($ex)
-    end
-end
-
-# Implement CPU macro here?
-function __atomic(ex)
-    error("@atomic macro incomplete!")
-end
-
 # arithmetic, bitwise, min/max, and inc/dec operations
 const ops = Dict(
     :atomic_add!   => +,
@@ -107,18 +80,10 @@ function atomic_op!(ptr::Ptr{T}, op, b::T) where T
     Core.Intrinsics.atomic_pointermodify(ptr::Ptr{T}, op, b::T, :monotonic)
 end
 
-###
-# CPU implementation of atomic macro
-###
-
-#@inline function Cassette.overdub(::CPUCtx, ::typeof(__atomic), ex)
-#    println(ex)
-#end
-
 # Other Documentation
 
 """
-    atomic_add!(ptr::LLVMPtr{T}, val::T)
+    atomic_add!(ptr::Ptr{T}, val::T)
 
 This is an atomic addition.
 It reads the value `old` located at address `ptr`, computes `old + val`, and stores the result back to memory at the same address.
@@ -131,7 +96,7 @@ Additionally, on GPU hardware with compute capability 6.0+, values of type Float
 atomic_add!
 
 """
-    atomic_sub!(ptr::LLVMPtr{T}, val::T)
+    atomic_sub!(ptr::Ptr{T}, val::T)
 
 This is an atomic subtraction.
 It reads the value `old` located at address `ptr`, computes `old - val`, and stores the result back to memory at the same address.
@@ -143,7 +108,7 @@ This operation is supported for values of type Int32, Int64, UInt32 and UInt64.
 atomic_sub!
 
 """
-    atomic_and!(ptr::LLVMPtr{T}, val::T)
+    atomic_and!(ptr::Ptr{T}, val::T)
 
 This is an atomic and.
 It reads the value `old` located at address `ptr`, computes `old & val`, and stores the result back to memory at the same address.
@@ -155,7 +120,7 @@ This operation is supported for values of type Int32, Int64, UInt32 and UInt64.
 atomic_and!
 
 """
-    atomic_or!(ptr::LLVMPtr{T}, val::T)
+    atomic_or!(ptr::Ptr{T}, val::T)
 
 This is an atomic or.
 It reads the value `old` located at address `ptr`, computes `old | val`, and stores the result back to memory at the same address.
@@ -167,7 +132,7 @@ This operation is supported for values of type Int32, Int64, UInt32 and UInt64.
 atomic_or!
 
 """
-    atomic_xor!(ptr::LLVMPtr{T}, val::T)
+    atomic_xor!(ptr::Ptr{T}, val::T)
 
 This is an atomic xor.
 It reads the value `old` located at address `ptr`, computes `old ⊻ val`, and stores the result back to memory at the same address.
@@ -179,7 +144,7 @@ This operation is supported for values of type Int32, Int64, UInt32 and UInt64.
 atomic_xor!
 
 """
-    atomic_min!(ptr::LLVMPtr{T}, val::T)
+    atomic_min!(ptr::Ptr{T}, val::T)
 
 This is an atomic min.
 It reads the value `old` located at address `ptr`, computes `min(old, val)`, and st ores the result back to memory at the same address.
@@ -191,7 +156,7 @@ This operation is supported for values of type Int32, Int64, UInt32 and UInt64.
 atomic_min!
 
 """
-    atomic_max!(ptr::LLVMPtr{T}, val::T)
+    atomic_max!(ptr::Ptr{T}, val::T)
 
 This is an atomic max.
 It reads the value `old` located at address `ptr`, computes `max(old, val)`, and st ores the result back to memory at the same address.
@@ -203,7 +168,7 @@ This operation is supported for values of type Int32, Int64, UInt32 and UInt64.
 atomic_max!
 
 """
-    atomic_inc!(ptr::LLVMPtr{T}, val::T)
+    atomic_inc!(ptr::Ptr{T}, val::T)
 
 This is an atomic increment function that counts up to a certain number before starting again at 0.
 It reads the value `old` located at address `ptr`, computes `((old >= val) ? 0 : (o ld+1))`, and stores the result back to memory at the same address.
@@ -215,7 +180,7 @@ This operation is only supported for values of type Int32.
 atomic_inc!
 
 """
-    atomic_dec!(ptr::LLVMPtr{T}, val::T)
+    atomic_dec!(ptr::Ptr{T}, val::T)
 
 This is an atomic decrement function that counts down to 0 from a defined value `val`.
 It reads the value `old` located at address `ptr`, computes `(((old == 0) | (old > val)) ? val : (old-1))`, and stores the result back to memory at the same address.