switch name to CUDADevice from CUDAGPU

jakebolewski · jakebolewski · commit 7644f620523a · 2020-06-17T16:05:55.000-06:00
diff --git a/docs/src/index.md b/docs/src/index.md
@@ -55,13 +55,13 @@ all(A .== 2.0)
 1. Functions inside kernels are forcefully inlined, except when marked with `@noinline`.
 2. Floating-point multiplication, addition, subtraction are marked contractable.
 
-## Important differences to CUDA
+## Important differences to CUDA.jl
 
 1. The kernels are automatically bounds-checked against either the dynamic or statically
    provided `ndrange`.
 2. Functions like `Base.sin` are mapped to `CUDA.sin`.
 
-## Important differences to GPUifyLoops
+## Important differences to GPUifyLoops.jl
 
 1. `@scratch` has been renamed to `@private`, and the semantics have changed. Instead
    of denoting how many dimensions are implicit on the GPU, you only ever provide the
diff --git a/examples/matmul.jl b/examples/matmul.jl
@@ -26,7 +26,7 @@ function matmul!(a, b, c)
     if isa(a, Array)
         kernel! = matmul_kernel!(CPU(),4)
     else
-        kernel! = matmul_kernel!(CUDAGPU(),256)
+        kernel! = matmul_kernel!(CUDADevice(),256)
     end
     kernel!(a, b, c, ndrange=size(c)) 
 end
diff --git a/examples/memcopy.jl b/examples/memcopy.jl
@@ -24,7 +24,7 @@ if has_cuda_gpu()
 
     function mycopy!(A::CuArray, B::CuArray)
         @assert size(A) == size(B)
-        copy_kernel!(CUDAGPU(), 256)(A, B, ndrange=length(A))
+        copy_kernel!(CUDADevice(), 256)(A, B, ndrange=length(A))
     end
 
     A = CuArray{Float32}(undef, 1024)
diff --git a/examples/memcopy_static.jl b/examples/memcopy_static.jl
@@ -23,7 +23,7 @@ if has_cuda_gpu()
 
     function mycopy_static!(A::CuArray, B::CuArray)
         @assert size(A) == size(B)
-        kernel = copy_kernel!(CUDAGPU(), 32, size(A)) # if size(A) varies this will cause recompilation
+        kernel = copy_kernel!(CUDADevice(), 32, size(A)) # if size(A) varies this will cause recompilation
         kernel(A, B, ndrange=size(A))
     end
 
diff --git a/examples/mpi.jl b/examples/mpi.jl
@@ -10,7 +10,7 @@ end
 
 using MPI
 
-device(A) = typeof(A) <: Array ? CPU() : CUDAGPU()
+device(A) = typeof(A) <: Array ? CPU() : CUDADevice()
 
 function mpiyield()
     MPI.Iprobe(MPI.MPI_ANY_SOURCE, MPI.MPI_ANY_TAG, MPI.COMM_WORLD)
diff --git a/examples/naive_transpose.jl b/examples/naive_transpose.jl
@@ -19,7 +19,7 @@ function naive_transpose!(a, b)
     if isa(a, Array)
         kernel! = naive_transpose_kernel!(CPU(),4)
     else
-        kernel! = naive_transpose_kernel!(CUDAGPU(),256)
+        kernel! = naive_transpose_kernel!(CUDADevice(),256)
     end
     kernel!(a, b, ndrange=size(a))
 end
diff --git a/examples/performance.jl b/examples/performance.jl
@@ -19,7 +19,7 @@ const nreps = 1
 NVTX.@range "Naive transpose ($block_dim, $block_dim)" let
     a = CuArray(rand(T, shape))
     b = similar(a, shape[2], shape[1])
-    kernel! = transpose_kernel_naive!(CUDAGPU(), (block_dim, block_dim), size(b))
+    kernel! = transpose_kernel_naive!(CUDADevice(), (block_dim, block_dim), size(b))
   
     event = kernel!(b, a)
     wait(event)
@@ -35,7 +35,7 @@ end
 NVTX.@range "Naive transpose ($(block_dim^2), 1)" let
     a = CuArray(rand(T, shape))
     b = similar(a, shape[2], shape[1])
-    kernel! = transpose_kernel_naive!(CUDAGPU(), (block_dim*block_dim, 1), size(b))
+    kernel! = transpose_kernel_naive!(CUDADevice(), (block_dim*block_dim, 1), size(b))
   
     event = kernel!(b, a)
     wait(event)
@@ -51,7 +51,7 @@ end
 NVTX.@range "Naive transpose (1, $(block_dim^2))" let
     a = CuArray(rand(T, shape))
     b = similar(a, shape[2], shape[1])
-    kernel! = transpose_kernel_naive!(CUDAGPU(), (1, block_dim*block_dim), size(b))
+    kernel! = transpose_kernel_naive!(CUDADevice(), (1, block_dim*block_dim), size(b))
   
     event = kernel!(b, a)
     wait(event)
diff --git a/src/KernelAbstractions.jl b/src/KernelAbstractions.jl
@@ -2,7 +2,7 @@ module KernelAbstractions
 
 export @kernel
 export @Const, @localmem, @private, @uniform, @synchronize, @index, groupsize, @print
-export Device, GPU, CPU, CUDAGPU, Event, MultiEvent, NoneEvent
+export Device, GPU, CPU, CUDADevice, Event, MultiEvent, NoneEvent
 export async_copy!
 
 
@@ -303,7 +303,7 @@ abstract type Device end
 abstract type GPU <: Device end
 
 struct CPU <: Device end
-struct CUDAGPU <: GPU end
+struct CUDADevice <: GPU end
 # struct AMD <: GPU end
 # struct Intel <: GPU end
 
diff --git a/src/backends/cuda.jl b/src/backends/cuda.jl
@@ -49,7 +49,7 @@ end
 failed(::CudaEvent) = false
 isdone(ev::CudaEvent) = CUDA.query(ev.event)
 
-function Event(::CUDAGPU)
+function Event(::CUDADevice)
     stream = CUDA.CuDefaultStream()
     event = CUDA.CuEvent(CUDA.EVENT_DISABLE_TIMING)
     CUDA.record(event, stream)
@@ -69,25 +69,25 @@ function wait(::CPU, ev::CudaEvent, progress=yield)
 end
 
 # Use this to synchronize between computation using the CuDefaultStream
-wait(::CUDAGPU, ev::CudaEvent, progress=nothing, stream=CUDA.CuDefaultStream()) = CUDA.wait(ev.event, stream)
-wait(::CUDAGPU, ev::NoneEvent, progress=nothing, stream=nothing) = nothing
+wait(::CUDADevice, ev::CudaEvent, progress=nothing, stream=CUDA.CuDefaultStream()) = CUDA.wait(ev.event, stream)
+wait(::CUDADevice, ev::NoneEvent, progress=nothing, stream=nothing) = nothing
 
-function wait(::CUDAGPU, ev::MultiEvent, progress=nothing, stream=CUDA.CuDefaultStream())
+function wait(::CUDADevice, ev::MultiEvent, progress=nothing, stream=CUDA.CuDefaultStream())
     dependencies = collect(ev.events)
     cudadeps  = filter(d->d isa CudaEvent,    dependencies)
     otherdeps = filter(d->!(d isa CudaEvent), dependencies)
     for event in cudadeps
         CUDA.wait(event.event, stream)
     end
     for event in otherdeps
-        wait(CUDAGPU(), event, progress, stream)
+        wait(CUDADevice(), event, progress, stream)
     end
 end
 
 include("cusynchronization.jl")
 import .CuSynchronization: unsafe_volatile_load, unsafe_volatile_store!
 
-function wait(::CUDAGPU, ev::CPUEvent, progress=nothing, stream=nothing)
+function wait(::CUDADevice, ev::CPUEvent, progress=nothing, stream=nothing)
     error("""
     Waiting on the GPU for an CPU event to finish is currently not supported.
     We have encountered deadlocks arising, due to interactions with the CUDA
@@ -106,7 +106,7 @@ end
 # TODO:
 # - In case of an error we should probably also kill the waiting GPU code.
 unsafe_wait(dev::Device, ev, progress=nothing) = wait(dev, ev, progress) 
-function unsafe_wait(::CUDAGPU, ev::CPUEvent, progress=nothing, stream=CUDA.CuDefaultStream())
+function unsafe_wait(::CUDADevice, ev::CPUEvent, progress=nothing, stream=CUDA.CuDefaultStream())
     buf = CUDA.Mem.alloc(CUDA.Mem.HostBuffer, sizeof(UInt32), CUDA.Mem.HOSTREGISTER_DEVICEMAP)
     unsafe_store!(convert(Ptr{UInt32}, buf), UInt32(0))
     # TODO: Switch to `@spawn` when CUDA.jl is thread-safe
@@ -150,12 +150,12 @@ function __pin!(a)
     return nothing
 end
 
-function async_copy!(::CUDAGPU, A, B; dependencies=nothing, progress=yield)
+function async_copy!(::CUDADevice, A, B; dependencies=nothing, progress=yield)
     A isa Array && __pin!(A)
     B isa Array && __pin!(B)
 
     stream = next_stream()
-    wait(CUDAGPU(), MultiEvent(dependencies), progress, stream)
+    wait(CUDADevice(), MultiEvent(dependencies), progress, stream)
     event = CUDA.CuEvent(CUDA.EVENT_DISABLE_TIMING)
     GC.@preserve A B begin
         destptr = pointer(A)
@@ -173,7 +173,7 @@ end
 ###
 # Kernel launch
 ###
-function (obj::Kernel{CUDAGPU})(args...; ndrange=nothing, dependencies=nothing, workgroupsize=nothing, progress=yield)
+function (obj::Kernel{CUDADevice})(args...; ndrange=nothing, dependencies=nothing, workgroupsize=nothing, progress=yield)
     if ndrange isa Integer
         ndrange = (ndrange,)
     end
@@ -203,7 +203,7 @@ function (obj::Kernel{CUDAGPU})(args...; ndrange=nothing, dependencies=nothing,
     end
 
     stream = next_stream()
-    wait(CUDAGPU(), MultiEvent(dependencies), progress, stream)
+    wait(CUDADevice(), MultiEvent(dependencies), progress, stream)
 
     ctx = mkcontext(obj, ndrange, iterspace)
     # Launch kernel
@@ -218,7 +218,7 @@ end
 
 Cassette.@context CUDACtx
 
-function mkcontext(kernel::Kernel{CUDAGPU}, _ndrange, iterspace)
+function mkcontext(kernel::Kernel{CUDADevice}, _ndrange, iterspace)
     metadata = CompilerMetadata{ndrange(kernel), DynamicCheck}(_ndrange, iterspace)
     Cassette.disablehooks(CUDACtx(pass = CompilerPass, metadata=metadata))
 end
diff --git a/test/async_copy.jl b/test/async_copy.jl
@@ -20,6 +20,6 @@ end
 M = 1024
 
 if has_cuda_gpu()
-    copy_test(CUDAGPU(), CuArray, M)
+    copy_test(CUDADevice(), CuArray, M)
 end
-copy_test(CPU(), Array, M)
+copy_test(CPU(), Array, M)
diff --git a/test/events.jl b/test/events.jl
@@ -28,8 +28,8 @@ if has_cuda_gpu()
     barrier = Base.Threads.Event()
     cpu_event = Event(wait, barrier)
 
-    KernelAbstractions.unsafe_wait(CUDAGPU(), cpu_event) # Event edge on CuDefaultStream
-    gpu_event = Event(CUDAGPU()) # Event on CuDefaultStream
+    KernelAbstractions.unsafe_wait(CUDADevice(), cpu_event) # Event edge on CuDefaultStream
+    gpu_event = Event(CUDADevice()) # Event on CuDefaultStream
 
     notify(barrier)
     wait(gpu_event)
diff --git a/test/localmem.jl b/test/localmem.jl
@@ -53,6 +53,6 @@ end
 @testset "kernels" begin
     harness(CPU(), Array)
     if has_cuda_gpu()
-        harness(CUDAGPU(), CuArray)
+        harness(CUDADevice(), CuArray)
     end
 end
diff --git a/test/print_test.jl b/test/print_test.jl
@@ -17,7 +17,7 @@ end
 
 @testset "print test" begin
     if has_cuda_gpu()
-        wait(test_print(CUDAGPU()))
+        wait(test_print(CUDADevice()))
         @test true
     end
 
diff --git a/test/private.jl b/test/private.jl
@@ -65,6 +65,6 @@ end
 @testset "kernels" begin
     harness(CPU(), Array)
     if has_cuda_gpu()
-        harness(CUDAGPU(), CuArray)
+        harness(CUDADevice(), CuArray)
     end
 end
diff --git a/test/test.jl b/test/test.jl
@@ -109,7 +109,7 @@ end
 @testset "indextest" begin
     indextest(CPU(), Array)
     if has_cuda_gpu()
-        indextest(CUDAGPU(), CuArray)
+        indextest(CUDADevice(), CuArray)
     end
 end
 
@@ -134,7 +134,7 @@ end
     end
 
     if has_cuda_gpu()
-        let kernel = constarg(CUDAGPU(), 8, (1024,))
+        let kernel = constarg(CUDADevice(), 8, (1024,))
             # this is poking at internals
             iterspace = NDRange{1, StaticSize{(128,)}, StaticSize{(8,)}}();
             ctx = KernelAbstractions.mkcontext(kernel, nothing, iterspace)
@@ -159,7 +159,7 @@ wait(kernel_val!(CPU())(A,Val(3), ndrange=size(A)))
 @test all((a)->a==3, A)
 if has_cuda_gpu()
     A = CUDA.zeros(Int64, 1024)
-    wait(kernel_val!(CUDAGPU())(A,Val(3), ndrange=size(A)))
+    wait(kernel_val!(CUDADevice())(A,Val(3), ndrange=size(A)))
     @test all((a)->a==3, A)
 end
 
@@ -169,24 +169,24 @@ end
 if has_cuda_gpu()
     @testset "CPU--CUDA dependencies" begin
         event1 = kernel_empty(CPU(), 1)(ndrange=1)
-        event2 = kernel_empty(CUDAGPU(), 1)(ndrange=1)
+        event2 = kernel_empty(CUDADevice(), 1)(ndrange=1)
         event3 = kernel_empty(CPU(), 1)(ndrange=1)
-        event4 = kernel_empty(CUDAGPU(), 1)(ndrange=1)
-        @test_throws ErrorException event5 = kernel_empty(CUDAGPU(), 1)(ndrange=1, dependencies=(event1, event2, event3, event4))
+        event4 = kernel_empty(CUDADevice(), 1)(ndrange=1)
+        @test_throws ErrorException event5 = kernel_empty(CUDADevice(), 1)(ndrange=1, dependencies=(event1, event2, event3, event4))
         # wait(event5)
         # @test event5 isa KernelAbstractions.Event
 
         event1 = kernel_empty(CPU(), 1)(ndrange=1)
-        event2 = kernel_empty(CUDAGPU(), 1)(ndrange=1)
+        event2 = kernel_empty(CUDADevice(), 1)(ndrange=1)
         event3 = kernel_empty(CPU(), 1)(ndrange=1)
-        event4 = kernel_empty(CUDAGPU(), 1)(ndrange=1)
+        event4 = kernel_empty(CUDADevice(), 1)(ndrange=1)
         event5 = kernel_empty(CPU(), 1)(ndrange=1, dependencies=(event1, event2, event3, event4))
         wait(event5)
         @test event5 isa KernelAbstractions.Event
     end
     @testset "CUDA wait" begin
-        event = kernel_empty(CUDAGPU(), 1)(ndrange=1)
-        wait(CUDAGPU(), event)
+        event = kernel_empty(CUDADevice(), 1)(ndrange=1)
+        wait(CUDADevice(), event)
         @test event isa KernelAbstractions.Event
     end
 end
@@ -210,9 +210,9 @@ end
 
 if has_cuda_gpu()
   @testset "MultiEvent CUDA" begin
-    event1 = kernel_empty(CUDAGPU(), 1)(ndrange=1)
+    event1 = kernel_empty(CUDADevice(), 1)(ndrange=1)
     event2 = kernel_empty(CPU(), 1)(ndrange=1)
-    event3 = kernel_empty(CUDAGPU(), 1)(ndrange=1)
+    event3 = kernel_empty(CUDADevice(), 1)(ndrange=1)
 
     @test MultiEvent(event1) isa Event
     @test MultiEvent((event1, event2, event3)) isa Event
@@ -230,10 +230,10 @@ end
 
 if has_cuda_gpu()
     @testset "Zero iteration space CUDA" begin
-        event1 = kernel_empty(CUDAGPU(), 1)(ndrange=1)
-        event2 = kernel_empty(CUDAGPU(), 1)(ndrange=0; dependencies=event1)
+        event1 = kernel_empty(CUDADevice(), 1)(ndrange=1)
+        event2 = kernel_empty(CUDADevice(), 1)(ndrange=0; dependencies=event1)
         @test event2 == MultiEvent(event1)
-        event = kernel_empty(CUDAGPU(), 1)(ndrange=0)
+        event = kernel_empty(CUDADevice(), 1)(ndrange=0)
         @test event == MultiEvent(nothing)
     end
 end
@@ -287,7 +287,7 @@ end
     if has_cuda_gpu()
         cx = CuArray(x)
         cy = similar(cx)
-        event = gamma_knl(CUDAGPU())(cy, cx; ndrange=length(x))
+        event = gamma_knl(CUDADevice())(cy, cx; ndrange=length(x))
         wait(event)
 
         cy = Array(cy)
