Switch to SPIR-V address spaces.

Author: maleadt

lib/intrinsics/src/atomic.jl

@@ -8,7 +8,7 @@
 const atomic_integer_types = [UInt32, Int32]
 # TODO: 64-bit atomics with ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS
 # TODO: additional floating-point atomics with ZE_extension_float_atomics
-const atomic_memory_types = [AS.Local, AS.Global]
+const atomic_memory_types = [AS.Workgroup, AS.CrossWorkgroup]
 
 
 # generically typed

lib/intrinsics/src/math.jl

@@ -94,8 +94,8 @@ for gentype in generic_types
     cosval = Ref{$gentype}()
     sinval = GC.@preserve cosval begin
         ptr = Base.unsafe_convert(Ptr{$gentype}, cosval)
-        llvm_ptr = reinterpret(LLVMPtr{$gentype, AS.Private}, ptr)
-        @builtin_ccall("sincos", $gentype, ($gentype, LLVMPtr{$gentype, AS.Private}), x, llvm_ptr)
+        llvm_ptr = reinterpret(LLVMPtr{$gentype, AS.Function}, ptr)
+        @builtin_ccall("sincos", $gentype, ($gentype, LLVMPtr{$gentype, AS.Function}), x, llvm_ptr)
     end
     return sinval, cosval[]
 end

lib/intrinsics/src/memory.jl

@@ -5,15 +5,15 @@
     Context() do ctx
         # XXX: as long as LLVMPtr is emitted as i8*, it doesn't make sense to type the GV
         eltyp = convert(LLVMType, LLVM.Int8Type())
-        T_ptr = convert(LLVMType, LLVMPtr{T,AS.Local})
+        T_ptr = convert(LLVMType, LLVMPtr{T,AS.Workgroup})
 
         # create a function
         llvm_f, _ = create_function(T_ptr)
 
         # create the global variable
         mod = LLVM.parent(llvm_f)
         gv_typ = LLVM.ArrayType(eltyp, len * sizeof(T))
-        gv = GlobalVariable(mod, gv_typ, "local_memory", AS.Local)
+        gv = GlobalVariable(mod, gv_typ, "local_memory", AS.Workgroup)
         if len > 0
             linkage!(gv, LLVM.API.LLVMInternalLinkage)
             initializer!(gv, null(gv_typ))
@@ -33,6 +33,6 @@
             ret!(builder, untyped_ptr)
         end
 
-        call_function(llvm_f, LLVMPtr{T,AS.Local})
+        call_function(llvm_f, LLVMPtr{T,AS.Workgroup})
     end
 end

lib/intrinsics/src/pointer.jl

@@ -4,13 +4,16 @@ export AS
 
 module AS
 
-const Private    = 0
-const Global     = 1
-const Constant   = 2
-const Local      = 3
-const Generic    = 4
-const Input      = 5
-const Output     = 6
-const Count      = 7
+const Function          = 0
+const CrossWorkgroup    = 1
+const UniformConstant   = 2
+const Workgroup         = 3
+const Generic           = 4
+const DeviceOnlyINTEL   = 5 # XXX: should be CrossWorkgroup
+const HostOnlyINTEL     = 6 #      when USM is not supported
+const Input             = 7
+const Output            = 8
+const CodeSectionINTEL  = 9
+const Private           = 10
 
 end

lib/intrinsics/src/printf.jl

@@ -31,7 +31,7 @@ end
     Context() do ctx
         T_void = LLVM.VoidType()
         T_int32 = LLVM.Int32Type()
-        T_pint8 = LLVM.PointerType(LLVM.Int8Type(), AS.Constant)
+        T_pint8 = LLVM.PointerType(LLVM.Int8Type(), AS.UniformConstant)
 
         # create functions
         param_types = LLVMType[convert(LLVMType, typ) for typ in arg_types]
@@ -43,7 +43,7 @@ end
             entry = BasicBlock(llvm_f, "entry")
             position!(builder, entry)
 
-            str = globalstring_ptr!(builder, String(fmt); addrspace=AS.Constant)
+            str = globalstring_ptr!(builder, String(fmt); addrspace=AS.UniformConstant)
 
             # invoke printf and return
             printf_typ = LLVM.FunctionType(T_int32, [T_pint8]; vararg=true)

lib/intrinsics/src/utils.jl

@@ -34,22 +34,22 @@ macro builtin_ccall(name, ret, argtypes, args...)
             elt, as = T.parameters
 
             # mangle address space
-            ASstr = if as == AS.Global
+            ASstr = if as == AS.CrossWorkgroup
                 "CLglobal"
             #elseif as == AS.Global_device
             #    "CLdevice"
             #elseif as == AS.Global_host
             #    "CLhost"
-            elseif as == AS.Local
+            elseif as == AS.Workgroup
                 "CLlocal"
-            elseif as == AS.Constant
+            elseif as == AS.UniformConstant
                 "CLconstant"
-            elseif as == AS.Private
+            elseif as == AS.Function
                 "CLprivate"
             elseif as == AS.Generic
                 "CLgeneric"
             else
-                error("Unknown address space $AS")
+                error("Unknown address space $as")
             end
 
             # encode as vendor qualifier

lib/intrinsics/src/work_item.jl

@@ -21,9 +21,9 @@ for (julia_name, (spirv_name, offset)) in [
         export $julia_name
         @device_function $julia_name() =
             Base.llvmcall(
-                $("""$gvar_name = external addrspace(1) global i32
+                $("""$gvar_name = external addrspace($(AS.Input)) global i32
                      define i32 @entry() #0 {
-                         %val = load i32, i32 addrspace(1)* $gvar_name
+                         %val = load i32, i32 addrspace($(AS.Input))* $gvar_name
                          ret i32 %val
                      }
                      attributes #0 = { alwaysinline }
@@ -48,9 +48,9 @@ for (julia_name, (spirv_name, offset)) in [
         export $julia_name
         @device_function $julia_name(dimindx::Integer=1) =
             Base.llvmcall(
-                $("""$gvar_name = external addrspace(1) global <3 x i32>
+                $("""$gvar_name = external addrspace($(AS.Input)) global <3 x i32>
                      define i32 @entry(i32 %idx) #0 {
-                         %val = load <3 x i32>, <3 x i32> addrspace(1)* $gvar_name
+                         %val = load <3 x i32>, <3 x i32> addrspace($(AS.Input))* $gvar_name
                          %element = extractelement <3 x i32> %val, i32 %idx
                          ret i32 %element
                      }

src/array.jl

@@ -299,9 +299,10 @@ end
 
 ## interop with GPU arrays
 
-function Base.unsafe_convert(::Type{CLDeviceArray{T, N, AS.Global}}, a::CLArray{T, N}) where {T, N}
-    return CLDeviceArray{T, N, AS.Global}(
-        size(a), reinterpret(LLVMPtr{T, AS.Global}, pointer(a)),
+function Base.unsafe_convert(::Type{CLDeviceArray{T, N, AS.CrossWorkgroup}},
+                             a::CLArray{T, N}) where {T, N}
+    return CLDeviceArray{T, N, AS.CrossWorkgroup}(
+        size(a), reinterpret(LLVMPtr{T, AS.CrossWorkgroup}, pointer(a)),
         a.maxsize - a.offset * Base.elsize(a)
     )
 end

src/compiler/execution.jl

@@ -92,7 +92,7 @@ function Adapt.adapt_storage(to::KernelAdaptor, buf::cl.AbstractMemory)
 end
 function Adapt.adapt_storage(to::KernelAdaptor, arr::CLArray{T, N}) where {T, N}
     push!(to.indirect_memory, arr.data[].mem)
-    return Base.unsafe_convert(CLDeviceArray{T, N, AS.Global}, arr)
+    return Base.unsafe_convert(CLDeviceArray{T, N, AS.CrossWorkgroup}, arr)
 end
 
 # Base.RefValue isn't GPU compatible, so provide a compatible alternative

test/execution.jl

@@ -93,7 +93,7 @@ end
 
     @test OpenCL.return_type(identity, Tuple{Int}) === Int
     @test OpenCL.return_type(sin, Tuple{Float32}) === Float32
-    @test OpenCL.return_type(getindex, Tuple{CLDeviceArray{Float32,1,AS.Global},Int32}) === Float32
+    @test OpenCL.return_type(getindex, Tuple{CLDeviceArray{Float32,1,AS.CrossWorkgroup},Int32}) === Float32
     @test OpenCL.return_type(getindex, Tuple{Base.RefValue{Integer}}) === Integer
 end