Fix doctest failures (#248)

Fixes module namespace, floating-point regex, and updates to the latest Julia nightly.

This also prepares for the 2.6.1 release.

Author: timholy

.github/workflows/Documenter.yml

@@ -20,8 +20,9 @@ jobs:
       - uses: julia-actions/setup-julia@latest
         with:
           version: nightly
-      - run: julia --project -e 'using Pkg; Pkg.develop([PackageSpec(path="SnoopCompileCore")])'
+      - run: julia --project -e 'using Pkg; Pkg.develop([PackageSpec(path=joinpath(pwd(), "SnoopCompileCore"))])'
       - uses: julia-actions/julia-buildpkg@latest
+      - run: julia --project=docs/ -e 'using Pkg; Pkg.develop([PackageSpec(path=joinpath(pwd(), "SnoopCompileCore"))]); Pkg.instantiate()'
       - uses: julia-actions/julia-docdeploy@releases/v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Project.toml

@@ -1,7 +1,7 @@
 name = "SnoopCompile"
 uuid = "aa65fe97-06da-5843-b5b1-d5d13cad87d2"
 author = ["Tim Holy <[email protected]>"]
-version = "2.6.0"
+version = "2.6.1"
 
 [deps]
 Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f"
@@ -21,7 +21,7 @@ Cthulhu = "1.5"
 FlameGraphs = "0.2"
 OrderedCollections = "1"
 Requires = "1"
-SnoopCompileCore = "~2.5.2"
+SnoopCompileCore = "~2.6.1"
 YAML = "0.4"
 julia = "1"
 

SnoopCompileCore/Project.toml

@@ -1,7 +1,7 @@
 name = "SnoopCompileCore"
 uuid = "e2b509da-e806-4183-be48-004708413034"
 author = ["Tim Holy <[email protected]>"]
-version = "2.5.2"
+version = "2.6.1"
 
 [deps]
 Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"

SnoopCompileCore/src/snoopi_deep.jl

@@ -82,7 +82,7 @@ See also:  `flamegraph`, `flatten`, `inference_triggers`, `SnoopCompile.parcel`,
 `runtime_inferencetime`.
 
 # Example
-```jldoctest; setup=:(using SnoopCompile), filter=r"([0-9\\.e-]+/[0-9\\.e-]+|\\d direct)"
+```jldoctest; setup=:(using SnoopCompile), filter=r"([0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?/[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?|\\d direct)"
 julia> tinf = @snoopi_deep begin
            sort(rand(100))  # Evaluate some code and profile julia's type inference
        end

docs/Project.toml

@@ -1,9 +1,10 @@
 [deps]
+AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 MethodAnalysis = "85b6ec6f-f7df-4429-9514-a64bcd9ee824"
 PyPlot = "d330b81b-6aea-500a-939a-2ce795aea3ee"
 
 [compat]
-Documenter = "0.25"
+Documenter = "0.27"
 MethodAnalysis = "0.4"
 PyPlot = "2"

docs/src/snoopi_deep.md

@@ -47,7 +47,7 @@ FlattenDemo
 The main call, `packintype`, stores the input in a `struct`, and then calls functions that extract the field value and performs arithmetic on the result.
 To profile inference on this call, we simply do the following:
 
-```jldoctest flatten-demo; setup=:(using SnoopCompile), filter=r"([0-9\\.e-]+|WARNING: replacing module FlattenDemo\.\n)"
+```jldoctest flatten-demo; setup=:(using SnoopCompile), filter=r"([0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?|WARNING: replacing module FlattenDemo\.\n)"
 julia> tinf = @snoopi_deep FlattenDemo.packintype(1)
 InferenceTimingNode: 0.00932195/0.010080857 on InferenceFrameInfo for Core.Compiler.Timings.ROOT() with 1 direct children
 ```
@@ -90,7 +90,7 @@ You may have noticed that this `ROOT` node prints with two numbers.
 It will be easier to understand their meaning if we first display the whole tree.
 We can do that with the [AbstractTrees](https://github.com/JuliaCollections/AbstractTrees.jl) package:
 
-```jldoctest flatten-demo; filter=r"[0-9\\.e-]+"
+```jldoctest flatten-demo; filter=r"[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?"
 julia> using AbstractTrees
 
 julia> print_tree(tinf)
@@ -116,10 +116,10 @@ You can extract the `MethodInstance` with
 
 ```jldoctest flatten-demo
 julia> Core.MethodInstance(tinf)
-MethodInstance for ROOT()
+MethodInstance for Core.Compiler.Timings.ROOT()
 
 julia> Core.MethodInstance(tinf.children[1])
-MethodInstance for packintype(::Int64)
+MethodInstance for FlattenDemo.packintype(::Int64)
 ```
 
 Each node in this tree is accompanied by a pair of numbers.
@@ -135,7 +135,7 @@ As you will quickly discover, inference takes much more time on more complicated
 
 We can also display this tree as a flame graph, using the [ProfileView](https://github.com/timholy/ProfileView.jl) package:
 
-```jldoctest flatten-demo; filter=r"0:\d+"
+```jldoctest flatten-demo; filter=r":\d+"
 julia> fg = flamegraph(tinf)
 Node(FlameGraphs.NodeData(ROOT() at typeinfer.jl:75, 0x00, 0:10080857))
 ```

src/parcel_snoopi_deep.jl

@@ -56,7 +56,7 @@ or `nothing` to obtain them in the order they were inferred (depth-first order).
 
 We'll use [`SnoopCompile.flatten_demo`](@ref), which runs `@snoopi_deep` on a workload designed to yield reproducible results:
 
-```jldoctest flatten; setup=:(using SnoopCompile), filter=r"([0-9\\.e-]+/[0-9\\.e-]+|WARNING: replacing module FlattenDemo\\.\\n)"
+```jldoctest flatten; setup=:(using SnoopCompile), filter=r"([0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?/[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?|WARNING: replacing module FlattenDemo\\.\\n)"
 julia> tinf = SnoopCompile.flatten_demo()
 InferenceTimingNode: 0.002148974/0.002767166 on InferenceFrameInfo for Core.Compiler.Timings.ROOT() with 1 direct children
 
@@ -75,7 +75,7 @@ Note the printing of `getproperty(::SnoopCompile.FlattenDemo.MyType{$Int}, x::Sy
 that `getproperty` was inferred with. This reflects constant-propagation in inference.
 
 Then:
-```jldoctest flatten; setup=:(using SnoopCompile), filter=r"[0-9\\.e-]+/[0-9\\.e-]+"
+```jldoctest flatten; setup=:(using SnoopCompile), filter=r"[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?/[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?"
 julia> flatten(tinf; sortby=nothing)
 8-element Vector{SnoopCompileCore.InferenceTiming}:
  InferenceTiming: 0.002423543/0.0030352639999999998 on InferenceFrameInfo for Core.Compiler.Timings.ROOT()
@@ -142,12 +142,12 @@ that it is being inferred for many specializations (which might include speciali
 
 We'll use [`SnoopCompile.flatten_demo`](@ref), which runs `@snoopi_deep` on a workload designed to yield reproducible results:
 
-```jldoctest accum1; setup=:(using SnoopCompile), filter=r"([0-9\\.e-]+|at .*/deep_demos.jl:\\d+|WARNING: replacing module FlattenDemo\\.\\n)"
+```jldoctest accum1; setup=:(using SnoopCompile), filter=r"([0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?|at .*/deep_demos.jl:\\d+|at Base\\.jl:\\d+|at compiler/typeinfer\\.jl:\\d+|WARNING: replacing module FlattenDemo\\.\\n)"
 julia> tinf = SnoopCompile.flatten_demo()
 InferenceTimingNode: 0.002148974/0.002767166 on InferenceFrameInfo for Core.Compiler.Timings.ROOT() with 1 direct children
 
 julia> accumulate_by_source(flatten(tinf))
-7-element Vector{Tuple{Float64, Method}}:
+7-element Vector{Tuple{Float64, Union{Method, Core.MethodInstance}}}:
  (6.0012999999999996e-5, getproperty(x, f::Symbol) in Base at Base.jl:33)
  (6.7714e-5, extract(y::SnoopCompile.FlattenDemo.MyType) in SnoopCompile.FlattenDemo at /pathto/SnoopCompile/src/deep_demos.jl:35)
  (9.421e-5, dostuff(y) in SnoopCompile.FlattenDemo at /pathto/SnoopCompile/src/deep_demos.jl:44)
@@ -354,7 +354,7 @@ See also: [`SnoopCompile.write`](@ref).
 
 We'll use [`SnoopCompile.itrigs_demo`](@ref), which runs `@snoopi_deep` on a workload designed to yield reproducible results:
 
-```jldoctest parceltree; setup=:(using SnoopCompile), filter=r"([0-9\\.e-]+|WARNING: replacing module ItrigDemo\\.\\n|UInt8|Float64)"
+```jldoctest parceltree; setup=:(using SnoopCompile), filter=r"([0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?|WARNING: replacing module ItrigDemo\\.\\n|UInt8|Float64|SnoopCompile\\.ItrigDemo\\.)"
 julia> tinf = SnoopCompile.itrigs_demo()
 InferenceTimingNode: 0.004490576/0.004711168 on InferenceFrameInfo for Core.Compiler.Timings.ROOT() with 2 direct children
 
@@ -700,7 +700,7 @@ All the entries in `itrigs` are previously uninferred, or are freshly-inferred f
 
 We'll use [`SnoopCompile.itrigs_demo`](@ref), which runs `@snoopi_deep` on a workload designed to yield reproducible results:
 
-```jldoctest triggers; setup=:(using SnoopCompile), filter=r"([0-9\\.e-]+|.*/deep_demos\\.jl:\\d+|WARNING: replacing module ItrigDemo\\.\\n)"
+```jldoctest triggers; setup=:(using SnoopCompile), filter=r"([0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?|.*/deep_demos\\.jl:\\d+|WARNING: replacing module ItrigDemo\\.\\n)"
 julia> tinf = SnoopCompile.itrigs_demo()
 InferenceTimingNode: 0.004490576/0.004711168 on InferenceFrameInfo for Core.Compiler.Timings.ROOT() with 2 direct children
 
@@ -939,6 +939,14 @@ function findparent(node::TriggerNode, bt)
     return findparent(node.parent, bt)
 end
 
+"""
+    root = trigger_tree(itrigs)
+
+Organize inference triggers `itrigs` in tree format, grouping items via the call tree.
+
+It is a tree rather than a more general graph due to the fact that caching inference results means that each node gets
+visited only once.
+"""
 function trigger_tree(itrigs::AbstractVector{InferenceTrigger})
     root = node = TriggerNode()
     for itrig in itrigs
@@ -1668,7 +1676,7 @@ each method will cause the number of specializations to be included in the frame
 
 We'll use [`SnoopCompile.flatten_demo`](@ref), which runs `@snoopi_deep` on a workload designed to yield reproducible results:
 
-```jldoctest flamegraph; setup=:(using SnoopCompile), filter=r"([0-9\\.e-]+/[0-9\\.e-]+|at.*typeinfer\\.jl:\\d+|0:\\d+|WARNING: replacing module FlattenDemo\\.\\n)"
+```jldoctest flamegraph; setup=:(using SnoopCompile), filter=r"([0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?/[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?|at.*typeinfer\\.jl:\\d+|0:\\d+|WARNING: replacing module FlattenDemo\\.\\n)"
 julia> tinf = SnoopCompile.flatten_demo()
 InferenceTimingNode: 0.002148974/0.002767166 on InferenceFrameInfo for Core.Compiler.Timings.ROOT() with 1 direct children