265-fix is only partial

[maleadt]

Not sure how I only ran into this now...

# used by CUDAnative to determine whether to recompile a kernel
julia> function method_age(f, tt)::UInt
           for m in Base._methods(f, tt, 1, typemax(UInt))
               if VERSION >= v"1.2.0-DEV.573"
                   return m[3].primary_world
               else
                   return m[3].min_world
               end
           end
           throw(MethodError(f, tt))
       end

# example kernel that uses a method
julia> foo() = bar()
julia> bar() = 1

julia> method_age(foo, Tuple{})
0x00000000000065d2

julia> method_age(bar, Tuple{})
0x00000000000065d3

# redefinition of called function
julia> bar() = 2

# its age changes...
julia> method_age(bar, Tuple{})
0x00000000000065d4

# but not the age of the caller
julia> method_age(foo, Tuple{})
0x00000000000065d2

@vtjnash what is the correct way to invalidate a compiled function based on whether it or any called function has changed?

[maleadt]

I think I managed to come up with something that embeds proper backedges, based on JuliaLang/julia#32237:

using Core.Compiler: retrieve_code_info, CodeInfo, MethodInstance, SSAValue, SlotNumber
using Base: _methods_by_ftype

# cached compilation and kernel execution
const compilecache = Dict{Int,Nothing}()
function cufunction(id, f, args...)
    get!(compilecache, id) do
        mi, ci = compilerequests[id]
        delete!(compilerequests, id)
        println("compile: $mi")
        nothing
    end
    f(args...)
end

# generate code to call cufunction from generator(self, f, args)
globalUnique = 0
const compilerequests = Dict()
function emit_driver_call(mi, nargs, sparams)
    ci = retrieve_code_info(mi)
    @assert isa(ci, CodeInfo)

    # generate a unique id to represent this compilation
    # NOTE: we don't embed the method and code info into the call to cufunction
    #       to prevent dynamic dispatch and significantly speed-up the fast path
    global globalUnique
    id = (globalUnique += 1)
    compilerequests[id] = (mi, ci)

    # empty the function
    new_ci = copy(ci)
    empty!(new_ci.code)
    empty!(new_ci.codelocs)
    empty!(new_ci.linetable)
    empty!(new_ci.ssaflags)

    # prepare the slots
    new_ci.slotnames = Symbol[Symbol("#self#"), :f, :args, new_ci.slotnames[nargs+1:end]...]
    new_ci.slotflags = UInt8[(0x00 for i = 1:4)..., new_ci.slotflags[nargs+1:end]...]
    f = SlotNumber(2)

    # prepare the arguments: insert one SSAValue for every argument statement
    append!(new_ci.code, [Expr(:call, getfield, SlotNumber(3), i) for i = 1:nargs])
    append!(new_ci.codelocs, [0 for i = 1:nargs])
    new_ci.ssavaluetypes += nargs
    args = [SSAValue(i) for i in 1:nargs]

    # call the compiler
    append!(new_ci.code, [Expr(:call, cufunction, id, f, args...),
                          Expr(:return, SSAValue(nargs+1))])
    append!(new_ci.codelocs, [0, 0])
    new_ci.ssavaluetypes += 2

    return new_ci
end

function generator(self, f, args)
    # get a hold of the code info of the kernel function
    tt = Tuple{f, args...}
    mthds = _methods_by_ftype(tt, -1, typemax(UInt))
    @assert length(mthds) == 1
    mtypes, msp, m = mthds[1]
    mi = ccall(:jl_specializations_get_linfo, Ref{MethodInstance}, (Any, Any, Any), m, mtypes, msp)
    @assert !mi.def.isva

    # call the CUDA compiler driver instead
    code_info = emit_driver_call(mi, length(args), msp)
    if isdefined(code_info, :edges)
        code_info.edges = MethodInstance[mi]
    end

    code_info
end

# manual @generated to be able to return a code info
@eval function compile_and_launch(f, args...)
    $(Expr(:meta, :generated_only))
    $(Expr(:meta,
            :generated,
            Expr(:new,
                Core.GeneratedFunctionStub,
                :generator,
                Any[:generator, :f, :args],
                Any[],
                @__LINE__,
                QuoteNode(Symbol(@__FILE__)),
                true)))
end

macro cuda(ex)
    @assert Meta.isexpr(ex, :call)
    f = ex.args[1]
    args = ex.args[2:end]
    quote
        compile_and_launch($f, $(args...))
    end
end

Works as expected:

julia> foo(i,j) = return bar()

julia> bar() = 1

julia> @cuda foo(1,2)
compile: MethodInstance for foo(::Int64, ::Int64)
1

julia> @cuda foo(1,2)
1

julia> bar() = 2

julia> @cuda foo(1,2)
compile: MethodInstance for foo(::Int64, ::Int64)
2

julia> @cuda foo(1,2)
2

And performs well:

julia> f() = @cuda foo(1,2)
f (generic function with 1 method)

julia> @code_warntype f()
Variables
  #self#::Core.Compiler.Const(f, false)

Body::Int64
1 ─ %1 = Main.compile_and_launch(Main.foo, 1, 2)::Core.Compiler.Const(2, false)
└──      return %1

julia> @code_llvm f()

;  @ REPL[16]:1 within `f'
define i64 @julia_f_17407() {
top:
  %0 = alloca [1 x i64], align 8
; ┌ @ REPL[10]:6 within `macro expansion'
; │┌ @ REPL[4]:2 within `cufunction'
    %1 = getelementptr inbounds [1 x i64], [1 x i64]* %0, i64 0, i64 0
    store i64 2, i64* %1, align 8
    %2 = addrspacecast [1 x i64]* %0 to [1 x i64] addrspace(11)*
    call void @"julia_get!_17295"([1 x i64] addrspace(11)* nocapture readonly %2, %jl_value_t addrspace(10)* addrspacecast (%jl_value_t* inttoptr (i64 139830185558112 to %jl_value_t*) to %jl_value_t addrspace(10)*), i64 2)
; └└
  ret i64 2
}

julia> using BenchmarkTools

julia> @benchmark f()
BenchmarkTools.Trial: 
  memory estimate:  0 bytes
  allocs estimate:  0
  --------------
  minimum time:     7.719 ns (0.00% GC)
  median time:      7.933 ns (0.00% GC)
  mean time:        8.275 ns (0.00% GC)
  maximum time:     30.675 ns (0.00% GC)
  --------------
  samples:          10000
  evals/sample:     999

[maleadt]

Actually no, that still just relies on the call to the function for invalidation. The edges field seems to do nothing here.