Add edge-invalidation tests and implementation (#52)

In Julia 1.12, method insertion/deletion invalidations are logged to a
separate stream from edge invalidations. Our previous tests didn't cover
edge invalidations, and so failed to "notice" the separation of the
streams. This adds tests for edge invalidations and modifies the
implementation of `@recompile_invalidations` to cover them.

Author: timholy

src/invalidations.jl

@@ -13,19 +13,21 @@ macro recompile_invalidations(expr)
 end
 
 function recompile_invalidations(__module__::Module, @nospecialize expr)
-    list = ccall(:jl_debug_method_invalidation, Any, (Cint,), 1)
+    listi = ccall(:jl_debug_method_invalidation, Any, (Cint,), 1)
+    liste = Base.StaticData.debug_method_invalidation(true)
     try
         Core.eval(__module__, expr)
     finally
         ccall(:jl_debug_method_invalidation, Any, (Cint,), 0)
+        Base.StaticData.debug_method_invalidation(false)
     end
     if ccall(:jl_generating_output, Cint, ()) == 1
-        foreach(precompile_mi, invalidation_leaves(list))
+        foreach(precompile_mi, invalidation_leaves(listi, liste))
     end
     nothing
 end
 
-function invalidation_leaves(invlist)
+function invalidation_leaves(listi, liste)
     umis = Set{Core.MethodInstance}()
     # `queued` is a queue of length 0 or 1 of invalidated MethodInstances.
     # We wait to read the `depth` to find out if it's a leaf.
@@ -37,18 +39,19 @@ function invalidation_leaves(invlist)
         queued, depth = item, nextdepth
     end
 
-    i, ilast = firstindex(invlist), lastindex(invlist)
+    # Process method insertion/deletion events
+    i, ilast = firstindex(listi), lastindex(listi)
     while i <= ilast
-        item = invlist[i]
+        item = listi[i]
         if isa(item, Core.MethodInstance)
-            if i < lastindex(invlist)
-                nextitem = invlist[i+1]
+            if i < lastindex(listi)
+                nextitem = listi[i+1]
                 if nextitem == "invalidate_mt_cache"
                     cachequeued(nothing, 0)
                     i += 2
                     continue
                 end
-                if nextitem ∈ ("jl_method_table_disable", "jl_method_table_insert", "verify_methods")
+                if nextitem ∈ ("jl_method_table_disable", "jl_method_table_insert")
                     cachequeued(nothing, 0)
                     push!(umis, item)
                 end
@@ -65,5 +68,24 @@ function invalidation_leaves(invlist)
         end
         i += 1
     end
+
+    # Process edge-validation events
+    i, ilast = firstindex(liste), lastindex(liste)
+    while i <= ilast
+        tag = liste[i + 1]   # the tag is always second
+        if tag == "method_globalref"
+            push!(umis, Core.Compiler.get_ci_mi(liste[i + 2]))
+            i += 4
+        elseif tag == "insert_backedges_callee"
+            push!(umis, Core.Compiler.get_ci_mi(liste[i + 2]))
+            i += 4
+        elseif tag == "verify_methods"
+            push!(umis, Core.Compiler.get_ci_mi(liste[i]))
+            i += 3
+        else
+            error("Unknown tag found in invalidation list: ", tag)
+        end
+    end
+
     return umis
 end

test/runtests.jl

@@ -67,6 +67,11 @@ using Base: specializations
     @test success(run(`$(Base.julia_cmd()) --project=$(joinpath(@__DIR__, "PC_D")) -e $script 1`))
     Pkg.activate(projfile)
 
+    preffile = joinpath(@__DIR__, "PC_D", "LocalPreferences.toml")
+    if isfile(preffile)
+        rm(preffile)
+    end
+
     oldval = PrecompileTools.verbose[]
     PrecompileTools.verbose[] = true
     mktemp() do path, io
@@ -85,27 +90,28 @@ using Base: specializations
     # Mimic the format written to `_jl_debug_method_invalidation`
     # As a source of MethodInstances, `getproperty` has lots
     m = which(getproperty, (Any, Symbol))
-    mis = Core.MethodInstance[]
+    mis, cis = Core.MethodInstance[], Core.CodeInstance[]
     for mi in specializations(m)
-        length(mis) >= 10 && break
+        length(cis) >= 10 && break
         mi === nothing && continue
         push!(mis, mi)
+        isdefined(mi, :cache) && push!(cis, mi.cache)
     end
-    # These mimic the invalidation lists in SnoopCompile's `test/snoopr.jl`
+    # These mimic the format of the logs produced by `jl_debug_method_invalidation` (both variants)
     invs = Any[mis[1], 0, mis[2], 1, Tuple{}, m, "jl_method_table_insert"]
-    @test PrecompileTools.invalidation_leaves(invs) == Set([mis[2]])
+    @test PrecompileTools.invalidation_leaves(invs, []) == Set([mis[2]])
     invs = Any[mis[1], 0, mis[2], 1, mis[3], 1, Tuple{}, m, "jl_method_table_insert"]
-    @test PrecompileTools.invalidation_leaves(invs) == Set([mis[2], mis[3]])
+    @test PrecompileTools.invalidation_leaves(invs, []) == Set([mis[2], mis[3]])
     invs = Any[mis[1], 0, mis[2], 1, Tuple{}, mis[1], 1, mis[3], "jl_method_table_insert", m, "jl_method_table_insert"]
-    @test PrecompileTools.invalidation_leaves(invs) == Set(mis[1:3])
+    @test PrecompileTools.invalidation_leaves(invs, []) == Set(mis[1:3])
     invs = Any[mis[1], 1, mis[2], "jl_method_table_disable", m, "jl_method_table_disable"]
-    @test PrecompileTools.invalidation_leaves(invs) == Set([mis[1], mis[2]])
+    @test PrecompileTools.invalidation_leaves(invs, []) == Set([mis[1], mis[2]])
     invs = Any[mis[1], 1, mis[2], "jl_method_table_disable", mis[3], "jl_method_table_insert", m]
-    @test Set([mis[1], mis[2]]) ⊆ PrecompileTools.invalidation_leaves(invs)
+    @test Set([mis[1], mis[2]]) ⊆ PrecompileTools.invalidation_leaves(invs, [])
     invs = Any[mis[1], 1, mis[2], "jl_method_table_insert", mis[2], "invalidate_mt_cache", m, "jl_method_table_insert"]
-    @test PrecompileTools.invalidation_leaves(invs) == Set([mis[1], mis[2]])
-    invs = Any[Tuple{}, "insert_backedges_callee", 55, Any[m], mis[2], "verify_methods", 55]
-    @test PrecompileTools.invalidation_leaves(invs) == Set([mis[2]])
+    @test PrecompileTools.invalidation_leaves(invs, []) == Set([mis[1], mis[2]])
+    invs = Any[m, "method_globalref", cis[1], nothing, Tuple{}, "insert_backedges_callee", cis[2], Any[m], cis[3], "verify_methods", cis[4]]
+    @test PrecompileTools.invalidation_leaves([], invs) == Set(Core.Compiler.get_ci_mi.(cis[1:3]))
 
     # Coverage isn't on during package precompilation, so let's test a few things here
     PrecompileTools.precompile_mi(mis[1])
@@ -115,6 +121,7 @@ using Base: specializations
     mktempdir() do dir
         push!(LOAD_PATH, dir)
         cd(dir) do
+            # Method insertion invalidations
             for ((pkg1, pkg2, pkg3), recompile) in ((("RC_A", "RC_B", "RC_C"), false,),
                                                     (("RC_D", "RC_E", "RC_F"), true))
                 Pkg.generate(pkg1)
@@ -174,6 +181,73 @@ using Base: specializations
                 wc = Base.get_world_counter()
                 @test recompile ? mi.cache.max_world >= wc : mi.cache.max_world < wc
             end
+
+            # Edge-invalidation
+            for ((pkg1, pkg2, pkg3), recompile) in ((("RC_G", "RC_H", "RC_I"), false,),
+                                                    (("RC_J", "RC_K", "RC_L"), true))
+                Pkg.generate(pkg1)
+                open(joinpath(dir, pkg1, "src", pkg1*".jl"), "w") do io
+                    println(io, """
+                    module $pkg1
+                    nbits(::Int8) = 8
+                    nbits(::Int16) = 16
+                    end
+                    """)
+                end
+                Pkg.generate(pkg2)
+                Pkg.activate(joinpath(dir, pkg2))
+                Pkg.develop(PackageSpec(path=joinpath(dir, pkg1)))
+                open(joinpath(dir, pkg2, "src", pkg2*".jl"), "w") do io
+                    println(io, """
+                    module $pkg2
+                    using $pkg1
+                    call_nbits(c) = $pkg1.nbits(only(c))
+                    begin
+                        Base.Experimental.@force_compile
+                        call_nbits(Any[Int8(5)])
+                    end
+                    end
+                    """)
+                end
+                Pkg.generate(pkg3)
+                Pkg.activate(joinpath(dir, pkg3))
+                Pkg.develop(PackageSpec(path=joinpath(dir, pkg1)))
+                Pkg.develop(PackageSpec(path=joinpath(dir, pkg2)))
+                Pkg.develop(PackageSpec(path=dirname(@__DIR__)))   # depend on PrecompileTools
+                open(joinpath(dir, pkg3, "src", pkg3*".jl"), "w") do io
+                    if recompile
+                        println(io, """
+                        module $pkg3
+                        using PrecompileTools
+                        @recompile_invalidations begin
+                            using $pkg1
+                            $pkg1.nbits(::Int32) = 32  # This will cause an edge invalidation
+                            using $pkg2
+                        end
+                        end
+                        """)
+                    else
+                        println(io, """
+                        module $pkg3
+                        using PrecompileTools
+                        using $pkg1
+                        $pkg1.nbits(::Int32) = 32  # This will cause an edge invalidation
+                        using $pkg2
+                        end
+                        """)
+                    end
+                end
+
+                @eval using $(Symbol(pkg3))
+                mod3 = Base.@invokelatest getglobal(@__MODULE__, Symbol(pkg3))
+                mod2 = Base.@invokelatest getglobal(mod3, Symbol(pkg2))
+                mod1 = Base.@invokelatest getglobal(mod2, Symbol(pkg1))
+                m = only(methods(mod2.call_nbits))
+                mi = first(specializations(m))
+                wc = Base.get_world_counter()
+                @test recompile ? mi.cache.max_world >= wc : mi.cache.max_world < wc
+            end
+
         end
         pop!(LOAD_PATH)
     end