Merge #337

337: WIP: Adapt to the new CUDAdrv.CuPtr pointer type. r=maleadt a=maleadt

JuliaGPU/CUDAdrv.jl#125

Co-authored-by: Tim Besard <[email protected]>

Author: bors[bot]

REQUIRE

@@ -1,5 +1,5 @@
 julia 1.0
-CUDAdrv 1.0
+CUDAdrv 1.1
 LLVM 0.9.14
 CUDAapi 0.4.0
 Adapt 0.4

docs/make.jl

@@ -1,10 +1,12 @@
-using Documenter, CUDAnative
+using Documenter
 
 using Pkg
 if haskey(ENV, "GITLAB_CI")
   Pkg.add([PackageSpec(name = x; rev = "master") for x in ["CUDAdrv", "LLVM"]])
 end
 
+using CUDAnative
+
 makedocs(
     modules = [CUDAnative],
     format = Documenter.HTML(prettyurls = get(ENV, "CI", nothing) == "true"),

src/device/cuda_intrinsics/memory_shared.jl

@@ -23,7 +23,7 @@ macro cuStaticSharedMem(T, dims)
     quote
         len = prod($(esc(dims)))
         ptr = _shmem(Val($id), $(esc(T)), Val(len))
-        CuDeviceArray($(esc(dims)), DevicePtr{$(esc(T)), AS.Shared}(ptr))
+        CuDeviceArray($(esc(dims)), ptr)
     end
 end
 
@@ -49,15 +49,15 @@ macro cuDynamicSharedMem(T, dims, offset=0)
     quote
         len = prod($(esc(dims)))
         ptr = _shmem(Val($id), $(esc(T))) + $(esc(offset))
-        CuDeviceArray($(esc(dims)), DevicePtr{$(esc(T)), AS.Shared}(ptr))
+        CuDeviceArray($(esc(dims)), ptr)
     end
 end
 
 # get a pointer to shared memory, with known (static) or zero length (dynamic shared memory)
 @generated function _shmem(::Val{id}, ::Type{T}, ::Val{len}=Val(0)) where {id,T,len}
     eltyp = convert(LLVMType, T)
 
-    T_ptr = convert(LLVMType, Ptr{T})
+    T_ptr = convert(LLVMType, DevicePtr{T,AS.Shared})
     T_actual_ptr = LLVM.PointerType(eltyp)
 
     # create a function
@@ -96,5 +96,5 @@ end
         ret!(builder, val)
     end
 
-    call_function(llvm_f, Ptr{T})
+    call_function(llvm_f, DevicePtr{T,AS.Shared})
 end

src/device/pointer.jl

@@ -10,8 +10,7 @@ abstract type AddressSpace end
 
 module AS
 
-using CUDAnative
-import CUDAnative: AddressSpace
+import ..AddressSpace
 
 struct Generic  <: AddressSpace end
 struct Global   <: AddressSpace end
@@ -26,27 +25,30 @@ end
 # Device pointer
 #
 
-struct DevicePtr{T,A}
-    ptr::Ptr{T}
+"""
+    DevicePtr{T,A}
 
-    # inner constructors, fully parameterized
-    DevicePtr{T,A}(ptr::Ptr{T}) where {T,A<:AddressSpace} = new(ptr)
-end
-
-# outer constructors, partially parameterized
-DevicePtr{T}(ptr::Ptr{T}) where {T} = DevicePtr{T,AS.Generic}(ptr)
+A memory address that refers to data of type `T` that is accessible from the GPU. It is the
+on-device counterpart of `CUDAdrv.CuPtr`, additionally keeping track of the address space
+`A` where the data resides (shared, global, constant, etc). This information is used to
+provide optimized implementations of operations such as `unsafe_load` and `unsafe_store!.`
+"""
+DevicePtr
 
-# outer constructors, non-parameterized
-DevicePtr(ptr::Ptr{T})              where {T} = DevicePtr{T,AS.Generic}(ptr)
+if sizeof(Ptr{Cvoid}) == 8
+    primitive type DevicePtr{T,A} 64 end
+else
+    primitive type DevicePtr{T,A} 32 end
+end
 
-Base.show(io::IO, dp::DevicePtr{T,AS}) where {T,AS} =
-    print(io, AS.name.name, " Device", pointer(dp))
+# constructors
+DevicePtr{T,A}(x::Union{Int,UInt,CuPtr,DevicePtr}) where {T,A<:AddressSpace} = Base.bitcast(DevicePtr{T,A}, x)
+DevicePtr{T}(ptr::CuPtr{T}) where {T} = DevicePtr{T,AS.Generic}(ptr)
+DevicePtr(ptr::CuPtr{T}) where {T} = DevicePtr{T,AS.Generic}(ptr)
 
 
 ## getters
 
-Base.pointer(p::DevicePtr) = p.ptr
-
 Base.eltype(::Type{<:DevicePtr{T}}) where {T} = T
 
 addrspace(x::DevicePtr) = addrspace(typeof(x))
@@ -55,20 +57,23 @@ addrspace(::Type{DevicePtr{T,A}}) where {T,A} = A
 
 ## conversions
 
-# between regular and device pointers
-## simple conversions disallowed
-Base.convert(::Type{Ptr{T}}, p::DevicePtr{T})        where {T} = throw(InexactError(:convert, Ptr{T}, p))
-Base.convert(::Type{<:DevicePtr{T}}, p::Ptr{T})      where {T} = throw(InexactError(:convert, DevicePtr{T}, p))
-## unsafe ones are allowed
-Base.unsafe_convert(::Type{Ptr{T}}, p::DevicePtr{T}) where {T} = pointer(p)
+# to and from integers
+## pointer to integer
+Base.convert(::Type{T}, x::DevicePtr) where {T<:Integer} = T(UInt(x))
+## integer to pointer
+Base.convert(::Type{DevicePtr{T,A}}, x::Union{Int,UInt}) where {T,A<:AddressSpace} = DevicePtr{T,A}(x)
+Int(x::DevicePtr)  = Base.bitcast(Int, x)
+UInt(x::DevicePtr) = Base.bitcast(UInt, x)
 
-# defer conversions to DevicePtr to unsafe_convert
-Base.cconvert(::Type{<:DevicePtr}, x) = x
+# between host and device pointers
+Base.convert(::Type{CuPtr{T}},  p::DevicePtr)  where {T}                 = Base.bitcast(CuPtr{T}, p)
+Base.convert(::Type{DevicePtr{T,A}}, p::CuPtr) where {T,A<:AddressSpace} = Base.bitcast(DevicePtr{T,A}, p)
+Base.convert(::Type{DevicePtr{T}}, p::CuPtr)   where {T}                 = Base.bitcast(DevicePtr{T,AS.Generic}, p)
 
 # between device pointers
-Base.convert(::Type{<:DevicePtr}, p::DevicePtr)                         = throw(InexactError(:convert, DevicePtr, p))
+Base.convert(::Type{<:DevicePtr}, p::DevicePtr)                         = throw(ArgumentError("cannot convert between incompatible device pointer types"))
 Base.convert(::Type{DevicePtr{T,A}}, p::DevicePtr{T,A})   where {T,A}   = p
-Base.unsafe_convert(::Type{DevicePtr{T,A}}, p::DevicePtr) where {T,A}   = DevicePtr{T,A}(reinterpret(Ptr{T}, pointer(p)))
+Base.unsafe_convert(::Type{DevicePtr{T,A}}, p::DevicePtr) where {T,A}   = Base.bitcast(DevicePtr{T,A}, p)
 ## identical addrspaces
 Base.convert(::Type{DevicePtr{T,A}}, p::DevicePtr{U,A}) where {T,U,A} = Base.unsafe_convert(DevicePtr{T,A}, p)
 ## convert to & from generic
@@ -78,19 +83,25 @@ Base.convert(::Type{DevicePtr{T,AS.Generic}}, p::DevicePtr{T,AS.Generic}) where
 ## unspecified, preserve source addrspace
 Base.convert(::Type{DevicePtr{T}}, p::DevicePtr{U,A}) where {T,U,A} = Base.unsafe_convert(DevicePtr{T,A}, p)
 
+# defer conversions to DevicePtr to unsafe_convert
+Base.cconvert(::Type{<:DevicePtr}, x) = x
+
 
 ## limited pointer arithmetic & comparison
 
-Base.:(==)(a::DevicePtr, b::DevicePtr) = pointer(a) == pointer(b) && addrspace(a) == addrspace(b)
+isequal(x::DevicePtr, y::DevicePtr) = (x === y) && addrspace(x) == addrspace(y)
+isless(x::DevicePtr{T,A}, y::DevicePtr{T,A}) where {T,A<:AddressSpace} = x < y
 
-Base.isless(x::DevicePtr, y::DevicePtr) = Base.isless(pointer(x), pointer(y))
-Base.:(-)(x::DevicePtr, y::DevicePtr)   = pointer(x) - pointer(y)
+Base.:(==)(x::DevicePtr, y::DevicePtr) = UInt(x) == UInt(y) && addrspace(x) == addrspace(y)
+Base.:(<)(x::DevicePtr,  y::DevicePtr) = UInt(x) < UInt(y)
+Base.:(-)(x::DevicePtr,  y::DevicePtr) = UInt(x) - UInt(y)
 
-Base.:(+)(x::DevicePtr{T,A}, y::Integer) where {T,A} = DevicePtr{T,A}(pointer(x) + y)
-Base.:(-)(x::DevicePtr{T,A}, y::Integer) where {T,A} = DevicePtr{T,A}(pointer(x) - y)
+Base.:(+)(x::DevicePtr, y::Integer) = oftype(x, Base.add_ptr(UInt(x), (y % UInt) % UInt))
+Base.:(-)(x::DevicePtr, y::Integer) = oftype(x, Base.sub_ptr(UInt(x), (y % UInt) % UInt))
 Base.:(+)(x::Integer, y::DevicePtr) = y + x
 
 
+
 ## memory operations
 
 Base.convert(::Type{Int}, ::Type{AS.Generic})  = 0
@@ -121,7 +132,7 @@ tbaa_addrspace(as::Type{<:AddressSpace}) = tbaa_make_child(lowercase(String(as.n
     eltyp = convert(LLVMType, T)
 
     T_int = convert(LLVMType, Int)
-    T_ptr = convert(LLVMType, Ptr{T})
+    T_ptr = convert(LLVMType, DevicePtr{T,A})
 
     T_actual_ptr = LLVM.PointerType(eltyp)
 
@@ -148,15 +159,15 @@ tbaa_addrspace(as::Type{<:AddressSpace}) = tbaa_make_child(lowercase(String(as.n
         ret!(builder, ld)
     end
 
-    call_function(llvm_f, T, Tuple{Ptr{T}, Int}, :((pointer(p), Int(i-one(i)))))
+    call_function(llvm_f, T, Tuple{DevicePtr{T,A}, Int}, :((p, Int(i-one(i)))))
 end
 
 @generated function Base.unsafe_store!(p::DevicePtr{T,A}, x, i::Integer=1,
                                        ::Val{align}=Val(1)) where {T,A,align}
     eltyp = convert(LLVMType, T)
 
     T_int = convert(LLVMType, Int)
-    T_ptr = convert(LLVMType, Ptr{T})
+    T_ptr = convert(LLVMType, DevicePtr{T,A})
 
     T_actual_ptr = LLVM.PointerType(eltyp)
 
@@ -184,7 +195,8 @@ end
         ret!(builder)
     end
 
-    call_function(llvm_f, Cvoid, Tuple{Ptr{T}, T, Int}, :((pointer(p), convert(T,x), Int(i-one(i)))))
+    call_function(llvm_f, Cvoid, Tuple{DevicePtr{T,A}, T, Int},
+                  :((p, convert(T,x), Int(i-one(i)))))
 end
 
 ## loading through the texture cache
@@ -215,7 +227,7 @@ const CachedLoadPointers = Union{Tuple(DevicePtr{T,AS.Global}
 
     T_int = convert(LLVMType, Int)
     T_int32 = LLVM.Int32Type(JuliaContext())
-    T_ptr = convert(LLVMType, Ptr{T})
+    T_ptr = convert(LLVMType, DevicePtr{T,AS.Global})
 
     T_actual_ptr = LLVM.PointerType(eltyp)
     T_actual_ptr_as = LLVM.PointerType(eltyp, convert(Int, AS.Global))
@@ -258,7 +270,7 @@ const CachedLoadPointers = Union{Tuple(DevicePtr{T,AS.Global}
         ret!(builder, ld)
     end
 
-    call_function(llvm_f, T, Tuple{Ptr{T}, Int}, :((pointer(p), Int(i-one(i)))))
+    call_function(llvm_f, T, Tuple{DevicePtr{T,AS.Global}, Int}, :((p, Int(i-one(i)))))
 end
 
 @inline unsafe_cached_load(p::DevicePtr{T,AS.Global}, i::Integer=1, args...) where {T} =

src/execution.jl

@@ -128,6 +128,9 @@ end
 
 struct Adaptor end
 
+# convert CUDAdrv pointers to CUDAnative pointers
+Adapt.adapt_storage(to::Adaptor, p::CuPtr{T}) where {T} = DevicePtr{T,AS.Generic}(p)
+
 # Base.RefValue isn't GPU compatible, so provide a compatible alternative
 struct CuRefValue{T} <: Ref{T}
   x::T

test/device/array.jl

@@ -3,8 +3,7 @@
 @testset "constructors" begin
     # inner constructors
     let
-        p = Ptr{Int}(C_NULL)
-        dp = CUDAnative.DevicePtr(p)
+        dp = CUDAnative.DevicePtr{Int,AS.Generic}(0)
         CuDeviceArray{Int,1,AS.Generic}((1,), dp)
     end
 
@@ -13,8 +12,7 @@
         a = I(1)
         b = I(2)
 
-        p = Ptr{I}(C_NULL)
-        dp = CUDAnative.DevicePtr(p)
+        dp = CUDAnative.DevicePtr{I,AS.Generic}(0)
 
         # not parameterized
         CuDeviceArray(b, dp)
@@ -138,7 +136,7 @@ end
 
     a = [1]
     p = pointer(a)
-    dp = CUDAnative.DevicePtr(p)
+    dp = Base.bitcast(CUDAnative.DevicePtr{eltype(p), AS.Generic}, p)
     da = CUDAnative.CuDeviceArray(1, dp)
     load_index(da)
 end

test/device/codegen.jl

@@ -12,7 +12,9 @@
     end
 
     buf = Mem.alloc(Float64)
-    @cuda kernel(convert(Ptr{Float64}, buf.ptr), (1., 2., ))
+    ptr = Base.unsafe_convert(CuPtr{Float64}, buf)
+
+    @cuda kernel(ptr, (1., 2., ))
     @test Mem.download(Float64, buf) == [1.]
 end
 
@@ -32,7 +34,9 @@ end
         return
     end
 
-    @cuda threads=2 kernel(CuDeviceArray((2,1), CUDAnative.DevicePtr(convert(Ptr{Int}, out_buf.ptr))), a, b)
+    ptr = Base.unsafe_convert(CuPtr{Int}, out_buf)
+
+    @cuda threads=2 kernel(CuDeviceArray((2,1), CUDAnative.DevicePtr(ptr)), a, b)
     @test Mem.download(Int, out_buf, 2) == (_a .+ 1)[1:2]
 end
 
@@ -62,7 +66,9 @@ end
     function gpu(input)
         output = Mem.alloc(Int, 2)
 
-        @cuda threads=2 kernel(input, convert(Ptr{eltype(input)}, output.ptr), 99)
+        ptr = Base.unsafe_convert(CuPtr{eltype(input)}, output)
+
+        @cuda threads=2 kernel(input, ptr, 99)
 
         return Mem.download(Int, output, 2)
     end