Upgrade to GPUCompiler v0.19 (#113)

Author: tshort

.github/workflows/ci.yml

@@ -27,6 +27,10 @@ jobs:
           - x64
         group:
           - Core
+        include:
+          - arch: x86
+            version: '1'
+            os: ubuntu-latest   
     steps:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@latest

.gitignore

@@ -7,6 +7,10 @@
 /test/test.*
 Manifest.toml
 
+*.wasm
+*.dll
+*.o
+*.so
 test.o
 test.so
 test.bc

Project.toml

@@ -8,6 +8,7 @@ Clang_jll = "0ee61d77-7f21-5576-8119-9fcc46b10100"
 CodeInfoTools = "bc773b8a-8374-437a-b9f2-0e9785855863"
 GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+LLD_jll = "d55e3150-da41-5e91-b323-ecfd1eec6109"
 LLVM = "929cbde3-209d-540e-8aea-75f648917ca0"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
@@ -16,10 +17,10 @@ StaticTools = "86c06d3c-3f03-46de-9781-57580aa96d0a"
 
 [compat]
 CodeInfoTools = "0.3"
-GPUCompiler = "0.17"
-LLVM = "4.8, 5"
-StaticTools = "0.8"
+GPUCompiler = "0.19"
+LLVM = "5"
 MacroTools = "0.5"
+StaticTools = "0.8"
 julia = "1.8, 1.9"
 
 [extras]

src/StaticCompiler.jl

@@ -23,6 +23,7 @@ include("code_loading.jl")
 include("optimize.jl")
 include("quirks.jl")
 
+fix_name(s) = string("julia_", GPUCompiler.safe_name(s))
 
 """
     compile(f, types, path::String = tempname()) --> (compiled_f, path)
@@ -91,12 +92,13 @@ single method (the method determined by `types`).
 """
 function compile(f, _tt, path::String = tempname(); 
                  mixtape = NoContext(), 
-                 name = GPUCompiler.safe_name(repr(f)), 
+                 name = fix_name(repr(f)), 
                  filename = "obj",
                  strip_llvm = false,
                  strip_asm  = true,
                  opt_level=3,
                  kwargs...)
+
     tt = Base.to_tuple_type(_tt)
     isconcretetype(tt) || error("input type signature $_tt is not concrete")
 
@@ -114,7 +116,7 @@ end
 
 """
 ```julia
-generate_obj(f, tt, path::String = tempname(), name = GPUCompiler.safe_name(repr(f)), filenamebase::String="obj";
+generate_obj(f, tt, path::String = tempname(), name = fix_name(repr(f)), filenamebase::String="obj";
             \tmixtape = NoContext(),
             \tstrip_llvm = false,
             \tstrip_asm  = true,
@@ -148,7 +150,7 @@ shell> tree \$path
 0 directories, 1 file
 ```
 """
-function generate_obj(f, tt, external = true, path::String = tempname(), name = GPUCompiler.safe_name(repr(f)), filenamebase::String="obj";
+function generate_obj(f, tt, external = true, path::String = tempname(), name = fix_name(repr(f)), filenamebase::String="obj";
                         mixtape = NoContext(),
                         strip_llvm = false,
                         strip_asm  = true,
@@ -158,12 +160,9 @@ function generate_obj(f, tt, external = true, path::String = tempname(), name =
     mkpath(path)
     obj_path = joinpath(path, "$filenamebase.o")
     #Get LLVM to generated a module of code for us. We don't want GPUCompiler's optimization passes.
-    job = CompilerJob(NativeCompilerTarget(target...), 
-                      FunctionSpec(f, tt, false, name), 
-                      StaticCompilerParams(; 
-                                            opt = true, 
-                                            mixtape = mixtape,
-                                            optlevel = Base.JLOptions().opt_level))
+    params = StaticCompilerParams(opt = true, mixtape = mixtape, optlevel = Base.JLOptions().opt_level)
+    config = GPUCompiler.CompilerConfig(NativeCompilerTarget(target...), params, name = name, kernel = false)
+    job = GPUCompiler.CompilerJob(GPUCompiler.methodinstance(typeof(f), tt), config)
 
     mod, meta = GPUCompiler.JuliaContext() do context
         GPUCompiler.codegen(:llvm, job; strip=strip_llvm, only_entry=false, validate=false, optimize=false, ctx=context)
@@ -259,7 +258,7 @@ shell> ./hello
 Hello, world!
 ```
 """
-function compile_executable(f::Function, types=(), path::String="./", name=GPUCompiler.safe_name(repr(f));
+function compile_executable(f::Function, types=(), path::String="./", name=fix_name(repr(f));
         filename=name,
         cflags=``,
         kwargs...
@@ -315,7 +314,7 @@ julia> ccall(("julia_test", "test.dylib"), Float64, (Int64,), 100_000)
 5.2564961094956075
 ```
 """
-function compile_shlib(f::Function, types=(), path::String="./", name=GPUCompiler.safe_name(repr(f));
+function compile_shlib(f::Function, types=(), path::String="./", name=fix_name(repr(f));
         filename=name,
         cflags=``,
         kwargs...
@@ -396,19 +395,19 @@ julia> test(100_000)
 function generate_shlib_fptr(path::String, name, filename::String=name)
     lib_path = joinpath(abspath(path), "$filename.$(Libdl.dlext)")
     ptr = Libdl.dlopen(lib_path, Libdl.RTLD_LOCAL)
-    fptr = Libdl.dlsym(ptr, "julia_$name")
+    fptr = Libdl.dlsym(ptr, name)
     @assert fptr != C_NULL
     fptr
 end
 # As above, but also compile (maybe remove this method in the future?)
-function generate_shlib_fptr(f, tt, path::String=tempname(), name = GPUCompiler.safe_name(repr(f)), filename::String=name;
+function generate_shlib_fptr(f, tt, path::String=tempname(), name = fix_name(repr(f)), filename::String=name;
                             temp::Bool=true,
                             kwargs...)
 
     generate_shlib(f, tt, false, path, name; kwargs...)
     lib_path = joinpath(abspath(path), "$filename.$(Libdl.dlext)")
     ptr = Libdl.dlopen(lib_path, Libdl.RTLD_LOCAL)
-    fptr = Libdl.dlsym(ptr, "julia_$name")
+    fptr = Libdl.dlsym(ptr, name)
     @assert fptr != C_NULL
     if temp
         atexit(()->rm(path; recursive=true))
@@ -436,7 +435,7 @@ shell> ./hello
 Hello, world!
 ```
 """
-function generate_executable(f, tt, path=tempname(), name=GPUCompiler.safe_name(repr(f)), filename=string(name);
+function generate_executable(f, tt, path=tempname(), name=fix_name(repr(f)), filename=string(name);
         cflags=``,
         kwargs...
     )
@@ -456,18 +455,18 @@ function generate_executable(f, tt, path=tempname(), name=GPUCompiler.safe_name(
     # Compile!
     if Sys.isapple()
         # Apple no longer uses _start, so we can just specify a custom entry
-        entry = "_julia_$name"
+        entry = "_$name"
         run(`$cc -e $entry $cflags $obj_path -o $exec_path`)
     else
         # Write a minimal wrapper to avoid having to specify a custom entry
         wrapper_path = joinpath(path, "wrapper.c")
         f = open(wrapper_path, "w")
-        print(f, """int julia_$name(int argc, char** argv);
+        print(f, """int $name(int argc, char** argv);
         void* __stack_chk_guard = (void*) $(rand(UInt) >> 1);
 
         int main(int argc, char** argv)
         {
-            julia_$name(argc, argv);
+            $name(argc, argv);
             return 0;
         }""")
         close(f)
@@ -517,7 +516,7 @@ julia> ccall(("julia_test", "example/test.dylib"), Float64, (Int64,), 100_000)
 5.2564961094956075
 ```
 """
-function generate_shlib(f::Function, tt, external::Bool=true, path::String=tempname(), name=GPUCompiler.safe_name(repr(f)), filename=name;
+function generate_shlib(f::Function, tt, external::Bool=true, path::String=tempname(), name=fix_name(repr(f)), filename=name;
         cflags=``,
         kwargs...
     )
@@ -568,15 +567,15 @@ function native_code_typed(@nospecialize(func), @nospecialize(types); kwargs...)
 end
 
 # Return an LLVM module
-function native_llvm_module(f, tt, name = GPUCompiler.safe_name(repr(f)); kwargs...)
+function native_llvm_module(f, tt, name = fix_name(repr(f)); kwargs...)
     job, kwargs = native_job(f, tt, true; name, kwargs...)
     m, _ = GPUCompiler.JuliaContext() do context
         GPUCompiler.codegen(:llvm, job; strip=true, only_entry=false, validate=false, ctx=context)
     end
     return m
 end
 
-function native_code_native(@nospecialize(f), @nospecialize(tt), name = GPUCompiler.safe_name(repr(f)); kwargs...)
+function native_code_native(@nospecialize(f), @nospecialize(tt), name = fix_name(repr(f)); kwargs...)
     job, kwargs = native_job(f, tt, true; name, kwargs...)
     GPUCompiler.code_native(stdout, job; kwargs...)
 end
@@ -587,7 +586,7 @@ function native_llvm_module(funcs::Array; demangle = false, kwargs...)
     mod = native_llvm_module(f,tt, kwargs...)
     if length(funcs) > 1
         for func in funcs[2:end]
-            @show f,tt = func
+            f,tt = func
             tmod = native_llvm_module(f,tt, kwargs...)
             link!(mod,tmod)
         end
@@ -613,10 +612,10 @@ function generate_obj(funcs::Array, external, path::String = tempname(), filenam
                         strip_asm  = true,
                         opt_level=3,
                         kwargs...)
-    f,tt = funcs[1]
+    f, tt = funcs[1]
     mkpath(path)
     obj_path = joinpath(path, "$filenamebase.o")
-    fakejob, kwargs = native_job(f,tt, external, kwargs...)
+    fakejob, kwargs = native_job(f, tt, external, kwargs...)
     mod = native_llvm_module(funcs; demangle = demangle, kwargs...)
     obj, _ = GPUCompiler.emit_asm(fakejob, mod; strip=strip_asm, validate=false, format=LLVM.API.LLVMObjectFile)
     open(obj_path, "w") do io

src/code_loading.jl

@@ -50,7 +50,7 @@ function instantiate(p::LazyStaticCompiledFunction{rt, tt}) where {rt, tt}
     dg = LLVM.CreateDynamicLibrarySearchGeneratorForProcess(prefix)
     LLVM.add!(jd, dg)
     LLVM.add!(lljit, jd, ofile)
-    fptr = pointer(LLVM.lookup(lljit, "julia_" * p.name))
+    fptr = pointer(LLVM.lookup(lljit, p.name))
 
     StaticCompiledFunction{rt, tt}(p.f, fptr, lljit, p.reloc)
 end

src/interpreter.jl

@@ -3,7 +3,7 @@
 using Core.Compiler:
     AbstractInterpreter, InferenceResult, InferenceParams, InferenceState, MethodInstance, OptimizationParams, WorldView
 using GPUCompiler:
-    @safe_debug, AbstractCompilerParams, CodeCache, CompilerJob, FunctionSpec
+    @safe_debug, AbstractCompilerParams, CodeCache, CompilerJob, methodinstance
 using CodeInfoTools
 using CodeInfoTools: resolve
 

src/pointer_patching.jl

@@ -137,7 +137,7 @@ function get_pointers!(d, mod, inst)
                         _, gv = d[val]
                         LLVM.API.LLVMSetOperand(inst, i-1, gv)
                     else
-                        gv_name = GPUCompiler.safe_name(String(gensym(repr(Core.Typeof(val)))))
+                        gv_name = fix_name(String(gensym(repr(Core.Typeof(val)))))
                         gv = LLVM.GlobalVariable(mod, llvmeltype(arg), gv_name, LLVM.addrspace(llvmtype(arg)))
 
                         LLVM.extinit!(gv, true)
@@ -157,7 +157,7 @@ llvmeltype(x::LLVM.Value) = eltype(LLVM.llvmtype(x))
 
 function pointer_patching_diff(f, tt, path1=tempname(), path2=tempname(); show_reloc_table=false)
     tm = GPUCompiler.llvm_machine(NativeCompilerTarget())
-    job, kwargs = native_job(f, tt, false; name=GPUCompiler.safe_name(repr(f)))
+    job, kwargs = native_job(f, tt, false; name=fix_name(repr(f)))
     #Get LLVM to generated a module of code for us. We don't want GPUCompiler's optimization passes.
     mod, meta = GPUCompiler.JuliaContext() do context
         GPUCompiler.codegen(:llvm, job; strip=true, only_entry=false, validate=false, optimize=false, ctx=context)

src/target.jl

@@ -72,7 +72,7 @@ for target in (:NativeCompilerTarget, :ExternalNativeCompilerTarget)
             return tm
         end
 
-        GPUCompiler.runtime_slug(job::GPUCompiler.CompilerJob{$target}) = "native_$(job.target.cpu)-$(hash(job.target.features))"
+        GPUCompiler.runtime_slug(job::GPUCompiler.CompilerJob{$target}) = "native_$(job.config.target.cpu)-$(hash(job.config.target.features))"
 
         GPUCompiler.runtime_module(::GPUCompiler.CompilerJob{$target}) = StaticRuntime
         GPUCompiler.runtime_module(::GPUCompiler.CompilerJob{$target, StaticCompilerParams}) = StaticRuntime
@@ -82,10 +82,10 @@ for target in (:NativeCompilerTarget, :ExternalNativeCompilerTarget)
         GPUCompiler.can_throw(job::GPUCompiler.CompilerJob{$target}) = true
 
         GPUCompiler.get_interpreter(job::GPUCompiler.CompilerJob{$target, StaticCompilerParams}) =
-            StaticInterpreter(job.params.cache, GPUCompiler.method_table(job), job.source.world, 
+            StaticInterpreter(job.config.params.cache, GPUCompiler.method_table(job), job.world, 
                               GPUCompiler.inference_params(job), GPUCompiler.optimization_params(job), 
-                              job.params.mixtape)    
-        GPUCompiler.ci_cache(job::GPUCompiler.CompilerJob{$target, StaticCompilerParams}) = job.params.cache       
+                              job.config.params.mixtape)    
+        GPUCompiler.ci_cache(job::GPUCompiler.CompilerJob{$target, StaticCompilerParams}) = job.config.params.cache       
     end
 end
 
@@ -94,20 +94,22 @@ GPUCompiler.method_table(@nospecialize(job::GPUCompiler.CompilerJob{ExternalNati
 
 function native_job(@nospecialize(func::Function), @nospecialize(types::Type), external::Bool;
         mixtape = NoContext(),
-        name = GPUCompiler.safe_name(repr(func)),
+        name = fix_name(repr(func)),
         kernel::Bool = false,
         target = (),
         kwargs...
     )
-    source = GPUCompiler.FunctionSpec(func, types, kernel, name)
+    source = methodinstance(typeof(func), Base.to_tuple_type(types)) 
     target = external ? ExternalNativeCompilerTarget(;target...) : NativeCompilerTarget(;target...)
     params = StaticCompilerParams(mixtape = mixtape)
-    StaticCompiler.CompilerJob(target, source, params), kwargs
+    config = GPUCompiler.CompilerConfig(target, params, name = name, kernel = kernel)
+    StaticCompiler.CompilerJob(source, config), kwargs
 end
 
-function native_job(@nospecialize(func), @nospecialize(types), external; mixtape = NoContext(), kernel::Bool=false, name=GPUCompiler.safe_name(repr(func)), target = (), kwargs...)
-    source = GPUCompiler.FunctionSpec(func, Base.to_tuple_type(types), kernel, name)
+function native_job(@nospecialize(func), @nospecialize(types), external; mixtape = NoContext(), kernel::Bool=false, name=fix_name(repr(func)), target = (), kwargs...)
+    source = methodinstance(typeof(func), Base.to_tuple_type(types)) 
     target = external ? ExternalNativeCompilerTarget(;target...) : NativeCompilerTarget(;target...)
     params = StaticCompilerParams(mixtape = mixtape)
-    GPUCompiler.CompilerJob(target, source, params), kwargs
+    config = GPUCompiler.CompilerConfig(target, params, name = name, kernel = kernel)
+    GPUCompiler.CompilerJob(source, config), kwargs
 end

test/Project.toml

@@ -3,14 +3,14 @@ CodeInfoTools = "bc773b8a-8374-437a-b9f2-0e9785855863"
 Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 Formatting = "59287772-0a20-5a39-b81b-1366585eb4c0"
 GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55"
-Infiltrator = "5903a43b-9cc3-4c30-8d17-598619ec4e9b"
+LLD_jll = "d55e3150-da41-5e91-b323-ecfd1eec6109"
+LLVM = "929cbde3-209d-540e-8aea-75f648917ca0"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-LLVM = "929cbde3-209d-540e-8aea-75f648917ca0"
 LoopVectorization = "bdcacae8-1622-11e9-2a5c-532679323890"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 ManualMemory = "d125e4d3-2237-4719-b19c-fa641b8a4667"
 StaticTools = "86c06d3c-3f03-46de-9781-57580aa96d0a"
 StrideArraysCore = "7792a7ef-975c-4747-a70f-980b88e8d1da"
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

test/runtests.jl

@@ -9,6 +9,7 @@ using StaticTools
 using StrideArraysCore
 using CodeInfoTools
 using MacroTools
+using LLD_jll
 
 addprocs(1)
 @everywhere using StaticCompiler, StrideArraysCore