`--trace-compile` incorrectly reports only-inferred methods as being re-compiled

[topolarity]

There are times (such as when inlining) when Julia will create a CodeInstance that has no code associated with it.

For example:

using Base.Filesystem: contractuser
mi = methods(contractuser, (String,))[1].specializations::Base.MethodInstance

println("world range: ", (mi.cache.min_world, mi.cache.max_world))
println("invoke, specptr: ", (mi.cache.invoke, mi.cache.specptr))
println("next?: ", (isdefined(mi.cache, :next)))

println(contractuser("")) # trigger compilation

println("world range: ", (mi.cache.min_world, mi.cache.max_world))
println("invoke, specptr: ", (mi.cache.invoke, mi.cache.specptr))
println("next?: ", (isdefined(mi.cache, :next)))

This outputs:

world range: (0x0000000000003f84, 0xffffffffffffffff)
invoke, specptr: (Ptr{Nothing}(0x0000000000000000), Ptr{Nothing}(0x0000000000000000))
next?: false

world range: (0x0000000000003f84, 0xffffffffffffffff)
invoke, specptr: (Ptr{Nothing}(0x00007f6f10b09680), Ptr{Nothing}(0x00007f6f10b09590))
next?: false

which shows that contractuser(::String) was never invalidated (and in fact only has one CodeInstance). It just never had any code associated with it because it was only inferred and then inlined.

However if you run with --trace-compile=compile.log you'll see:

...
precompile(Tuple{typeof(Base.Filesystem.contractuser), String}) # recompile
...

You can see we reported precompile(Tuple{typeof(Base.Filesystem.contractuser), String}) # recompile

[topolarity]

This also affects the "% re-compilation" metric reported in @timed etc.

[vtjnash]

Yes, this is an implementation issue that "recompiled" is basically meaningless right now, since is_recompile never actually checks if it was compiled before (invoke is set)

[IanButterworth]

I tried to fix this with the following, but nothing is marked as a recompile. I'm guessing we need to look for codeinsts from previous world ages?

diff --git a/src/gf.c b/src/gf.c
index d220ad057176a..6f023d91cacf5 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -2863,7 +2863,9 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
 
     // Everything from here on is considered (user facing) compile time
     uint64_t start = jl_typeinf_timing_begin();
-    int is_recompile = jl_atomic_load_relaxed(&mi->cache) != NULL;
+
+    // Is a recompile if there is cached code, and it was compiled (not only inferred) before
+    int is_recompile = jl_atomic_load_relaxed(&mi->cache) != NULL && codeinst && jl_atomic_load_relaxed(&codeinst->invoke);
 
     // This codeinst hasn't been previously inferred do that now
     // jl_type_infer will internally do a cache lookup and jl_engine_reserve call

---

My test is

f(x::Int) = 1
applyf(container) = f(container[1])
Base.@trace_compile @eval applyf([100])
Base.@trace_compile @eval applyf(Any[100])
f(::Bool) = 2
Base.@trace_compile @eval applyf([true])
Base.@trace_compile @eval applyf(Any[true])

which should give this with the last line as a recompile

#=    4.6 ms =# precompile(Tuple{typeof(Main.applyf), Array{Int64, 1}})
#=    5.2 ms =# precompile(Tuple{typeof(Main.applyf), Array{Any, 1}})
#=    5.6 ms =# precompile(Tuple{typeof(Base.vect), Bool})
#=    2.7 ms =# precompile(Tuple{typeof(Main.applyf), Array{Bool, 1}})
#=    5.3 ms =# precompile(Tuple{typeof(Main.applyf), Array{Any, 1}}) # recompile

[vtjnash]

You want approximately jl_method_compiled there (without the world argument)