Markdown regression on 1.11, probably by 16x (3x for PythonCall)

[PallHaraldsson]

Needs some simple precompile statement (and backport to 1.11 would be great!), then alternative to JuliaLang/Pkg.jl#4015, to fix (3x PythonCall startup regression and) 16x for its dependency JuliaPy/CondaPkg.jl#145

Pkg.REPLMode.gen_help() is slow (makes CondaPkg 16x slower, and therefore PythonCall startup), because of md_str macro taking:

julia> @time Markdown.mdexpr(" ... ")
  1.846971 seconds (794.50 k allocations: 40.745 MiB, 5.85% gc time, 99.96% compilation time)
:($(Expr(:escape, :((Markdown.MD)(Base.getindex(Any, (Markdown.Paragraph)(Base.getindex(Any, "... "))), Dict{Symbol, Any}(:config => Markdown.Config(Function[Markdown.hashheader, Markdown.list, Markdown.fencedcode, Markdown.blockquote, Markdown.admonition], Function[Markdown.blocktex, Markdown.blockinterp, Markdown.indentcode, Markdown.footnote, Markdown.github_table, Markdown.horizontalrule, Markdown.setextheader, Markdown.paragraph], Dict{Char, Vector{Function}}('!' => [Markdown.image], '_' => [Markdown.underscore_bold, Markdown.underscore_italic], '<' => [Markdown.autolink], '`' => [Markdown.inline_code], '*' => [Markdown.asterisk_bold, Markdown.asterisk_italic], '[' => [Markdown.footnote_link, Markdown.link], '\\' => [Markdown.linebreak, Markdown.escapes], '$' => [Markdown.tex, Markdown.interp], '-' => [Markdown.en_dash]))))))))

The ineffective way to time this was:

julia> @time @time md" ... "
  0.000002 seconds (6 allocations: 176 bytes)
  0.013056 seconds (219 allocations: 9.352 KiB, 98.93% compilation time)

also before that, this slow:

julia> @time using Markdown
  0.021316 seconds (8.72 k allocations: 818.078 KiB)

vs. on 1.10:

julia> @time using Markdown
  0.000452 seconds (413 allocations: 44.297 KiB)

[PallHaraldsson]

I can find precompile statements [for Markdown], might the root cause be elsewhere, I at least saw:
@tecosaur

337630b
Reimplement Markdown printing using StyledStringsUsing StyledStrings

[tecosaur]

Just taking a quick look at this, I'm not sure I can easily reproduce what you show at the start of this message?

13:50:48 ❯ julia +1.11 --startup-file=no -q
julia> using Markdown

julia> @time Markdown.mdexpr(" ... ")
  0.000120 seconds (150 allocations: 10.242 KiB)
:($(Expr(:escape, :((Markdown.MD)(Base.getindex(Any, (Markdown.Paragraph)(Base.getindex(Any, "... "))), Dict{Symbol, Any}(:config => Markdown.Config(Function[Markdown.hashheader, Markdown.list, Markdown.fencedcode, Markdown.blockquote, Markdown.admonition], Function[Markdown.blocktex, Markdown.blockinterp, Markdown.indentcode, Markdown.footnote, Markdown.github_table, Markdown.horizontalrule, Markdown.setextheader, Markdown.paragraph], Dict{Char, Vector{Function}}('!' => [Markdown.image], '_' => [Markdown.underscore_bold, Markdown.underscore_italic], '<' => [Markdown.autolink], '`' => [Markdown.inline_code], '*' => [Markdown.asterisk_bold, Markdown.asterisk_italic], '[' => [Markdown.footnote_link, Markdown.link], '\\' => [Markdown.linebreak, Markdown.escapes], '$' => [Markdown.tex, Markdown.interp], '-' => [Markdown.en_dash]))))))))

[PallHaraldsson]

I'm on 1.11.0-rc3 (confirm same regression on alpha1, rc1 and rc2...), but you on some other 1.11?! Because while it's good news to see fast for you, puzzling why that is, especially if same exact version. Are you on Arm or something (I think precompilation should work for all or no platforms...), can you show versioninfo(), and also the first line here:

$ julia +1.11 --startup-file=no -q
julia> @time using Markdown
  0.024302 seconds (8.72 k allocations: 818.078 KiB)

julia> @time Markdown.mdexpr(" ... ")
  1.756375 seconds (794.50 k allocations: 40.745 MiB, 6.03% gc time, 99.96% compilation time)
:($(Expr(:escape, :((Markdown.MD)(Base.getindex(Any, (Markdown.Paragraph)(Base.getindex(Any, "... "))), Dict{Symbol, Any}(:config => Markdown.Config(Function[Markdown.hashheader, Markdown.list, Markdown.fencedcode, Markdown.blockquote, Markdown.admonition], Function[Markdown.blocktex, Markdown.blockinterp, Markdown.indentcode, Markdown.footnote, Markdown.github_table, Markdown.horizontalrule, Markdown.setextheader, Markdown.paragraph], Dict{Char, Vector{Function}}('!' => [Markdown.image], '_' => [Markdown.underscore_bold, Markdown.underscore_italic], '<' => [Markdown.autolink], '`' => [Markdown.inline_code], '*' => [Markdown.asterisk_bold, Markdown.asterisk_italic], '[' => [Markdown.footnote_link, Markdown.link], '\\' => [Markdown.linebreak, Markdown.escapes], '$' => [Markdown.tex, Markdown.interp], '-' => [Markdown.en_dash]))))))))

julia> versioninfo()
Julia Version 1.11.0-rc3
Commit 616e45539db (2024-08-26 15:46 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 16 × Intel(R) Xeon(R) CPU D-1541 @ 2.10GHz
  WORD_SIZE: 64
  LLVM: libLLVM-16.0.6 (ORCJIT, broadwell)
Threads: 1 default, 0 interactive, 1 GC (on 16 virtual cores)

@cdoris, since this is ultimately for PythonCall, can someone confirm the regression, since I don't beleive I have unusual setup/computer, and unchanged 1.11 rc3 I believe. I wanted to make sure and move .julia out of the way (it shouldn't matter, but it's more complex now with juliaup, so will look into how), and test with for sure clean environment.

FYI, doesn't work at all on 1.12-DEV (on current nightly I just downloaded, nor the older from 1.12.0-DEV.1121 Commit ed08457 (2024-08-30"):

[ Info: Precompiling Markdown [d6f4376e-aef5-505a-96c1-9c027394607a] (cache misses: mismatched flags (2), dep uuid changed (2))
ERROR: LoadError: ArgumentError: Package Markdown does not have StyledStrings in its dependencies:
- Note that the following manifests in the load path were resolved with a potentially
  different DEV version of the current version, which may be the cause of the error.
  Try to re-resolve them in the current version, or consider deleting them if that fails:
    /home/pharaldsson/.julia/environments/v1.12/Manifest.toml
- You may have a partially installed environment. Try `Pkg.instantiate()`
  to ensure all packages in the environment are installed.
- Or, if you have Markdown checked out for development and have
  added StyledStrings as a dependency but haven't updated your primary
  environment's manifest file, try `Pkg.resolve()`.
- Otherwise you may need to report an issue with Markdown

[giordano]

I do see a major regression outside of the REPL:

$ julia --startup-file=no -e 'using Markdown; @time @eval Markdown.mdexpr(" ... ")'
  0.000410 seconds (112 allocations: 6.836 KiB)
$ julia +1.11 --startup-file=no -e 'using Markdown; @time @eval Markdown.mdexpr(" ... ")'
  1.551309 seconds (1.48 M allocations: 74.751 MiB, 2.34% gc time, 99.43% compilation time)

julia> versioninfo()
Julia Version 1.11.0-rc3
Commit 616e45539db (2024-08-26 15:46 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 256 × AMD EPYC 7742 64-Core Processor
  WORD_SIZE: 64
  LLVM: libLLVM-16.0.6 (ORCJIT, znver2)
Threads: 1 default, 0 interactive, 1 GC (on 256 virtual cores)

[PallHaraldsson]

You confirm "99.43% compilation time" unlike for @tecosaur.

Good to have regression confirmed in 1.11, but only outside of the REPL for you? For me also in the REPL, and actually even worse for a script (and there, sometimes, not always, I get "1.48 M" allocations like you, or higher):

$ time julia --startup-file=no -e 'using Markdown; @time @eval Markdown.mdexpr(" ... ")'
  2.221819 seconds (1.60 M allocations: 80.717 MiB, 2.61% gc time, 99.37% compilation time)

real	0m2,780s
user	0m3,199s
sys	0m0,474s

$ time julia +1.10 --startup-file=no -e '@time using Markdown; @time @eval Markdown.mdexpr(" ... ")'
  0.000472 seconds (413 allocations: 44.297 KiB)
  0.000475 seconds (112 allocations: 6.836 KiB)

real	0m0,293s
user	0m0,488s
sys	0m0,291s

[@eval doesn't seem needed, it added a bit of time and allocations in the REPL and for a script, and while a bit of a distraction, why did you add it?]

[tecosaur]

Ah, this is helpful. When doing it command-line like this I see a whole bunch of uncompiled stuff, as in Mose's message.

For fun, I also tried nightly, and it performs similarly to 1.11. On nightly I can do --trace-compile-timing though, which might shed some more light on where this latency spike is coming from:

~$ time julia +nightly --startup-file=no -e 'using Markdown; @time @eval Markdown.mdexpr(" ... ")' --trace-compile=/tmp/julia_precompile.jl --trace-compile-timing
  0.771441 seconds (1.30 M allocations: 68.541 MiB, 0.99% gc time, 99.29% compilation time: <1% of which was recompilation)
user=1.86s system=0.05s cpu=178% total=1.070

~$ cat /tmp/julia_precompile.jl
#=    2.5 ms =# precompile(Tuple{typeof(Base.Threads.lock_profiling), Bool})
#=    1.7 ms =# precompile(Tuple{typeof(Base.getindex), Base.Threads.Atomic{Int64}})
#=    2.7 ms =# precompile(Tuple{typeof(Base.gc_num)})
#=    2.5 ms =# precompile(Tuple{typeof(Base.cumulative_compile_timing), Bool})
#=    2.5 ms =# precompile(Tuple{typeof(Base.cumulative_compile_time_ns)})
#=   67.3 ms =# precompile(Tuple{typeof(Markdown.mdexpr), String})
#=   94.8 ms =# precompile(Tuple{typeof(Markdown.hashheader), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=    1.9 ms =# precompile(Tuple{Type{NamedTuple{(:eat,), T} where T<:Tuple}, Tuple{Bool}})
#=   68.8 ms =# precompile(Tuple{typeof(Markdown.list), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=    1.9 ms =# precompile(Tuple{Type{NamedTuple{(:padding,), T} where T<:Tuple}, Tuple{Bool}})
#=    1.7 ms =# precompile(Tuple{typeof(Base.signbit), Int64})
#=    1.9 ms =# precompile(Tuple{typeof(Base.widen), Int64})
#=   33.8 ms =# precompile(Tuple{typeof(Markdown.fencedcode), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=   23.1 ms =# precompile(Tuple{typeof(Markdown.blockquote), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=    2.4 ms =# precompile(Tuple{Type{NamedTuple{(:allow_whitespace, :allowempty, :eat), T} where T<:Tuple}, Tuple{Bool, Bool, Bool}})
#=   58.9 ms =# precompile(Tuple{typeof(Markdown.admonition), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=    2.0 ms =# precompile(Tuple{Type{NamedTuple{(:rep,), T} where T<:Tuple}, Tuple{Bool}})
#=   42.7 ms =# precompile(Tuple{typeof(Markdown.blocktex), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=   21.0 ms =# precompile(Tuple{typeof(Markdown.blockinterp), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=   16.0 ms =# precompile(Tuple{typeof(Markdown.indentcode), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=   18.9 ms =# precompile(Tuple{typeof(Markdown.footnote), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=  145.1 ms =# precompile(Tuple{typeof(Markdown.github_table), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=   24.1 ms =# precompile(Tuple{typeof(Markdown.horizontalrule), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=   24.2 ms =# precompile(Tuple{typeof(Markdown.setextheader), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=    1.9 ms =# precompile(Tuple{typeof(Base.:(==)), Char, Char})
#=    2.7 ms =# precompile(Tuple{Type{NamedTuple{(:breaking,), T} where T<:Tuple}, Tuple{Bool}})
#=   27.3 ms =# precompile(Tuple{typeof(Markdown.paragraph), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD})
#=    2.2 ms =# precompile(Tuple{typeof(Markdown.toexpr), Markdown.Paragraph})
#=    4.3 ms =# precompile(Tuple{typeof(Markdown.toexpr), Array{Any, 1}})
#=    1.5 ms =# precompile(Tuple{typeof(Markdown.toexpr), String})
#=    2.0 ms =# precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), Tuple{UInt64, UInt64}, Tuple{UInt64, UInt64}})
#=    2.1 ms =# precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(-)), Tuple{Tuple{UInt64, UInt64}, Tuple{UInt64, UInt64}}}})
#=    2.9 ms =# precompile(Tuple{Type{Base.GC_Diff}, Base.GC_Num, Base.GC_Num})
#=    2.0 ms =# precompile(Tuple{typeof(Base.getproperty), Base.GC_Diff, Symbol})
#=    2.5 ms =# precompile(Tuple{Type{NamedTuple{(:value, :time, :bytes, :gctime, :gcstats, :lock_conflicts, :compile_time, :recompile_time), T} where T<:Tuple}, Tuple{Expr, Float64, Int64, Float64, Base.GC_Diff, Int64, Float64, Float64}})
#=    3.6 ms =# precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:value, :time, :bytes, :gctime, :gcstats, :lock_conflicts, :compile_time, :recompile_time), Tuple{Expr, Float64, Int64, Float64, Base.GC_Diff, Int64, Float64, Float64}}, Symbol})
#=    1.9 ms =# precompile(Tuple{typeof(Base.:(*)), Float64, Float64})
#=    1.9 ms =# precompile(Tuple{typeof(Base.gc_alloc_count), Base.GC_Diff})
#=   34.6 ms =# precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:msg,), Tuple{Nothing}}, typeof(Base.time_print), Base.TTY, Float64, Int64, Int64, Int64, Int64, Float64, Float64, Bool})
#=   15.4 ms =# precompile(Tuple{Base.var"#1136#1137"{Nothing, Float64, Int64, Int64, Int64, Float64, Float64, Bool, String}, Base.GenericIOBuffer{Memory{UInt8}}})
#=    4.3 ms =# precompile(Tuple{typeof(Base.prettyprint_getunits), Int64, Int64, Int64})
#=    1.7 ms =# precompile(Tuple{typeof(Base.Ryu.writefixed), Float64, Int64})
#=   16.4 ms =# precompile(Tuple{Base.var"#1205#1208"{Task, Base.AsyncCondition}})
#=    4.3 ms =# precompile(Tuple{typeof(Base.uvfinalize), Base.TTY})

[PallHaraldsson]

@tecosaur, you confirm this for1.11, except for in the REPL, which is strange (and for nightly, neither in REPL, which version, because not working for me, you must have older?)?

A precompile file for me on 1.11 has one fewer statements, not sure which is missing, since I can't diff them or even run this on my nightly.

I probably only need to add this line (or more? to to a precompile file or) even just in Markdown.jl:

#=   67.3 ms =# precompile(Tuple{typeof(Markdown.mdexpr), String})

I would have though enough, enough for mdexpr (as opposed to the md_str macro too), and it recursively precompiles the functions it call, If not include all of them at least some of the more costly ones such as:

#=  145.1 ms =# precompile(Tuple{typeof(Markdown.github_table), Base.GenericIOBuffer{Memory{UInt8}}, Markdown.MD}

Some of these do not belong there, rather for Base or at least the sysimage, and I'm not sure why not already precompiled:

#=    1.9 ms =# precompile(Tuple{typeof(Base.:(==)), Char, Char})

#=    2.9 ms =# precompile(Tuple{Type{Base.GC_Diff}, Base.GC_Num, Base.GC_Num})
..
#=    1.9 ms =# precompile(Tuple{typeof(Base.gc_alloc_count), Base.GC_Diff})
#=   34.6 ms =# precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:msg,), Tuple{Nothing}}, typeof(Base.time_print), Base.TTY, Float64, Int64, Int64, Int64, Int64, Float64, Float64, Bool})
#=   15.4 ms =# precompile(Tuple{Base.var"#1136#1137"{Nothing, Float64, Int64, Int64, Int64, Float64, Float64, Bool, String}, Base.GenericIOBuffer{Memory{UInt8}}})
#=    4.3 ms =# precompile(Tuple{typeof(Base.prettyprint_getunits), Int64, Int64, Int64})
#=    1.7 ms =# precompile(Tuple{typeof(Base.Ryu.writefixed), Float64, Int64})
#=   16.4 ms =# precompile(Tuple{Base.var"#1205#1208"{Task, Base.AsyncCondition}})

[IanButterworth]

@tecosaur do you have a different version of StyledStrings in your default env that's being used over the shipped version?

And for me

% ./julia --start=no
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.12.0-DEV.1159 (2024-09-06)
 _/ |\__'_|_|_|\__'_|  |  Commit 6f04ee0ff3 (1 day old master)
|__/                   |

julia> @time using Markdown
  0.043199 seconds (72.06 k allocations: 4.184 MiB)

julia> @time Markdown.mdexpr(" ... ")
  0.510729 seconds (1.01 M allocations: 53.306 MiB, 2.19% gc time, 99.92% compilation time: <1% of which was recompilation)

[PallHaraldsson]

Can this be added to the 1.11 milestone? The fix seems simple:

My PR is forthcoming, seemingly down to 12.8 ms, now 52% faster than 1.10. Older timing, with more precompile statments, possibly harmful: down from 1.8469711.8 sec to 0.046797 sec, and actually the LATTER is still a regression of 113x (so was actually 4472x regression) and 52x in allocations... but not as worrying as the absolute time isn't that noticeable.

I added precompile statements to .julia/juliaup/julia-1.11.0-rc3+0.x64.linux.gnu/share/julia/stdlib/v1.11/Markdown/src/Markdown.jl and it seems to have some effect,

Now I get:

julia> @time using Markdown
  0.046797 seconds (21.32 k allocations: 1.407 MiB)

or:

julia> @time_imports using Markdown
      1.5 ms  Base64
     23.2 ms  Markdown

and strangely I see neither of those lines on 1.10, only this timing:
julia> @time using Markdown
  0.000222 seconds (223 allocations: 21.242 KiB)

Currently I have Markdown related plus these (that do probably not belong there, not sure if good or bad, but somebody may want to look into if belongs elsewhere):

precompile(Tuple{typeof(Base.setindex!), Base.EnvDict, Bool, String})
#precompile(Tuple{typeof(Base.something), REPL.LineEdit.Prompt, REPL.LineEdit.Prompt})
#precompile(Tuple{typeof(Base.Threads.atomic_add!), Base.Threads.Atomic{Int64}, Int64})
precompile(Tuple{typeof(Base.println), Base.TTY})
#precompile(Tuple{typeof(Base.Threads.atomic_sub!), Base.Threads.Atomic{Int64}, Int64})


#precompile(Tuple{typeof(Base.getindex), Base.Threads.Atomic{Int64}})
precompile(Tuple{typeof(Base.cumulative_compile_timing), Bool})
precompile(Tuple{typeof(Base.cumulative_compile_time_ns)})
precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), Tuple{UInt64, UInt64}, Tuple{UInt64, UInt64}})
precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(-)), Tuple{Tuple{UInt64, UInt64}, Tuple{UInt64, UInt64}}}})
precompile(Tuple{Type{NamedTuple{(:value, :time, :bytes, :gctime, :gcstats, :lock_conflicts, :compile_time, :recompile_time), T} where T<:Tuple}, Tuple{Nothing, Float64, Int64, Float64, Base.GC_Diff, Int64, Float64, Float64}})
precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:value, :time, :bytes, :gctime, :gcstats, :lock_conflicts, :compile_time, :recompile_time), Tuple{Nothing, Float64, Int64, Float64, Base.GC_Diff, Int64, Float64, Float64}}, Symbol})
precompile(Tuple{typeof(Base.:(*)), Float64, Float64})
precompile(Tuple{typeof(Base.prettyprint_getunits), Int64, Int64, Int64})
precompile(Tuple{typeof(Base.Ryu.writefixed), Float64, Int64})

and also these, I saw emitted, but since each low in ms, maybe not word adding anywhere...:
#=    2.5 ms =# precompile(Tuple{typeof(Base.Threads.lock_profiling), Bool})
#=    1.7 ms =# precompile(Tuple{typeof(Base.getindex), Base.Threads.Atomic{Int64}})
#=    2.7 ms =# precompile(Tuple{typeof(Base.gc_num)})
#=    1.9 ms =# precompile(Tuple{Type{NamedTuple{(:eat,), T} where T<:Tuple}, Tuple{Bool}})
#=    1.9 ms =# precompile(Tuple{Type{NamedTuple{(:padding,), T} where T<:Tuple}, Tuple{Bool}})
#=    2.4 ms =# precompile(Tuple{Type{NamedTuple{(:allow_whitespace, :allowempty, :eat), T} where T<:Tuple}, Tuple{Bool, Bool, Bool}})
#=    2.0 ms =# precompile(Tuple{Type{NamedTuple{(:rep,), T} where T<:Tuple}, Tuple{Bool}})
#=    1.9 ms =# precompile(Tuple{typeof(Base.:(==)), Char, Char})
#=    2.7 ms =# precompile(Tuple{Type{NamedTuple{(:breaking,), T} where T<:Tuple}, Tuple{Bool}})
#=    2.0 ms =# precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), Tuple{UInt64, UInt64}, Tuple{UInt64, UInt64}})
#=    2.1 ms =# precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(-)), Tuple{Tuple{UInt64, UInt64}, Tuple{UInt64, UInt64}}}})
#=    2.9 ms =# precompile(Tuple{Type{Base.GC_Diff}, Base.GC_Num, Base.GC_Num})
#=    2.0 ms =# precompile(Tuple{typeof(Base.getproperty), Base.GC_Diff, Symbol})
#=    2.5 ms =# precompile(Tuple{Type{NamedTuple{(:value, :time, :bytes, :gctime, :gcstats, :lock_conflicts, :compile_time, :recompile_time), T} where T<:Tuple}, Tuple{Expr, Float64, Int64, Float64, Base.GC_Diff, Int64, Float64, Float64}})
#=    3.6 ms =# precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:value, :time, :bytes, :gctime, :gcstats, :lock_conflicts, :compile_time, :recompile_time), Tuple{Expr, Float64, Int64, Float64, Base.GC_Diff, Int64, Float64, Float64}}, Symbol})
#=    1.9 ms =# precompile(Tuple{typeof(Base.:(*)), Float64, Float64})
#=    1.9 ms =# precompile(Tuple{typeof(Base.gc_alloc_count), Base.GC_Diff})
#=   34.6 ms =# precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:msg,), Tuple{Nothing}}, typeof(Base.time_print), Base.TTY, Float64, Int64, Int64, Int64, Int64, Float64, Float64, Bool})
#=    4.3 ms =# precompile(Tuple{typeof(Base.prettyprint_getunits), Int64, Int64, Int64})
#=    1.7 ms =# precompile(Tuple{typeof(Base.Ryu.writefixed), Float64, Int64})
#=    4.3 ms =# precompile(Tuple{typeof(Base.uvfinalize), Base.TTY})