Add timing @zones for profiling each pass (#69)

Author: mlechu

src/closure_conversion.jl

@@ -580,7 +580,7 @@ Invariants:
 * This pass must not introduce new K"Identifier" - only K"BindingId".
 * Any new binding IDs must be added to the enclosing lambda locals
 """
-function convert_closures(ctx::VariableAnalysisContext, ex)
+@fzone "JL: closures" function convert_closures(ctx::VariableAnalysisContext, ex)
     ctx = ClosureConversionCtx(ctx.graph, ctx.bindings, ctx.mod,
                                ctx.closure_bindings, ex.lambda_bindings)
     ex1 = closure_convert_lambda(ctx, ex)

src/compat.jl

@@ -29,7 +29,7 @@ function expr_to_syntaxtree(@nospecialize(e), lnn::Union{LineNumberNode, Nothing
     expr_to_syntaxtree(graph, e, lnn)
 end
 
-function expr_to_syntaxtree(ctx, @nospecialize(e), lnn::Union{LineNumberNode, Nothing})
+@fzone "JL: expr_to_syntaxtree" function expr_to_syntaxtree(ctx, @nospecialize(e), lnn::Union{LineNumberNode, Nothing})
     graph = syntax_graph(ctx)
     toplevel_src = if isnothing(lnn)
         # Provenance sinkhole for all nodes until we hit a linenode

src/desugaring.jl

@@ -4586,7 +4586,7 @@ function expand_forms_2(ctx::StatementListCtx, args...)
     expand_forms_2(ctx.ctx, args...)
 end
 
-function expand_forms_2(ctx::MacroExpansionContext, ex::SyntaxTree)
+@fzone "JL: desugar" function expand_forms_2(ctx::MacroExpansionContext, ex::SyntaxTree)
     ctx1 = DesugaringContext(ctx, ctx.expr_compat_mode)
     ex1 = expand_forms_2(ctx1, reparent(ctx1, ex))
     ctx1, ex1

src/eval.jl

@@ -156,7 +156,7 @@ function to_code_info(ex, mod, funcname, slots)
 
     stmt_offset = length(stmts)
     for stmt in children(ex)
-        push!(stmts, to_lowered_expr(mod, stmt, stmt_offset))
+        push!(stmts, _to_lowered_expr(mod, stmt, stmt_offset))
         add_ir_debug_info!(current_codelocs_stack, stmt)
     end
 
@@ -223,7 +223,11 @@ function to_code_info(ex, mod, funcname, slots)
     )
 end
 
-function to_lowered_expr(mod, ex, stmt_offset=0)
+@fzone "JL: to_lowered_expr" function to_lowered_expr(mod, ex)
+    _to_lowered_expr(mod, ex, 0)
+end
+
+function _to_lowered_expr(mod, ex, stmt_offset)
     k = kind(ex)
     if is_literal(k)
         ex.value
@@ -259,7 +263,7 @@ function to_lowered_expr(mod, ex, stmt_offset=0)
     elseif k == K"SSAValue"
         Core.SSAValue(ex.var_id + stmt_offset)
     elseif k == K"return"
-        Core.ReturnNode(to_lowered_expr(mod, ex[1], stmt_offset))
+        Core.ReturnNode(_to_lowered_expr(mod, ex[1], stmt_offset))
     elseif k == K"inert"
         e1 = ex[1]
         getmeta(ex, :as_Expr, false) ? QuoteNode(Expr(e1)) : e1
@@ -278,36 +282,36 @@ function to_lowered_expr(mod, ex, stmt_offset=0)
     elseif k == K"goto"
         Core.GotoNode(ex[1].id + stmt_offset)
     elseif k == K"gotoifnot"
-        Core.GotoIfNot(to_lowered_expr(mod, ex[1], stmt_offset), ex[2].id + stmt_offset)
+        Core.GotoIfNot(_to_lowered_expr(mod, ex[1], stmt_offset), ex[2].id + stmt_offset)
     elseif k == K"enter"
         catch_idx = ex[1].id
         numchildren(ex) == 1 ?
             Core.EnterNode(catch_idx) :
-            Core.EnterNode(catch_idx, to_lowered_expr(mod, ex[2], stmt_offset))
+            Core.EnterNode(catch_idx, _to_lowered_expr(mod, ex[2], stmt_offset))
     elseif k == K"method"
-        cs = map(e->to_lowered_expr(mod, e, stmt_offset), children(ex))
+        cs = map(e->_to_lowered_expr(mod, e, stmt_offset), children(ex))
         # Ad-hoc unwrapping to satisfy `Expr(:method)` expectations
         c1 = cs[1] isa QuoteNode ? cs[1].value : cs[1]
         Expr(:method, c1, cs[2:end]...)
     elseif k == K"newvar"
-        Core.NewvarNode(to_lowered_expr(mod, ex[1], stmt_offset))
+        Core.NewvarNode(_to_lowered_expr(mod, ex[1], stmt_offset))
     elseif k == K"opaque_closure_method"
-        args = map(e->to_lowered_expr(mod, e, stmt_offset), children(ex))
+        args = map(e->_to_lowered_expr(mod, e, stmt_offset), children(ex))
         # opaque_closure_method has special non-evaluated semantics for the
         # `functionloc` line number node so we need to undo a level of quoting
         @assert args[4] isa QuoteNode
         args[4] = args[4].value
         Expr(:opaque_closure_method, args...)
     elseif k == K"meta"
-        args = Any[to_lowered_expr(mod, e, stmt_offset) for e in children(ex)]
+        args = Any[_to_lowered_expr(mod, e, stmt_offset) for e in children(ex)]
         # Unpack K"Symbol" QuoteNode as `Expr(:meta)` requires an identifier here.
         args[1] = args[1].value
         Expr(:meta, args...)
     elseif k == K"static_eval"
         @assert numchildren(ex) == 1
-        to_lowered_expr(mod, ex[1], stmt_offset)
+        _to_lowered_expr(mod, ex[1], stmt_offset)
     elseif k == K"cfunction"
-        args = Any[to_lowered_expr(mod, e, stmt_offset) for e in children(ex)]
+        args = Any[_to_lowered_expr(mod, e, stmt_offset) for e in children(ex)]
         if kind(ex[2]) == K"static_eval"
             args[2] = QuoteNode(args[2])
         end
@@ -339,13 +343,13 @@ function to_lowered_expr(mod, ex, stmt_offset=0)
         if isnothing(head)
             throw(LoweringError(ex, "Unhandled form for kind $k"))
         end
-        Expr(head, map(e->to_lowered_expr(mod, e, stmt_offset), children(ex))...)
+        Expr(head, map(e->_to_lowered_expr(mod, e, stmt_offset), children(ex))...)
     end
 end
 
 #-------------------------------------------------------------------------------
 # Our version of eval takes our own data structures
-function Core.eval(mod::Module, ex::SyntaxTree; expr_compat_mode::Bool=false)
+@fzone "JL: eval" function Core.eval(mod::Module, ex::SyntaxTree; expr_compat_mode::Bool=false)
     k = kind(ex)
     if k == K"toplevel"
         x = nothing
@@ -355,7 +359,7 @@ function Core.eval(mod::Module, ex::SyntaxTree; expr_compat_mode::Bool=false)
         return x
     end
     linear_ir = lower(mod, ex; expr_compat_mode)
-    expr_form = to_lowered_expr(mod, linear_ir, 0)
+    expr_form = to_lowered_expr(mod, linear_ir)
     eval(mod, expr_form)
 end
 

src/linear_ir.jl

@@ -1109,7 +1109,7 @@ Most of the compliexty of this pass is in lowering structured control flow (if,
 loops, etc) to gotos and exception handling to enter/leave. We also convert
 `K"BindingId"` into K"slot", `K"globalref"` or `K"SSAValue` as appropriate.
 """
-function linearize_ir(ctx, ex)
+@fzone "JL: linearize" function linearize_ir(ctx, ex)
     graph = ensure_attributes(ctx.graph,
                               slots=Vector{Slot},
                               mod=Module,
@@ -1127,4 +1127,3 @@ function linearize_ir(ctx, ex)
     res = compile_lambda(_ctx, reparent(_ctx, ex))
     _ctx, res
 end
-

src/macro_expansion.jl

@@ -460,7 +460,7 @@ function expand_forms_1(ctx::MacroExpansionContext, ex::SyntaxTree)
     end
 end
 
-function expand_forms_1(mod::Module, ex::SyntaxTree, expr_compat_mode::Bool, macro_world::UInt)
+@fzone "JL: macroexpand" function expand_forms_1(mod::Module, ex::SyntaxTree, expr_compat_mode::Bool, macro_world::UInt)
     graph = ensure_attributes(syntax_graph(ex),
                               var_id=IdTag,
                               scope_layer=LayerId,

src/scope_analysis.jl

@@ -802,7 +802,7 @@ metadata about each binding.
 This pass also records the set of binding IDs used locally within the
 enclosing lambda form and information about variables captured by closures.
 """
-function resolve_scopes(ctx::DesugaringContext, ex)
+@fzone "JL: resolve_scopes" function resolve_scopes(ctx::DesugaringContext, ex)
     ctx2 = ScopeResolutionContext(ctx)
     ex2 = resolve_scopes(ctx2, reparent(ctx2, ex))
     ctx3 = VariableAnalysisContext(ctx2.graph, ctx2.bindings, ctx2.mod, ex2.lambda_bindings)

src/utils.jl

@@ -169,3 +169,17 @@ function _print_ir(io::IO, ex, indent)
         end
     end
 end
+
+# Wrap a function body in Base.Compiler.@zone for profiling
+if isdefined(Base.Compiler, Symbol("@zone"))
+    macro fzone(str, f)
+        @assert f isa Expr && f.head === :function && length(f.args) === 2 && str isa String
+        esc(Expr(:function, f.args[1],
+                 # Use source of our caller, not of this macro.
+                 Expr(:macrocall, :(Base.Compiler.var"@zone"), __source__, str, f.args[2])))
+    end
+else
+    macro fzone(str, f)
+        esc(f)
+    end
+end