Merge pull request #18 from JuliaGPU/wsp/updates

Manual compiler rebase (was #17)

Author: jpsamaroo

.gitlab-ci.yml

@@ -53,14 +53,6 @@ test:source:llvm7:
   variables:
     CI_BUILD_ARGS: 'LLVM_VER=7.0.0 USE_BINARYBUILDER_LLVM=0'
 
-test:source:llvm8:
-  extends:
-    - .julia:source
-    - .test
-  tags:
-    - rocm
-  variables:
-    CI_BUILD_ARGS: 'LLVM_VER=8.0.0 USE_BINARYBUILDER_LLVM=0'
 
 test:source:llvm9:
   extends:
@@ -70,4 +62,3 @@ test:source:llvm9:
     - rocm
   variables:
     CI_BUILD_ARGS: 'LLVM_VER=9.0.0rc6 USE_BINARYBUILDER_LLVM=0'
-

Project.toml

@@ -1,18 +1,25 @@
 name = "AMDGPUnative"
 uuid = "12f4821f-d7ee-5ba6-b76b-566925c5fcc5"
-version = "0.1.0"
-
-[compat]
-julia = "1"
-HSARuntime = "0.2.5"
+version = "0.1.1"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
 BinaryProvider = "b99e7846-7c00-51b0-8f62-c81ae34c0232"
+DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 HSARuntime = "2c364e2c-59fb-59c3-96f3-194112e690e0"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 LLVM = "929cbde3-209d-540e-8aea-75f648917ca0"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
+
+[compat]
+Adapt = "0.4, 1.0"
+BinaryProvider = "0.5"
+DataStructures = "0.15, 0.16, 0.17"
+HSARuntime = "0.2.6"
+LLVM = "1.3"
+TimerOutputs = "0.5"
+julia = "1"
 
 [extras]
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"

README.md

@@ -21,7 +21,7 @@ Acknowledgment
 AMDGPUnative would not have been possible without the work by Tim Besard on [CUDAnative.jl](https://github.com/JuliaGPU/CUDAnative.jl)
 and [LLVM.jl](https://github.com/maleadt/LLVM.jl). 
 
-
+In revision to: commit 53966d812d63c7cbea0de114ebee4033c7ddad0d of CUDAnative.jl 
 License
 -------
 

src/AMDGPUnative.jl

@@ -4,29 +4,32 @@ using LLVM, LLVM.Interop
 using InteractiveUtils
 using HSARuntime
 using Adapt
+using TimerOutputs
+using DataStructures
 using Libdl
 
 const configured = HSARuntime.configured
 
-# where the ROCm-Device-Libs bitcode goes
+# ROCm-Device-Libs bitcode path
 include(joinpath(@__DIR__, "..", "deps", "deps.jl"))
 const device_libs_path = joinpath(@__DIR__, "..", "deps", "usr", "lib")
 
-# needs to be loaded _before_ the compiler infrastructure, because of generated functions
+# Device sources must load _before_ the compiler infrastructure
+# because of generated functions.
 include(joinpath("device", "tools.jl"))
 include(joinpath("device", "pointer.jl"))
 include(joinpath("device", "array.jl"))
-include(joinpath("device", "gcn_intrinsics.jl"))
-include(joinpath("device", "runtime_intrinsics.jl"))
+include(joinpath("device", "gcn.jl"))
+include(joinpath("device", "runtime.jl"))
 
 include("execution_utils.jl")
 include("compiler.jl")
 include("execution.jl")
-
 include("reflection.jl")
 
 function __init__()
     check_deps()
+    __init_compiler__()
 end
 
 end # module

src/compiler.jl

@@ -1,5 +1,13 @@
 # JIT compilation of Julia code to GCN
 
+const to = Ref{TimerOutput}()
+
+function timings!(new=TimerOutput())
+  global to
+  to[] = new
+  return
+end
+
 include(joinpath("compiler", "common.jl"))
 include(joinpath("compiler", "irgen.jl"))
 include(joinpath("compiler", "optim.jl"))
@@ -10,6 +18,5 @@ include(joinpath("compiler", "debug.jl"))
 include(joinpath("compiler", "driver.jl"))
 
 function __init_compiler__()
-    # enable generation of FMA instructions to mimic behavior of nvcc
-    #LLVM.clopts("--nvptx-fma-level=1")
+    timings!()
 end

src/compiler/common.jl

@@ -1,8 +1,8 @@
 # common functionality
 
-struct CompilerContext
+struct CompilerJob
     # core invocation
-    f::Core.Function
+    f::Base.Callable
     tt::DataType
     agent::HSAAgent
     kernel::Bool
@@ -12,63 +12,61 @@ struct CompilerContext
     maxthreads::Union{Nothing,ROCDim}
     blocks_per_sm::Union{Nothing,Integer}
     maxregs::Union{Nothing,Integer}
+    name::Union{Nothing,String}
 
-    CompilerContext(f, tt, agent, kernel;
-                    minthreads=nothing, maxthreads=nothing,
-                    blocks_per_sm=nothing, maxregs=nothing) =
-        new(f, tt, agent, kernel, minthreads, maxthreads, blocks_per_sm, maxregs)
+    CompilerJob(f, tt, agent, kernel; name=nothing,
+                minthreads=nothing, maxthreads=nothing,
+                blocks_per_sm=nothing, maxregs=nothing) =
+        new(f, tt, agent, kernel, minthreads, maxthreads, blocks_per_sm,
+            maxregs, name)
 end
 
 # global context reference
-# FIXME: thread through `ctx` everywhere (deadlocks the Julia compiler when doing so with
+# FIXME: thread through `job` everywhere (deadlocks the Julia compiler when doing so with
 #        the LLVM passes in AMDGPUnative)
-global_ctx = nothing
+current_job = nothing
 
-
-function signature(ctx::CompilerContext)
-    fn = typeof(ctx.f).name.mt.name
-    args = join(ctx.tt.parameters, ", ")
-    return "$fn($(join(ctx.tt.parameters, ", ")))"
+function signature(job::CompilerJob)
+    fn = something(job.name, nameof(job.f))
+    args = join(job.tt.parameters, ", ")
+    return "$fn($(join(job.tt.parameters, ", ")))"
 end
 
-
 struct KernelError <: Exception
-    ctx::CompilerContext
+    job::CompilerJob
     message::String
     help::Union{Nothing,String}
     bt::StackTraces.StackTrace
 
-    KernelError(ctx::CompilerContext, message::String, help=nothing;
+    KernelError(job::CompilerJob, message::String, help=nothing;
                 bt=StackTraces.StackTrace()) =
-        new(ctx, message, help, bt)
+        new(job, message, help, bt)
 end
 
 function Base.showerror(io::IO, err::KernelError)
-    println(io, "GPU compilation of $(signature(err.ctx)) failed")
+    println(io, "GPU compilation of $(signature(err.job)) failed")
     println(io, "KernelError: $(err.message)")
     println(io)
     println(io, something(err.help, "Try inspecting the generated code with any of the @device_code_... macros."))
     Base.show_backtrace(io, err.bt)
 end
 
-
 struct InternalCompilerError <: Exception
-    ctx::CompilerContext
+    job::CompilerJob
     message::String
     meta::Dict
-    InternalCompilerError(ctx, message; kwargs...) = new(ctx, message, kwargs)
+    InternalCompilerError(job, message; kwargs...) = new(job, message, kwargs)
 end
 
 function Base.showerror(io::IO, err::InternalCompilerError)
     println(io, """AMDGPUnative.jl encountered an unexpected internal compiler error.
                    Please file an issue attaching the following information, including the backtrace,
                    as well as a reproducible example (if possible).""")
-
     println(io, "\nInternalCompilerError: $(err.message)")
 
     println(io, "\nCompiler invocation:")
-    for field in fieldnames(CompilerContext)
-        println(io, " - $field = $(repr(getfield(err.ctx, field)))")
+    for field in fieldnames(CompilerJob)
+        println(io, " - $field = $(repr(getfield(err.job, field)))")
     end
 
     if !isempty(err.meta)
@@ -78,23 +76,25 @@ function Base.showerror(io::IO, err::InternalCompilerError)
         end
     end
 
-    println(io, "\nInstalled packages:")
-    for (pkg,ver) in Pkg.installed()
-        println(io, " - $pkg = $ver")
+    let Pkg = Base.require(Base.PkgId(Base.UUID((0x44cfe95a1eb252ea, 0xb672e2afdf69b78f)), "Pkg"))
+        println(io, "\nInstalled packages:")
+        for (pkg,ver) in Pkg.installed()
+            println(io, " - $pkg = $(repr(ver))")
+        end
     end
 
     println(io)
     versioninfo(io)
 end
 
-macro compiler_assert(ex, ctx, kwargs...)
+macro compiler_assert(ex, job, kwargs...)
     msg = "$ex, at $(__source__.file):$(__source__.line)"
     return :($(esc(ex)) ? $(nothing)
-                        : throw(InternalCompilerError($(esc(ctx)), $msg;
+                        : throw(InternalCompilerError($(esc(job)), $msg;
                                                       $(map(esc, kwargs)...)))
             )
 end
 
-
 # maintain our own "global unique" suffix for disambiguating kernels
 globalUnique = 0
+

src/compiler/debug.jl

@@ -1,10 +1,10 @@
 # tools for dealing with compiler debug information
 
-# generate a pseudo-backtrace from LLVM IR instruction debug information
-#
-# this works by looking up the debug information of the instruction, and inspecting the call
-# sites of the containing function. if there's only one, repeat the process from that call.
-# finally, the debug information is converted to a Julia stack trace.
+# `backtrace()` generates a pseudo-backtrace from LLVM IR instruction debug
+# information. This works by looking up the debug information of the
+# instruction, and inspecting the call sites of the containing function.
+# If there's only one, repeat the process from that call. Finally, the debug
+# information is converted to a Julia stack trace.
 function backtrace(inst::LLVM.Instruction, bt = StackTraces.StackFrame[])
     name = Ref{Cstring}()
     filename = Ref{Cstring}()
@@ -13,7 +13,8 @@ function backtrace(inst::LLVM.Instruction, bt = StackTraces.StackFrame[])
 
     # look up the debug information from the current instruction
     depth = 0
-    while LLVM.API.LLVMGetSourceLocation(LLVM.ref(inst), depth, name, filename, line, col) == 1
+    while LLVM.API.LLVMGetSourceLocation(LLVM.ref(inst), depth, name, filename,
+                                         line, col) == 1
         frame = StackTraces.StackFrame(replace(unsafe_string(name[]), r";$"=>""),
                                        unsafe_string(filename[]), line[])
         push!(bt, frame)
@@ -46,3 +47,4 @@ function backtrace(inst::LLVM.Instruction, bt = StackTraces.StackFrame[])
 
     return bt
 end
+