precompiling on V.11, V1.12, ... may loose half the precompilation work

[joa-quim]

See also this Forum post

Version 1.11 and ahead have very large regression on TTFP with GMT codes.

  | | |_| | | | (_| |  |  Version 1.10.10 (2025-06-27)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> using GMT

julia> @time @eval plot(rand(5,2))
  2.366811 seconds (7.95 M allocations: 538.542 MiB, 4.96% gc time, 99.88% compilation time: 23% of which was recompilation)


  | | |_| | | | (_| |  |  Version 1.13.0-DEV.1081 (2025-09-04)
 _/ |\__'_|_|_|\__'_|  |  Commit b9bcc03fc2 (1 day old master)
|__/                   |

julia> using GMT

julia> @time @eval plot(rand(5,2))
  6.600449 seconds (26.31 M allocations: 1.396 GiB, 3.36% gc time, 99.95% compilation time: 100% of which was recompilation)

Note that this plot(rand(5,2)) command is part of PrecompileTools workload. It's actually the last one.

If we look at the @trace_compile output we see that there a lot compilations (from Julia functions???, rand()???) and recompilations. Namely, the plot function is recompiled, even if it was the last precompiled command.

I also notice that since the Forum post (a few days ago) and now, a new function (GMT.read_data) is now being recompiled too (it wasn't before).

I added loose half the precompilation work to title because if I don't have in the precompilation workload than TTFP is ~12 sec, the double of current case, which is ~3 times longer than that of Julia 1.10

#= 6166.4 ms =# precompile(Tuple{typeof(GMT.plot), Array{Float64, 2}}) # recompile
#=    2.7 ms =# precompile(Tuple{typeof(GMT.read_data), Base.Dict{Symbol, Any}, String, String, GMT.GMTdataset{Float64, 2}, String, Bool}) # recompile
#=   57.4 ms =# precompile(Tuple{typeof(GMT.add_opt_cpt), Base.Dict{Symbol, Any}, String, Array{Symbol, 2}, Char, Int64, GMT.GMTdataset{Float64, 2}, Nothing, Bool, Bool, String, Bool}) # recompile
#=  518.4 ms =# precompile(Tuple{typeof(GMT.prep_and_call_finish_PS_module), Base.Dict{Symbol, Any}, Array{String, 1}, String, Bool, Bool, Bool, GMT.GMTdataset{Float64, 2}, Nothing, Nothing, Nothing}) # recompile

The full @trace_compile output

julia> @trace_compile @eval plot(rand(5,2))
#=    2.4 ms =# precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:limit, :keepempty), Tuple{Int64, Bool}}, typeof(Base.eachsplit), String, Char})
#=    2.6 ms =# precompile(Tuple{Base.var"##eachsplit#425", Int64, Bool, typeof(Base.eachsplit), String, Char})
#=    2.6 ms =# precompile(Tuple{Type{Base.SplitIterator{S, F} where F where S<:AbstractString}, String, Base.Fix{2, typeof(Base.isequal), Char}, Int64, Bool})
#=    4.4 ms =# precompile(Tuple{typeof(Base.getproperty), Base.SplitIterator{String, Base.Fix{2, typeof(Base.isequal), Char}}, Symbol})
#=    2.6 ms =# precompile(Tuple{typeof(Base.to_shape), Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}})
#=    4.3 ms =# precompile(Tuple{typeof(Base._array_for), Type{Symbol}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}})
#=   26.0 ms =# precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Symbol, 1}, Symbol, Base.Generator{Base.UnitRange{Int64}, Base.var"#_ntuple##0#_ntuple##1"{Base.Compiler.var"#tuple_tfunc##0#tuple_tfunc##1"{Array{Any, 1}}}}, Int64})
#=   71.5 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, Any, Nothing, NamedTuple{(:F, :D, :par), Tuple{String, String, Tuple{Symbol, String}}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=    2.9 ms =# precompile(Tuple{typeof(Base.convert), Type{UInt32}, Int32})
#=   82.4 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{String}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=    6.1 ms =# precompile(Tuple{Type{Int64}, Char})
#=    2.4 ms =# precompile(Tuple{typeof(Base.split_sign), Int64})
#=    2.9 ms =# precompile(Tuple{typeof(Base.indexed_iterate), Tuple{UInt64, Bool}, Int64})
#=    2.8 ms =# precompile(Tuple{typeof(Base.indexed_iterate), Tuple{UInt64, Bool}, Int64, Int64})
#=    1.7 ms =# precompile(Tuple{typeof(Base.abs), UInt64})
#=    1.7 ms =# precompile(Tuple{typeof(Base.unsigned), UInt64})
#=    1.9 ms =# precompile(Tuple{typeof(Base.top_set_bit), UInt64})
#=    2.7 ms =# precompile(Tuple{typeof(Base.Broadcast._getindex), Tuple{Int64}, Int64})
#=    2.4 ms =# precompile(Tuple{typeof(Base.Broadcast.broadcastable), Int64})
#=   73.1 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, V, Nothing, NT} where NT<:(NamedTuple{names, T} where T<:Tuple where names) where V}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=    3.2 ms =# precompile(Tuple{Type{UInt32}, Int32})
#=    2.9 ms =# precompile(Tuple{typeof(Base.to_indices), Array{String, 1}, Tuple{Base.UnitRange{Int64}}})
#=    2.2 ms =# precompile(Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Array{String, 1}}, Tuple{Base.UnitRange{Int64}}})
#=    2.0 ms =# precompile(Tuple{typeof(Base._maybe_reshape_parent), Array{String, 1}, Tuple{Bool}})
#=    1.7 ms =# precompile(Tuple{typeof(Base.reshape), Array{String, 1}, Base.Val{1}})
#=    2.7 ms =# precompile(Tuple{typeof(Base.unsafe_view), Array{String, 1}, Base.UnitRange{Int64}})
#=    2.8 ms =# precompile(Tuple{Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, Array{String, 1}, Tuple{Base.UnitRange{Int64}}})
#=    2.1 ms =# precompile(Tuple{typeof(Base.ensure_indexable), Tuple{Base.UnitRange{Int64}}})
#=    2.9 ms =# precompile(Tuple{Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, Base.IndexLinear, Array{String, 1}, Tuple{Base.UnitRange{Int64}}, Tuple{Bool}})
#=    2.0 ms =# precompile(Tuple{typeof(Base.compute_offset1), Array{String, 1}, Int64, Tuple{Base.UnitRange{Int64}}})
#=    2.6 ms =# precompile(Tuple{Type{Base.SubArray{String, 1, Array{String, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{String, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64})
#=    2.7 ms =# precompile(Tuple{typeof(Base.axes), Base.SubArray{String, 1, Array{String, 1}, Tuple{Base.UnitRange{Int64}}, true}})
#=    3.6 ms =# precompile(Tuple{typeof(Base.checkbounds), Base.SubArray{String, 1, Array{String, 1}, Tuple{Base.UnitRange{Int64}}, true}, Int64})
#=    4.6 ms =# precompile(Tuple{typeof(Base.getproperty), Base.SubArray{String, 1, Array{String, 1}, Tuple{Base.UnitRange{Int64}}, true}, Symbol})
#=    2.5 ms =# precompile(Tuple{typeof(Base._reindexlinear), Base.SubArray{String, 1, Array{String, 1}, Tuple{Base.UnitRange{Int64}}, true}, Int64})
#=   71.2 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, String, Nothing, NamedTuple{(:T, :f), Tuple{String, String}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=    9.3 ms =# precompile(Tuple{typeof(Base.Compiler.EscapeAnalysis.escape_builtin!), typeof(Core.finalizer), Base.Compiler.EscapeAnalysis.AnalysisState{Base.Compiler.GetNativeEscapeCache{Base.Compiler.WorldView{Base.Compiler.InternalCodeCache}}, Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}, Int64, Array{Any, 1}})
#=    2.7 ms =# precompile(Tuple{typeof(Base.:(>)), Int64})
#=    3.4 ms =# precompile(Tuple{typeof(Base._all), Base.Fix{2, typeof(Base.:(>)), Int64}, Tuple{Int64, Int64}, Base.Colon})
#=    2.1 ms =# precompile(Tuple{Base.Fix{2, typeof(Base.:(>)), Int64}, Int64})
#=    2.7 ms =# precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Int64, Base.UnitRange{Int64}})
#=    1.8 ms =# precompile(Tuple{typeof(Base.Broadcast.materialize), Base.UnitRange{Int64}})
#=    3.1 ms =# precompile(Tuple{typeof(Base.:(var"==")), Function, Function})
#=   83.2 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, String, Nothing, NamedTuple{(:J,), Tuple{String}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=   73.5 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, T, Nothing, A} where A<:(NamedTuple{(:R, :J), var"#s185"} where var"#s185"<:Tuple{Union{Array{Any, 1}, Array{Float64, 1}}, String}) where T}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=    4.9 ms =# precompile(Tuple{typeof(Base._array_for), Type{Tuple{String, typeof(GMT.arg2str), Int64}}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}}) # recompile
#=   16.6 ms =# precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Tuple{String, typeof(GMT.arg2str), Int64}, 1}, Tuple{String, typeof(GMT.arg2str), Int64}, Base.Generator{Base.UnitRange{Int64}, Base.var"#_ntuple##0#_ntuple##1"{Base.Compiler.var"#tuple_tfunc##0#tuple_tfunc##1"{Array{Any, 1}}}}, Int64})
#=   34.6 ms =# precompile(Tuple{typeof(Base.setindex_widen_up_to), Array{Tuple{String, typeof(GMT.arg2str), Int64}, 1}, Tuple{String, typeof(GMT.arg2str)}, Int64})
#=   10.9 ms =# precompile(Tuple{typeof(Base.collect_to!), Array{Tuple{String, typeof(GMT.arg2str), Vararg{Int64}}, 1}, Base.Generator{Base.UnitRange{Int64}, Base.var"#_ntuple##0#_ntuple##1"{Base.Compiler.var"#tuple_tfunc##0#tuple_tfunc##1"{Array{Any, 1}}}}, Int64, Int64})
#=   21.8 ms =# precompile(Tuple{typeof(Base.setindex_widen_up_to), Array{Tuple{String, typeof(GMT.arg2str), Vararg{Int64}}, 1}, String, Int64})
#=    3.2 ms =# precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:W, :A, :Vd), Tuple{Float64, String, Int64}}, Type{NamedTuple{(:clip,), T} where T<:Tuple}})
#=    3.2 ms =# precompile(Tuple{typeof(Base._new_NamedTuple), Type{NamedTuple{(:W, :A, :Vd), Tuple{Float64, String, Int64}}}, Tuple{Float64, String, Int64}})
#=    3.4 ms =# precompile(Tuple{typeof(Base.pairs), NamedTuple{(:W, :A, :Vd), Tuple{Float64, String, Int64}}})
#=    3.5 ms =# precompile(Tuple{Type{Base.Pairs{Symbol, V, I, A} where A where I where V}, NamedTuple{(:W, :A, :Vd), Tuple{Float64, String, Int64}}, Nothing})
#=   71.5 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, Any, Nothing, NamedTuple{(:W, :A, :Vd), Tuple{Float64, String, Int64}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=   67.0 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, String, Nothing, NamedTuple{(:f, :s), Tuple{String, String}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=   74.6 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, Any, Nothing, NamedTuple{(:pos, :B, :Vd), Tuple{NamedTuple{(:anchor,), Tuple{String}}, String, Int64}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=   77.0 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, Int64, Nothing, NamedTuple{(:Vd,), Tuple{Int64}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=   72.8 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, String, Nothing, NamedTuple{(:R,), Tuple{String}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=    2.6 ms =# precompile(Tuple{typeof(Base.:(+)), Vararg{Int64, 4}})
#=   69.5 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, Bool, Nothing, NamedTuple{(:gdataset,), Tuple{Bool}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=   73.1 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, NTuple{4, Float64}, Nothing, NamedTuple{(:R,), Tuple{NTuple{4, Float64}}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=   67.8 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, Any, Nothing, NamedTuple{(:J, :C, :F), Tuple{String, Bool, Bool}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#=   67.3 ms =# precompile(Tuple{Base.Compiler.var"#inferiterate_2arg#abstract_iteration##1"{Base.Compiler.InferenceLattice{Base.Compiler.ConditionalsLattice{Base.Compiler.PartialsLattice{Base.Compiler.ConstsLattice}}}, Array{Any, 1}, Array{Base.Compiler.CallMeta, 1}, Type{Base.Pairs{Symbol, Any, Nothing, NamedTuple{(:Q, :o), Tuple{Bool, String}}}}, Base.Compiler.Future{Base.Compiler.AbstractIterationResult}}, Base.Compiler.NativeInterpreter, Base.Compiler.InferenceState})
#= 6166.4 ms =# precompile(Tuple{typeof(GMT.plot), Array{Float64, 2}}) # recompile
#=    2.7 ms =# precompile(Tuple{typeof(GMT.read_data), Base.Dict{Symbol, Any}, String, String, GMT.GMTdataset{Float64, 2}, String, Bool}) # recompile
#=   57.4 ms =# precompile(Tuple{typeof(GMT.add_opt_cpt), Base.Dict{Symbol, Any}, String, Array{Symbol, 2}, Char, Int64, GMT.GMTdataset{Float64, 2}, Nothing, Bool, Bool, String, Bool}) # recompile
#=  518.4 ms =# precompile(Tuple{typeof(GMT.prep_and_call_finish_PS_module), Base.Dict{Symbol, Any}, Array{String, 1}, String, Bool, Bool, Bool, GMT.GMTdataset{Float64, 2}, Nothing, Nothing, Nothing}) # recompile

[IanButterworth]

You seem to be hitting a big recompilation due to an invalidation. https://github.com/timholy/SnoopCompile.jl is the best tool to look into this further.

Probably worth closing as an issue with Base until it can be shown to be a Base issue.

[joa-quim]

Very quick closing this issue (which I have no permission to reopen)

I said it in Forum post. SnoopCompile shows only 6 invalidations, and 5 of them are in SparseArrays

Yes, there must be many invalidations. But where?

julia> using SnoopCompileCore

julia> invs = @snoop_invalidations using GMT;

julia> using SnoopCompile, AbstractTrees

julia> trees = invalidation_trees(invs)
6-element Vector{SnoopCompile.MethodInvalidations}:
 inserting map!(f::Tf, C::SparseArrays.AbstractSparseMatrixCSC, A::Union{LinearAlgebra.Bidiagonal, LinearAlgebra.Diagonal, LinearAlgebra.LowerTriangular, LinearAlgebra.SymTridiagonal, LinearAlgebra.Tridiagonal, LinearAlgebra.UnitLowerTriangular, LinearAlgebra.UnitUpperTriangular, LinearAlgebra.UpperTriangular, SparseArrays.FixedSparseCSC, SparseArrays.SparseMatrixCSC}, Bs::Vararg{Union{LinearAlgebra.Bidiagonal, LinearAlgebra.Diagonal, LinearAlgebra.LowerTriangular, LinearAlgebra.SymTridiagonal, LinearAlgebra.Tridiagonal, LinearAlgebra.UnitLowerTriangular, LinearAlgebra.UnitUpperTriangular, LinearAlgebra.UpperTriangular, SparseArrays.FixedSparseCSC, SparseArrays.SparseMatrixCSC}, N}) where {Tf, N} @ SparseArrays.HigherOrderFns C:\programs\Julia-1.10\share\julia\stdlib\v1.10\SparseArrays\src\higherorderfns.jl:1188 invalidated:
   mt_backedges: 1: signature Tuple{typeof(map!), typeof(JuliaInterpreter._Typeof), Any, AbstractArray} triggered MethodInstance for Base.mapany(::typeof(JuliaInterpreter._Typeof), ::AbstractArray) (0 children)
   1 mt_cache

 inserting eachindex(x::SparseArrays.ReadOnly) @ SparseArrays C:\programs\Julia-1.10\share\julia\stdlib\v1.10\SparseArrays\src\readonly.jl:17 invalidated:
   backedges: 1: superseding eachindex(A::AbstractVector) @ Base abstractarray.jl:321 with MethodInstance for eachindex(::AbstractVector) (2 children)

 inserting resize!(x::SparseArrays.ReadOnly, l) @ SparseArrays C:\programs\Julia-1.10\share\julia\stdlib\v1.10\SparseArrays\src\readonly.jl:33 invalidated:
   mt_backedges: 1: signature Tuple{typeof(resize!), Any, Int64} triggered MethodInstance for Base.remove_linenums!(::Core.CodeInfo) (7 children)

 inserting names(D::Vector{<:GMTdataset}) @ GMT C:\Users\j\.julia\dev\GMT\src\gmt_main.jl:1717 invalidated:
   mt_backedges: 1: signature Tuple{typeof(names), Any} triggered MethodInstance for iterate(::Base.Generator{Vector{Any}, typeof(names)}) (4 children)
                 2: signature Tuple{typeof(names), Any} triggered MethodInstance for iterate(::Base.Generator{Vector{Any}, typeof(names)}, ::Int64) (4 children)

 inserting _any(f, A::SparseArrays.AbstractSparseMatrixCSC, ::Colon) @ SparseArrays C:\programs\Julia-1.10\share\julia\stdlib\v1.10\SparseArrays\src\sparsematrix.jl:2377 invalidated:
   backedges:  1: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::ComposedFunction{ComposedFunction{ComposedFunction{O, I}, typeof(adjoint)}, typeof(transpose)} where {O, I}, ::Any, ::Colon) (1 children)
               2: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::ComposedFunction{ComposedFunction{O, I}, typeof(adjoint)} where {O, I}, ::Any, ::Colon) (1 children)
               3: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::ComposedFunction{ComposedFunction{typeof(ismissing), typeof(adjoint)}, typeof(transpose)}, ::Any, ::Colon) (1 children)
               4: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::ComposedFunction{typeof(ismissing), typeof(adjoint)}, ::Any, ::Colon) (1 children)
               5: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::ComposedFunction{ComposedFunction{typeof(ismissing), typeof(transpose)}, typeof(adjoint)}, ::Any, ::Colon) (1 children)
               6: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::ComposedFunction{ComposedFunction{ComposedFunction{O, I}, typeof(transpose)}, typeof(adjoint)} where {O, I}, ::Any, ::Colon) (1 children)
               7: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::ComposedFunction{typeof(ismissing), typeof(transpose)}, ::Any, ::Colon) (1 children)
               8: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::typeof(ismissing), ::AbstractArray, ::Colon) (1 children)
               9: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::typeof(ismissing), ::Any, ::Colon) (1 children)
              10: superseding _any(f, itr, ::Colon) @ Base reduce.jl:1217 with MethodInstance for Base._any(::ComposedFunction{ComposedFunction{O, I}, typeof(transpose)} where {O, I}, ::Any, ::Colon) (26 children)

 inserting _all(f, A::SparseArrays.AbstractSparseMatrixCSC, ::Colon) @ SparseArrays C:\programs\Julia-1.10\share\julia\stdlib\v1.10\SparseArrays\src\sparsematrix.jl:2379 invalidated:
   backedges:  1: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::ComposedFunction{ComposedFunction{ComposedFunction{O, I}, typeof(adjoint)}, typeof(transpose)} where {O, I}, ::Any, ::Colon) (1 children)
               2: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::ComposedFunction{ComposedFunction{O, I}, typeof(adjoint)} where {O, I}, ::Any, ::Colon) (1 children)
               3: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::ComposedFunction{ComposedFunction{Base.var"#949#950", typeof(adjoint)}, typeof(transpose)}, ::Any, ::Colon) (1 children)
               4: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::ComposedFunction{Base.var"#949#950", typeof(adjoint)}, ::Any, ::Colon) (1 children)
               5: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::ComposedFunction{ComposedFunction{Base.var"#949#950", typeof(transpose)}, typeof(adjoint)}, ::Any, ::Colon) (1 children)
               6: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::ComposedFunction{ComposedFunction{ComposedFunction{O, I}, typeof(transpose)}, typeof(adjoint)} where {O, I}, ::Any, ::Colon) (1 children)
               7: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::ComposedFunction{Base.var"#949#950", typeof(transpose)}, ::Any, ::Colon) (1 children)
               8: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::Base.var"#949#950", ::AbstractArray, ::Colon) (1 children)
               9: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::Base.var"#949#950", ::Any, ::Colon) (1 children)
              10: superseding _all(f, itr, ::Colon) @ Base reduce.jl:1285 with MethodInstance for Base._all(::ComposedFunction{ComposedFunction{O, I}, typeof(transpose)} where {O, I}, ::Any, ::Colon) (26 children)

[IanButterworth]

Fair. I didn't click on the links.

[timholy]

Just to check, you used SnoopCompile 3.2? It was released only 3 days ago, and earlier versions do not properly support Julia 1.12+. Though 1.12-rc2 is recommended, which will very shortly be available.

[timholy]

Here's what I get on julia +nightly with SnoopCompile 3.2/SnoopCompileCore 3.1:

julia> trees = invalidation_trees(invs)
49-element Vector{SnoopCompile.MethodInvalidations}:
 inserting similar(S::SparseArrays.AbstractCompressedVector{<:Any, Ti}, ::Type{TvNew}) where {Ti, TvNew} @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/sparsevector.jl:218 invalidated:
   mt_backedges: 1: signature Tuple{typeof(similar), AbstractVector, Type} triggered MethodInstance for Base._similar_or_copy(::AbstractVector, ::Type{T}) where T (0 children)

 inserting iterate(x::SparseArrays.ReadOnly, y...) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/readonly.jl:20 invalidated:
   mt_backedges: 1: signature Tuple{typeof(iterate), AbstractVector{Regex}} triggered MethodInstance for PrettyTables._apply_alignment_anchor_regex!(::PrettyTables.ProcessedTable, ::Matrix{Vector{String}}, ::Vector{Int64}, ::Symbol, ::Dict{Int64, Symbol}, ::Dict{Int64, T} where T<:AbstractVector{Regex}, ::Vector{Int64}, ::Vector{Int64}, ::Vector{Int64}) (0 children)

 inserting setindex!(A::Matrix, x::SparseArrays.AbstractSparseMatrixCSC, I::Integer, J::AbstractVector{Bool}) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/sparsematrix.jl:3537 invalidated:
   mt_backedges: 1: signature Tuple{typeof(setindex!), Matrix{Any}, Any, Any, Any} triggered MethodInstance for Base._copy_or_fill!(::Matrix{Any}, ::Tuple{Any, Any}, ::LinearAlgebra.AbstractQ) (0 children)

 inserting setindex!(A::Matrix, x::SparseArrays.AbstractSparseMatrixCSC, I::AbstractVector{Bool}, J::Integer) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/sparsematrix.jl:3538 invalidated:
   mt_backedges: 1: signature Tuple{typeof(setindex!), Matrix{Any}, Any, Any, Any} triggered MethodInstance for Base._copy_or_fill!(::Matrix{Any}, ::Tuple{Any, Any}, ::LinearAlgebra.AbstractQ) (0 children)

 inserting setindex!(A::Matrix, x::SparseArrays.AbstractSparseMatrixCSC, I::AbstractVector{Bool}, J::AbstractVector{Bool}) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/sparsematrix.jl:3539 invalidated:
   mt_backedges: 1: signature Tuple{typeof(setindex!), Matrix{Any}, Any, Any, Any} triggered MethodInstance for Base._copy_or_fill!(::Matrix{Any}, ::Tuple{Any, Any}, ::LinearAlgebra.AbstractQ) (0 children)

 inserting setindex!(A::Matrix, x::SparseArrays.AbstractSparseMatrixCSC, I::AbstractVector{<:Integer}, J::AbstractVector{Bool}) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/sparsematrix.jl:3540 invalidated:
   mt_backedges: 1: signature Tuple{typeof(setindex!), Matrix{Any}, Any, Any, Any} triggered MethodInstance for Base._copy_or_fill!(::Matrix{Any}, ::Tuple{Any, Any}, ::LinearAlgebra.AbstractQ) (0 children)

 inserting setindex!(A::Matrix, x::SparseArrays.AbstractSparseMatrixCSC, I::AbstractVector{Bool}, J::AbstractVector{<:Integer}) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/sparsematrix.jl:3541 invalidated:
   mt_backedges: 1: signature Tuple{typeof(setindex!), Matrix{Any}, Any, Any, Any} triggered MethodInstance for Base._copy_or_fill!(::Matrix{Any}, ::Tuple{Any, Any}, ::LinearAlgebra.AbstractQ) (0 children)

 rebinding Core.Binding(:(Base.Cartesian.axes), #undef, #undef, Any[CodeInstance for MethodInstance for permutedims!(::Array{Float64, 4}, ::Array{Float64, 4}, ::Vector{Int64}), CodeInstance for MethodInstance for permutedims!(::Array{T, 3}, ::Array{T, 3}, ::Vector{Int64}) where T, CodeInstance for MethodInstance for permutedims!(::Matrix{T}, ::Matrix{T}, ::Vector{Int64}) where T], 0x00) invalidated:
   mt_backedges: 1: signature Base.Cartesian.axes triggered MethodInstance for permutedims!(::Array{Float64, 4}, ::Array{Float64, 4}, ::Vector{Int64}) (0 children)
                 2: signature Base.Cartesian.axes triggered MethodInstance for permutedims!(::Array{T, 3}, ::Array{T, 3}, ::Vector{Int64}) where T (0 children)
                 3: signature Base.Cartesian.axes triggered MethodInstance for permutedims!(::Matrix{T}, ::Matrix{T}, ::Vector{Int64}) where T (0 children)

 rebinding Core.Binding(:(Base.UsesBaseOnly.title), #undef, #undef, Any[CodeInstance for MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module)], 0x00) invalidated:
   mt_backedges: 1: signature Base.UsesBaseOnly.title triggered MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module) (0 children)

 rebinding Core.Binding(:(Base.UsesBaseOnly.subtitle), #undef, #undef, Any[CodeInstance for MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module)], 0x00) invalidated:
   mt_backedges: 1: signature Base.UsesBaseOnly.subtitle triggered MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module) (0 children)

 rebinding Core.Binding(:(Base.UsesBaseOnly.xlabel), #undef, #undef, Any[CodeInstance for MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module)], 0x00) invalidated:
   mt_backedges: 1: signature Base.UsesBaseOnly.xlabel triggered MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module) (0 children)

 rebinding Core.Binding(:(Base.UsesBaseOnly.ylabel), #undef, #undef, Any[CodeInstance for MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module)], 0x00) invalidated:
   mt_backedges: 1: signature Base.UsesBaseOnly.ylabel triggered MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module) (0 children)

 rebinding Core.Binding(:(Base.UsesBaseOnly.zlabel), #undef, #undef, Any[CodeInstance for MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module)], 0x00) invalidated:
   mt_backedges: 1: signature Base.UsesBaseOnly.zlabel triggered MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module) (0 children)

 rebinding Core.Binding(:(Main.PlutoRunner), #undef, Core.BindingPartition(#undef, 0x0000000000009975, 0xffffffffffffffff, #undef, 0x0000000000000009), Any[CodeInstance for MethodInstance for getproperty(::Module, ::Symbol)], 0x00) invalidated:
   mt_backedges: 1: signature Main.PlutoRunner triggered MethodInstance for showfig(::Dict{Symbol, Any}, ::String, ::String, ::String, ::Bool, ::String) (0 children)
                 2: signature Main.PlutoRunner triggered MethodInstance for showfig(::Dict, ::String, ::String, ::String, ::Bool, ::String) (0 children)
                 3: signature Main.PlutoRunner triggered MethodInstance for getproperty(::Module, ::Symbol) (0 children)

 rebinding Core.Binding(:(Main.IJulia), #undef, Core.BindingPartition(#undef, 0x0000000000009975, 0xffffffffffffffff, #undef, 0x0000000000000009), #undef, 0x00) invalidated:
   mt_backedges: 1: signature Main.IJulia triggered MethodInstance for showfig(::Dict{Symbol, Any}, ::String, ::String, ::String, ::Bool, ::String) (0 children)
                 2: signature Main.IJulia triggered MethodInstance for showfig(::Dict, ::String, ::String, ::String, ::Bool, ::String) (0 children)

 rebinding Core.Binding(:(Main.VSCodeServer), #undef, Core.BindingPartition(#undef, 0x0000000000009975, 0xffffffffffffffff, #undef, 0x0000000000000009), #undef, 0x00) invalidated:
   mt_backedges: 1: signature Main.VSCodeServer triggered MethodInstance for showfig(::Dict{Symbol, Any}, ::String, ::String, ::String, ::Bool, ::String) (0 children)
                 2: signature Main.VSCodeServer triggered MethodInstance for showfig(::Dict, ::String, ::String, ::String, ::Bool, ::String) (0 children)

 inserting haskey(t::REPL.Terminals.TTYTerminal, key) @ REPL.Terminals ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/REPL/src/Terminals.jl:164 invalidated:
   mt_backedges: 1: signature Tuple{typeof(haskey), IO, Symbol} triggered MethodInstance for show(::IO, ::MIME{Symbol("text/plain")}, ::Vector{UInt8}) (0 children)

 rebinding Core.Binding(:(Base.UsesBaseOnly.gdalwarp), #undef, #undef, Any[CodeInstance for MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module)], 0x00) invalidated:
   mt_backedges: 1: signature Base.UsesBaseOnly.gdalwarp triggered MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module) (0 children)

 rebinding Core.Binding(:(Base.UsesBaseOnly.gdaltranslate), #undef, #undef, Any[CodeInstance for MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module)], 0x00) invalidated:
   mt_backedges: 1: signature Base.UsesBaseOnly.gdaltranslate triggered MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module) (0 children)

 rebinding Core.Binding(:(Base.UsesBaseOnly.gdalvectortranslate), #undef, #undef, Any[CodeInstance for MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module)], 0x00) invalidated:
   mt_backedges: 1: signature Base.UsesBaseOnly.gdalvectortranslate triggered MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module) (0 children)

 inserting match(re::Regex, s::LaTeXStrings.LaTeXString, idx::Integer) @ LaTeXStrings ~/.julia/packages/LaTeXStrings/6NrIG/src/LaTeXStrings.jl:126 invalidated:
   backedges: 1: superseding match(r::Regex, s::AbstractString, i::Integer) @ Base regex.jl:475 with MethodInstance for match(::Regex, ::AbstractString, ::Int64) (1 children)

 inserting IndexStyle(::SparseArrays.CHOLMOD.Dense) @ SparseArrays.CHOLMOD ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/solvers/cholmod.jl:1361 invalidated:
   backedges: 1: superseding IndexStyle(A::AbstractArray) @ Base indices.jl:94 with MethodInstance for IndexStyle(::AbstractArray) (2 children)

 inserting names(D::Vector{<:GMTdataset}) @ GMT ~/.julia/packages/GMT/FHk6Q/src/gmt_main.jl:1717 invalidated:
   mt_backedges: 1: signature Tuple{typeof(names), Any} triggered MethodInstance for REPL.accessible(::Module) (2 children)

 inserting displaysize(t::REPL.Terminals.UnixTerminal) @ REPL.Terminals ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/REPL/src/Terminals.jl:158 invalidated:
   mt_backedges: 1: signature Tuple{typeof(displaysize), IO} triggered MethodInstance for show(::IO, ::MIME{Symbol("text/plain")}, ::Vector{UInt8}) (2 children)

 inserting displaysize(::REPL.Terminals.TextTerminal) @ REPL.Terminals ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/REPL/src/Terminals.jl:46 invalidated:
   mt_backedges: 1: signature Tuple{typeof(displaysize), IO} triggered MethodInstance for show(::IO, ::MIME{Symbol("text/plain")}, ::Vector{UInt8}) (2 children)

 inserting displaysize(io::REPL.LimitIO) @ REPL ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/REPL/src/REPL.jl:484 invalidated:
   mt_backedges: 1: signature Tuple{typeof(displaysize), IO} triggered MethodInstance for show(::IO, ::MIME{Symbol("text/plain")}, ::Vector{UInt8}) (2 children)

 inserting display(d::REPL.REPLDisplay, mime::MIME{Symbol("text/plain")}, x) @ REPL ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/REPL/src/REPL.jl:532 invalidated:
   mt_backedges: 1: signature Tuple{typeof(display), AbstractDisplay, MIME, Any} triggered MethodInstance for display(::MIME, ::Any) (1 children)
                 2: signature Tuple{typeof(display), AbstractDisplay, MIME, Vector{UInt8}} triggered MethodInstance for display(::MIME, ::Vector{UInt8}) (2 children)

 inserting IOBuffer(s::LaTeXStrings.LaTeXString) @ LaTeXStrings ~/.julia/packages/LaTeXStrings/6NrIG/src/LaTeXStrings.jl:124 invalidated:
   mt_backedges: 1: signature Tuple{Type{IOBuffer}, AbstractString} triggered MethodInstance for Base.JuliaSyntax.Tokenize.Lexer(::AbstractString) (6 children)

 inserting match(re::Regex, s::LaTeXStrings.LaTeXString, idx::Integer, add_opts::UInt32) @ LaTeXStrings ~/.julia/packages/LaTeXStrings/6NrIG/src/LaTeXStrings.jl:126 invalidated:
   mt_backedges: 1: signature Tuple{typeof(match), Regex, AbstractString, Int64, UInt32} triggered MethodInstance for match(::Regex, ::Base.AnnotatedString, ::Int64, ::UInt32) (6 children)

 inserting kwcall(::NamedTuple, ::typeof(sort!), x::SparseArrays.AbstractCompressedVector) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/sparsevector.jl:2292 invalidated:
   mt_backedges: 1: signature Tuple{typeof(Core.kwcall), @NamedTuple{by::typeof(identity)}, typeof(sort!), Any} triggered MethodInstance for TOML.Internals.Printer.var"#print_table#2"(::Int64, ::Bool, ::Bool, ::IdSet{Dict{String}}, ::typeof(identity), ::typeof(TOML.Internals.Printer.print_table), ::typeof(identity), ::IOStream, ::AbstractDict, ::Vector{String}) (0 children)
   backedges: 1: superseding kwcall(::NamedTuple, ::typeof(sort!), v::AbstractVector{T}) where T @ Base.Sort sort.jl:1731 with MethodInstance for Core.kwcall(::NamedTuple{(:by,), <:Tuple{Base.Compiler.IRShow.var"#_new_nodes_iter##2#_new_nodes_iter##3"}}, ::typeof(sort!), ::AbstractVector{T}) where T (1 children)
              2: superseding kwcall(::NamedTuple, ::typeof(sort!), v::AbstractVector{T}) where T @ Base.Sort sort.jl:1731 with MethodInstance for Core.kwcall(::@NamedTuple{by::typeof(identity)}, ::typeof(sort!), ::AbstractVector{T}) where T (7 children)

 inserting setindex!(x::SparseArrays.ReadOnly, v, ind...) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/readonly.jl:25 invalidated:
   backedges: 1: superseding setindex!(A::AbstractArray, v, I...) @ Base abstractarray.jl:1454 with MethodInstance for setindex!(::AbstractArray, ::Any, ::Any, ::CartesianIndex{0}) (4 children)
              2: superseding setindex!(A::AbstractArray, v, I...) @ Base abstractarray.jl:1454 with MethodInstance for setindex!(::AbstractArray, ::Any, ::Int64, ::CartesianIndex{0}) (4 children)

 inserting eachindex(x::SparseArrays.ReadOnly) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/readonly.jl:17 invalidated:
   backedges: 1: superseding eachindex(A::AbstractVector) @ Base abstractarray.jl:321 with MethodInstance for eachindex(::AbstractVector) (4 children)
              2: superseding eachindex(A::AbstractVector) @ Base abstractarray.jl:321 with MethodInstance for eachindex(::AbstractVector) (4 children)

 inserting firstindex(x::SparseArrays.ReadOnly) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/readonly.jl:17 invalidated:
   backedges: 1: superseding firstindex(a::AbstractArray) @ Base abstractarray.jl:448 with MethodInstance for firstindex(::AbstractVector{Regex}) (3 children)
              2: superseding firstindex(a::AbstractArray) @ Base abstractarray.jl:448 with MethodInstance for firstindex(::AbstractArray{Module}) (10 children)

 unknown nothing invalidated:
   backedges: 1: superseding get_have_color() @ Base terminfo.jl:379 with MethodInstance for Base.get_have_color() (5 children)
              2: superseding displaysize(io::IOContext) @ Base show.jl:448 with MethodInstance for displaysize(::IOContext) (11 children)

 rebinding Core.Binding(:(Main.Symbol), #undef, Core.BindingPartition(Symbol, 0x000000000000990b, 0xffffffffffffffff, #undef, 0x0000000000000004), #undef, 0x00) invalidated:
   mt_backedges: 1: signature Main.Symbol triggered MethodInstance for Base.isvisible(::Symbol, ::Module, ::Module) (17 children)

 inserting eltype(x::SparseArrays.ReadOnly) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/readonly.jl:17 invalidated:
   backedges: 1: superseding eltype(x) @ Base abstractarray.jl:241 with MethodInstance for eltype(::AbstractVector) (9 children)
              2: superseding eltype(x) @ Base abstractarray.jl:241 with MethodInstance for eltype(::AbstractArray) (11 children)
              3: superseding eltype(x) @ Base abstractarray.jl:241 with MethodInstance for eltype(::AbstractArray) (11 children)

 inserting _mapreduce(f, op, ::IndexCartesian, A::Union{SparseArrays.AbstractCompressedVector{Tv, Ti}, SubArray{Tv, 1, <:SparseArrays.AbstractSparseMatrixCSC{Tv, Ti}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, false}, SubArray{Tv, 1, <:SparseArrays.AbstractSparseVector{Tv, Ti}, Tuple{Base.Slice{Base.OneTo{Int64}}}, false}} where {Tv, Ti}) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/sparsevector.jl:1667 invalidated:
   backedges: 1: superseding _mapreduce(f, op, ::IndexCartesian, A::Union{Base.AbstractBroadcasted, AbstractArray}) @ Base reduce.jl:452 with MethodInstance for Base._mapreduce(::JuliaSyntaxHighlighting.var"#19#20", ::typeof(Base.add_sum), ::IndexCartesian, ::SubArray{T, 1} where T) (9 children)
              2: superseding _mapreduce(f, op, ::IndexCartesian, A::Union{Base.AbstractBroadcasted, AbstractArray}) @ Base reduce.jl:452 with MethodInstance for Base._mapreduce(::JuliaSyntaxHighlighting.var"#23#24", ::typeof(Base.add_sum), ::IndexCartesian, ::SubArray{T, 1} where T) (29 children)

 inserting size(x::SparseArrays.ReadOnly, y...) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/readonly.jl:20 invalidated:
   mt_backedges: 1: signature Tuple{typeof(size), AbstractMatrix, Integer} triggered MethodInstance for size(::Union{LinearAlgebra.QRCompactWYQ, LinearAlgebra.QRPackedQ}, ::Integer) (2 children)
                 2: signature Tuple{typeof(size), AbstractMatrix, Int64} triggered MethodInstance for size(::LinearAlgebra.HessenbergQ, ::Int64) (37 children)

 inserting delete!(d::Dict, symbs::Array{T, N}) where {T, N} @ GMT ~/.julia/packages/GMT/FHk6Q/src/common_options.jl:32 invalidated:
   backedges: 1: superseding delete!(h::Dict, key) @ Base dict.jl:676 with MethodInstance for delete!(::Dict{Char, Nothing}, ::Any) (4 children)
              2: superseding delete!(h::Dict, key) @ Base dict.jl:676 with MethodInstance for delete!(::Dict{Any, Nothing}, ::Any) (52 children)

 inserting prevind(s::LaTeXStrings.LaTeXString, i::Int64) @ LaTeXStrings ~/.julia/packages/LaTeXStrings/6NrIG/src/LaTeXStrings.jl:110 invalidated:
   backedges: 1: superseding prevind(s::AbstractString, i::Int64) @ Base strings/basic.jl:507 with MethodInstance for prevind(::AbstractString, ::Int64) (57 children)

 inserting size(FC::SparseArrays.CHOLMOD.FactorComponent, i::Integer) @ SparseArrays.CHOLMOD ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/solvers/cholmod.jl:1363 invalidated:
   mt_backedges: 1: signature Tuple{typeof(size), AbstractMatrix, Integer} triggered MethodInstance for size(::Union{LinearAlgebra.QRCompactWYQ, LinearAlgebra.QRPackedQ}, ::Integer) (2 children)
                 2: signature Tuple{typeof(size), AbstractMatrix, Int64} triggered MethodInstance for size(::LinearAlgebra.HessenbergQ, ::Int64) (37 children)
   backedges: 1: superseding size(t::AbstractArray{T, N}, d) where {T, N} @ Base abstractarray.jl:42 with MethodInstance for size(::AbstractMatrix, ::Int64) (30 children)

 inserting axes(x::SparseArrays.ReadOnly, y...) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/readonly.jl:20 invalidated:
   backedges: 1: superseding axes(A::AbstractArray{T, N}, d) where {T, N} @ Base abstractarray.jl:75 with MethodInstance for axes(::AbstractVecOrMat, ::Int64) (16 children)
              2: superseding axes(A::AbstractArray{T, N}, d) where {T, N} @ Base abstractarray.jl:75 with MethodInstance for axes(::AbstractArray, ::Int64) (74 children)

 inserting axes(Q::SparseArrays.SPQR.QRSparseQ) @ SparseArrays.SPQR ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/solvers/spqr.jl:143 invalidated:
   backedges: 1: superseding axes(Q::LinearAlgebra.AbstractQ) @ LinearAlgebra ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/LinearAlgebra/src/abstractq.jl:75 with MethodInstance for axes(::LinearAlgebra.AbstractQ) (48 children)
              2: superseding axes(Q::LinearAlgebra.AbstractQ) @ LinearAlgebra ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/LinearAlgebra/src/abstractq.jl:75 with MethodInstance for axes(::LinearAlgebra.AbstractQ) (92 children)
   1 mt_cache

 inserting show(io::IO, s::LaTeXStrings.LaTeXString) @ LaTeXStrings ~/.julia/packages/LaTeXStrings/6NrIG/src/LaTeXStrings.jl:97 invalidated:
   backedges: 1: superseding show(io::IO, s::AbstractString) @ Base strings/io.jl:197 with MethodInstance for show(::IOBuffer, ::AbstractString) (196 children)

 inserting >(I::GMTimage{T}, val::Real) where T<:Unsigned @ GMT ~/.julia/packages/GMT/FHk6Q/src/grd_operations.jl:206 invalidated:
   backedges: 1: superseding >(x, y) @ Base operators.jl:425 with MethodInstance for >(::Any, ::Bool) (5 children)
              2: superseding >(x, y) @ Base operators.jl:425 with MethodInstance for >(::Any, ::UInt64) (7 children)
              3: superseding >(x, y) @ Base operators.jl:425 with MethodInstance for >(::Any, ::Integer) (16 children)
              4: superseding >(x, y) @ Base operators.jl:425 with MethodInstance for >(::Any, ::Int64) (188 children)
              5: superseding >(x, y) @ Base operators.jl:425 with MethodInstance for >(::Any, ::Any) (228 children)

 inserting lastindex(x::SparseArrays.ReadOnly) @ SparseArrays ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/SparseArrays/src/readonly.jl:17 invalidated:
   backedges: 1: superseding lastindex(a::AbstractArray) @ Base abstractarray.jl:425 with MethodInstance for lastindex(::AbstractVector{UInt8}) (489 children)

 inserting get(t::REPL.Terminals.TTYTerminal, key, default) @ REPL.Terminals ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.13/REPL/src/Terminals.jl:166 invalidated:
   mt_backedges:  1: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.typeinfo_prefix(::IO, ::Base.KeySet{Symbol, Dict{Symbol, Any}}) (0 children)
                  2: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.typeinfo_prefix(::IO, ::Vector{String}) (0 children)
                  3: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for Base.show_typealias(::IO, ::GlobalRef, ::Type, ::Core.SimpleVector, ::Vector{TypeVar}) (0 children)
                  4: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.typeinfo_prefix(::IO, ::Base.KeySet{K, T} where {K, T<:(Dict{K})}) (0 children)
                  5: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for show(::IO, ::MIME{Symbol("text/plain")}, ::Vector{UInt8}) (0 children)
                  6: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.typeinfo_prefix(::IO, ::Vector{UInt8}) (0 children)
                  7: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.show_delim_array(::IO, ::Base.KeySet{K, T} where {K, T<:(Dict{K})}, ::String, ::String, ::Char, ::Bool, ::Int64, ::Int64) (0 children)
                  8: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.show_delim_array(::IO, ::Base.KeySet{K, T} where {K, T<:(Dict{K})}, ::Char, ::String, ::String, ::Bool, ::Int64, ::Int64) (0 children)
                  9: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for Base.show_typealias(::IO, ::GlobalRef, ::Union, ::Core.SimpleVector, ::Vector{TypeVar}) (0 children)
                 10: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.show_delim_array(::IO, ::Base.KeySet{Symbol, Dict{Symbol, Any}}, ::String, ::String, ::Char, ::Bool, ::Int64, ::Int64) (0 children)
                 11: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.show_delim_array(::IO, ::Base.KeySet{Symbol, Dict{Symbol, Any}}, ::Char, ::String, ::String, ::Bool, ::Int64, ::Int64) (0 children)
                 12: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:auto}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, _A, Nothing, A} where {_A, A<:NamedTuple}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (1 children)
                 13: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:auto}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (1 children)
                 14: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Union{Symbol, Vector{Symbol}}, ::Union{Val{:auto}, Val{:text}, Val{:html}, Val{:latex}, Val{:markdown}}, ::Union{Nothing, Dict{Tuple{Int64, Int64}, Symbol}, Function, Tuple}, ::Bool, ::Bool, ::Union{Nothing, Function, Tuple}, ::Union{Nothing, Tuple, AbstractVector}, ::Union{Symbol, Vector{Symbol}}, ::Union{Nothing, Dict{Tuple{Int64, Int64}, Symbol}, Function, Tuple}, ::Bool, ::Int64, ::Int64, ::Symbol, ::Union{Nothing, AbstractVector}, ::Symbol, ::AbstractString, ::Symbol, ::AbstractString, ::Bool, ::Bool, ::Bool, ::AbstractString, ::Symbol, ::Base.Pairs{Symbol, V, Nothing, NT} where {V, NT<:NamedTuple}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (1 children)
                 15: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:auto}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Symbol, Nothing, @NamedTuple{crop::Symbol}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (1 children)
                 16: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:html}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (1 children)
                 17: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Vector{Symbol}, ::Val{:auto}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{Symbol}, Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Vector{String}, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Any, Nothing, @NamedTuple{crop::Symbol, reserved_display_lines::Int64, display_size::Tuple{Int64, Int64}, ellipsis_line_skip::Int64, hlines::Vector{Symbol}, newline_at_end::Bool, row_label_crayon::Crayons.Crayon, vcrop_mode::Symbol, vlines::Vector{Int64}}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (1 children)
                 18: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Vector{Symbol}, ::Val{:html}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{Symbol}, Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Vector{String}, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Any, Nothing, @NamedTuple{header_cell_titles::Tuple{Nothing, Vector{String}}, minify::Bool, show_omitted_cell_summary::Bool, standalone::Bool, table_class::String, table_div_class::String, top_left_str::String, top_right_str_decoration::PrettyTables.HtmlDecoration, vcrop_mode::Symbol, wrap_table_in_div::Bool}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (1 children)
                 19: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:auto}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{String}, Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Bool, Nothing, @NamedTuple{sortkeys::Bool}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (1 children)
                 20: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:latex}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (1 children)
                 21: signature Tuple{typeof(get), IO, Symbol, Module} triggered MethodInstance for Base.show_typealias(::IO, ::GlobalRef, ::Type, ::Core.SimpleVector, ::Vector{TypeVar}) (1 children)
                 22: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.show_delim_array(::IO, ::Base.KeySet{K, T} where {K, T<:(Dict{K})}, ::Char, ::String, ::Char, ::Bool, ::Int64, ::Int64) (1 children)
                 23: signature Tuple{typeof(get), IO, Symbol, Module} triggered MethodInstance for Base.show_typealias(::IO, ::GlobalRef, ::Union, ::Core.SimpleVector, ::Vector{TypeVar}) (1 children)
                 24: signature Tuple{typeof(get), IO, Symbol, Type{Any}} triggered MethodInstance for Base.show_delim_array(::IO, ::Base.KeySet{Symbol, Dict{Symbol, Any}}, ::Char, ::String, ::Char, ::Bool, ::Int64, ::Int64) (1 children)
                 25: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for Base.show_vector(::IO, ::Vector{UInt8}, ::Char, ::Char) (2 children)
                 26: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:auto}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{String}, Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Vector{Crayons.Crayon}, Nothing, @NamedTuple{header_crayon::Vector{Crayons.Crayon}}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (3 children)
                 27: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:auto}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{String}, Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Vector{Crayons.Crayon}, Nothing, @NamedTuple{subheader_crayon::Vector{Crayons.Crayon}}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (3 children)
                 28: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:auto}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{String}, Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Vector{Crayons.Crayon}, Nothing, @NamedTuple{header_crayon::Vector{Crayons.Crayon}, subheader_crayon::Vector{Crayons.Crayon}}}, ::typeof(PrettyTables._print_table), ::IO, ::Any) (3 children)
                 29: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Union{Symbol, Vector{Symbol}}, ::Union{Val{:auto}, Val{:text}, Val{:html}, Val{:latex}, Val{:markdown}}, ::Union{Nothing, Dict{Tuple{Int64, Int64}, Symbol}, Function, Tuple}, ::Bool, ::Bool, ::Union{Nothing, Function, Tuple}, ::Union{Nothing, Tuple, AbstractVector}, ::Union{Symbol, Vector{Symbol}}, ::Union{Nothing, Dict{Tuple{Int64, Int64}, Symbol}, Function, Tuple}, ::Bool, ::Int64, ::Int64, ::Symbol, ::Union{Nothing, AbstractVector}, ::Symbol, ::AbstractString, ::Symbol, ::AbstractString, ::Bool, ::Bool, ::Bool, ::AbstractString, ::Symbol, ::Base.Pairs{Symbol, _A, Nothing, A} where {_A, A<:NamedTuple}, ::typeof(PrettyTables._print_table), ::IO, ::Matrix{Any}) (3 children)
                 30: signature Tuple{typeof(get), IO, Symbol, Nothing} triggered MethodInstance for PrettyTables.var"#_print_table#46"(::Symbol, ::Val{:auto}, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Tuple{Vector{String}}, ::Symbol, ::Nothing, ::Bool, ::Int64, ::Int64, ::Symbol, ::Nothing, ::Symbol, ::String, ::Symbol, ::String, ::Bool, ::Bool, ::Bool, ::String, ::Symbol, ::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}, ::typeof(PrettyTables._print_table), ::IO, ::Matrix{Any}) (3 children)
                 31: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for Base.show_vector(::IO, ::Base.KeySet{K, T} where {K, T<:(Dict{K})}, ::Char, ::Char) (8 children)
                 32: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for Base.var"#with_output_color#863"(::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::typeof(Base.with_output_color), ::typeof(print), ::Symbol, ::IO, ::String) (10 children)
                 33: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for Base.ioproperties(::IO) (52 children)
                 34: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for Base.show_vector(::IO, ::Vector{String}, ::Char, ::Char) (58 children)
                 35: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for Base._show_type(::IO, ::Type) (185 children)
                 36: signature Tuple{typeof(get), IO, Symbol, Bool} triggered MethodInstance for Base.show_vector(::IO, ::Base.KeySet{Symbol, Dict{Symbol, Any}}, ::Char, ::Char) (402 children)

 inserting >=(I::GMTimage{T}, val::Real) where T<:Unsigned @ GMT ~/.julia/packages/GMT/FHk6Q/src/grd_operations.jl:217 invalidated:
   backedges: 1: superseding >=(x, y) @ Base operators.jl:472 with MethodInstance for >=(::Any, ::Any) (22 children)
              2: superseding >=(x, y) @ Base operators.jl:472 with MethodInstance for >=(::Any, ::Int64) (1100 children)

 inserting convert(::Type{String}, d::StringManipulation.Decoration) @ StringManipulation ~/.julia/packages/StringManipulation/inTre/src/decorations.jl:365 invalidated:
   mt_backedges:  1: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Union{Nothing, String}}, ::Any, ::Any) (0 children)
                  2: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for (::Base.var"#cvt1#convert##0"{Tuple{Base.PkgId, String}, <:Tuple})(::Int64) (0 children)
                  3: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for Base.CoreLogging.var"#handle_message#6"(::Base.Pairs{Symbol, _A, Nothing, A} where {_A, A<:NamedTuple}, ::typeof(Base.CoreLogging.handle_message), ::Base.CoreLogging.ConsoleLogger, ::Base.CoreLogging.LogLevel, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any) (0 children)
                  4: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for Base.CoreLogging.var"#handle_message#3"(::Base.Pairs{Symbol, _A, Nothing, A} where {_A, A<:NamedTuple}, ::typeof(Base.CoreLogging.handle_message), ::Base.CoreLogging.SimpleLogger, ::Base.CoreLogging.LogLevel, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any) (0 children)
                  5: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for Base.CoreLogging.var"#handle_message#6"(::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}, ::typeof(Base.CoreLogging.handle_message), ::Base.CoreLogging.ConsoleLogger, ::Base.CoreLogging.LogLevel, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any) (0 children)
                  6: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for Base.CoreLogging.var"#handle_message#3"(::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}, ::typeof(Base.CoreLogging.handle_message), ::Base.CoreLogging.SimpleLogger, ::Base.CoreLogging.LogLevel, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any) (0 children)
                  7: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for @NamedTuple{pkg::Pkg.Types.PackageEntry, urls::Set{String}, path::String}(::NamedTuple{(:pkg, :urls, :path), <:Tuple{Pkg.Types.PackageEntry, Any, Any}}) (0 children)
                  8: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, String}, ::Any, ::Any) (0 children)
                  9: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for (::Base.var"#cvt1#convert##0"{Tuple{Any, String}, <:Tuple})(::Int64) (0 children)
                 10: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for iterate(::OrdinalRange{String}, ::Any) (0 children)
                 11: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Vector{String}}, ::Any, ::Any) (0 children)
                 12: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for (::Base.var"#cvt1#convert##0"{Tuple{String, Dict{String, Any}, Any}, <:Tuple})(::Int64) (0 children)
                 13: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Function}, ::Any, ::Any) (1 children)
                 14: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Pkg.Types.AppInfo}, ::Any, ::Any) (2 children)
                 15: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Pkg.Types.Compat}, ::Any, ::Any) (2 children)
                 16: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Dict{String, String}}, ::Any, ::Any) (2 children)
                 17: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Union{Bool, String}}, ::Any, ::Any) (3 children)
                 18: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Union{Nothing, Tuple{Base.PkgId, String}}}, ::Any, ::Any) (3 children)
                 19: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for last(::OrdinalRange{String}) (4 children)
                 20: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{Symbol, String}, ::Any, ::Symbol) (5 children)
                 21: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for convert(::Type{Union{Nothing, String}}, ::Any) (7 children)
                 22: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Vector{String}, ::Any, ::Int64) (9 children)
                 23: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, String}, ::Any, ::String) (9 children)
                 24: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for (::Base.var"#cvt1#convert##0"{Tuple{String, Dict{String, Any}, Any}, <:Tuple})(::Int64) (10 children)
                 25: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for (::Base.var"#cvt1#convert##0"{Tuple{String, String}, <:Tuple})(::Int64) (13 children)
                 26: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for push!(::Vector{String}, ::Any) (13 children)
                 27: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Base.UUID}, ::Any, ::Any) (15 children)
                 28: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Nothing}, ::Nothing, ::Any) (15 children)
                 29: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for first(::OrdinalRange{String}) (20 children)
                 30: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Union{String, Vector{String}}}, ::Any, ::Any) (26 children)
                 31: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Dict{String, Any}, ::Any, ::Any) (36 children)
                 32: signature Tuple{typeof(convert), Type{String}, Any} triggered MethodInstance for setindex!(::Memory{String}, ::Any, ::Int64) (1374 children)

[nsajko]

Here's the invalidations I get.

Reproduce like this:

• the invalidations happen on using GMT

• don't load REPL and especially StyledStrings before measuring invalidation

• package versions:

  • GMT v1.32.0

  • SnoopCompile v3.2.0

  • SnoopCompileCore v3.1.0

Invalidations:

• including invalidation caused by precompilation: using_GMT.json

• not including invalidation caused by precompilation (there's a bit less of them here, presumably because of some type instability in Julia's precompilation logic): using_GMT_.json

Observations, in no particular order:

• A lot of invalidation occurs when loading StyledStrings.jl, xref issue Regression in latency from loading StyledStrings #57997 (comment)

• A lot of invalidation occurs when loading SparseArrays.jl.

• A lot of invalidation occurs when loading StringManipulation.jl, xref issue New convert(::Type{String}, ...)::String methods shouldn't invalidate #56173.

• A lot of invalidation occurs when defining the method >=(I::GMT.GMTimage{T}, val::Real) where T<:Unsigned in GMT.jl, xref ssue: Weird method definition for >= GenericMappingTools/GMT.jl#1799

• There's a weird entry that causes a lot of invalidation with "method": "nothing" and "reason": "unknown".

IMO, this issue should be closed now because it is not focused. Probably some other more focused issues should be opened instead.

[nsajko]

I can't pinpoint what's causing the "rebinding" invalidations. I see they do not occur when loading GDAL_jll directly. I suppose they're caused by bugs in GMT.jl itself. There's definitely lots of metaprogramming in GMT.jl.

[joa-quim]

OK, I reduced the number to 36 in GMT.jl master (part is because I had already dropped PrettyTables from the dependencies).
For that I commented some definitions involving > and >=. Now I get

julia> trees
36-element Vector{SnoopCompile.MethodInvalidations}:
 rebinding Core.Binding(:(Base.Cartesian.axes), #undef, #undef, Any[CodeInstance for MethodInstance for permutedims!(::Array{Float64, 4}, ::Array{Float64, 4}, ::Vector{Int64}), CodeInstance for MethodInstance for permutedims!(::Array{T, 3}, ::Array{T, 3}, ::Vector{Int64}) where T, CodeInstance for MethodInstance for permutedims!(::Matrix{T}, ::Matrix{T}, ::Vector{Int64}) where T], 0x00) invalidated:
   mt_backedges: 1: signature Base.Cartesian.axes triggered MethodInstance for permutedims!(::Array{Float64, 4}, ::Array{Float64, 4}, ::Vector{Int64}) (0 children)
                 2: signature Base.Cartesian.axes triggered MethodInstance for permutedims!(::Array{T, 3}, ::Array{T, 3}, ::Vector{Int64}) where T (0 children)
                 3: signature Base.Cartesian.axes triggered MethodInstance for permutedims!(::Matrix{T}, ::Matrix{T}, ::Vector{Int64}) where T (0 children)
...

julia> sum(contains.(string.(trees), "SparseArrays"))
15

julia> sum(contains.(string.(trees), "GMT"))
1

julia> findfirst(contains.(string.(trees), "GMT"))
15

julia> trees[15]
inserting names(D::Vector{<:GMTdataset}) @ GMT C:\Users\j\.julia\dev\GMT\src\gmt_main.jl:1717 invalidated:
   mt_backedges: 1: signature Tuple{typeof(names), Any} triggered MethodInstance for REPL.accessible(::Module) (2 children)

So there is only one invalidation directly involving GMT. But there is ofc those "rebinding" invalidations, which I have no idea what they are. Some mention GMT internal functions that interface with GDAL, but others not. Why this?

rebinding Core.Binding(:(Main.PlutoRunner), #undef, Core.BindingPartition(#undef, 0x0000000000009958, 0xffffffffffffffff, #undef, 0x0000000000000009), Any[CodeInstance for MethodInstance for getproperty(::Module, ::Symbol)], 0x00) invalidated:
   mt_backedges: 1: signature Main.PlutoRunner triggered MethodInstance for showfig(::Dict{Symbol, Any}, ::String, ::String, ::String, ::Bool, ::String) (0 children)
                 2: signature Main.PlutoRunner triggered MethodInstance for showfig(::Dict, ::String, ::String, ::String, ::Bool, ::String) (0 children)
                 3: signature Main.PlutoRunner triggered MethodInstance for getproperty(::Module, ::Symbol) (0 children)

The only instance where PlutoRunner occurs is in line (so tells me VSC global search).

isPluto = isdefined(Main, :PlutoRunner) && Main.PlutoRunner isa Module

And REPL? I don't have REPL or Terminals in any of the GMT dependencies.

inserting haskey(t::REPL.Terminals.TTYTerminal, key) @ REPL.Terminals C:\programs\Julia-1.13\share\julia\stdlib\v1.13\REPL\src\Terminals.jl:164 invalidated:
   mt_backedges: 1: signature Tuple{typeof(haskey), IO, Symbol} triggered MethodInstance for show(::IO, ::MIME{Symbol("text/plain")}, ::Vector{UInt8}) (0 children)

[timholy]

In some sense you're more insulated if they are...the issue is that precompilation happens in a session that doesn't load REPL, but interactive users do. Hence when you load GMT, it may suffer invalidations from REPL.

Do remember, usually the best use of measuring invalidations is to find out what is needlessly type-unstable in your code. It might be best treated as a chance to improve GMT's code. You can also get some of the same info from JET, perhaps in a less-daunting form.

[joa-quim]

Tim, thanks. I have spent days, months trying to reduce type instabilities (JET, Cthulhu), but the results were very disappointing (well, time to time they were not). GMT has many of those instabilities in places where it parses the code that deal with input arguments. Given the flexibility that I have in the package, input is passed via a Dict{Symbol, Any}, and those Any's are latter nearly impossible to kill. But that have been like that long before Julia 1.10 and those severe regressions I'm referring here started with 1.11. Hard to find where that is my fault.