adding a few more tests

Author: leios

src/KernelAbstractions.jl

@@ -2,7 +2,6 @@ module KernelAbstractions
 
 export @kernel
 export @Const, @localmem, @private, @uniform, @synchronize, @index, @groupsize, @print
-export @atomic, atomic_add!
 export Device, GPU, CPU, Event, MultiEvent, NoneEvent
 export async_copy!
 

src/atomics.jl

@@ -2,6 +2,10 @@
 # Atomics
 ###
 
+export @atomic, atomic_add!, atomic_sub!, atomic_and!, atomic_or!, atomic_xor!,
+       atomic_min!, atomic_max!, atomic_inc!, atomic_dec!, atomic_xchg!,
+       atomic_op!, atomic_cas!
+
 """
     @atomic macro
 
@@ -54,20 +58,22 @@ function atomic_cas!(ptr::Ptr{T}, old::T, new::T) where T
 end
 
 # Implementation of: (((old == 0) | (old > b)) ? b : (old-1)), returns old
+# Currently broken
 function atomic_dec!(ptr::Ptr{T}, b::T) where T
+    Core.Intrinsics.atomic_fence(:monotonic)
     if (unsafe_load(ptr) == 0 | unsafe_load(ptr) > b)
         Core.Intrinsics.atomic_pointerswap(ptr, b, :monotonic)
     else
-        Core.Intrinsics.atomic_pointermodify(ptr, -, 1, :monotonic)
+        Core.Intrinsics.atomic_pointermodify(ptr, -, T(1), :monotonic)
     end
 end
 
 # implementation of: ((old >= b) ? 0 : (old+1)), returns old
 function atomic_inc!(ptr::Ptr{T}, b::T) where T
     if unsafe_load(ptr) >= b
-        Core.Intrinsics.atomic_pointerswap(ptr, 0, :monotonic)
+        Core.Intrinsics.atomic_pointerswap(ptr, T(0), :monotonic)
     else
-        Core.Intrinsics.atomic_pointermodify(ptr, +, 1, :monotonic)
+        Core.Intrinsics.atomic_pointermodify(ptr, +, T(1), :monotonic)
     end
 end
 

test/atomic_test.jl

@@ -1,16 +1,28 @@
-using KernelAbstractions, Test
+using KernelAbstractions, CUDA, Test
 
 # Note: kernels affect second element because some CPU defaults will affect the
 #       first element of a pointer if not specified, so I am covering the bases
 @kernel function atomic_add_kernel(input, b)
     atomic_add!(pointer(input,2),b) 
 end
 
+@kernel function atomic_sub_kernel(input, b)
+    atomic_sub!(pointer(input,2),b) 
+end
+
+@kernel function atomic_inc_kernel(input, b)
+    atomic_inc!(pointer(input,2),b) 
+end
+
+@kernel function atomic_dec_kernel(input, b)
+    atomic_dec!(pointer(input,2),b) 
+end
+
 function atomics_testsuite(backend)
 
     @testset "atomic addition tests" begin
         types = [Int32, Int64, UInt32, UInt64, Float32]
-        if ArrayT == CuArray
+        if ArrayT != CuArray
             CUDA.capability(CUDA.device()) >= v"6.0" && push!(types, Float64)
             CUDA.capability(CUDA.device()) >= v"7.0" && push!(types, Float16)
         else
@@ -27,4 +39,52 @@ function atomics_testsuite(backend)
             @test Array(A)[2] == 1024
         end
     end
+
+    @testset "atomic subtraction tests" begin
+        types = [Int32, Int64, UInt32, UInt64, Float32]
+        if ArrayT == CuArray
+            CUDA.capability(CUDA.device()) >= v"6.0" && push!(types, Float64)
+            CUDA.capability(CUDA.device()) >= v"7.0" && push!(types, Float16)
+        else
+            push!(types, Float64)
+            push!(types, Float16)
+        end
+
+        for T in types
+            A = ArrayT{T}([2048,2048])
+
+            kernel = atomic_sub_kernel(backend(), 4)
+            wait(kernel(A, one(T), ndrange=(1024)))
+
+            @test Array(A)[2] == 1024
+        end
+    end
+
+    @testset "atomic inc tests" begin
+        types = [Int32]
+
+        for T in types
+            A = ArrayT{T}([0,0])
+
+            kernel = atomic_inc_kernel(backend(), 4)
+            wait(kernel(A, T(512), ndrange=(768)))
+
+            @test Array(A)[2] == 255
+        end
+    end
+
+    @testset "atomic dec tests" begin
+        types = [Int32]
+
+        for T in types
+            A = ArrayT{T}([1024,1024])
+
+            kernel = atomic_inc_kernel(backend(), 4)
+            wait(kernel(A, T(512), ndrange=(256)))
+
+            @test Array(A)[2] == 257
+        end
+    end
+
+
 end