added a section on implementation of the profiler using IRTools

Author: pevnak

docs/src/lecture_09/calls.jl

@@ -1,4 +1,3 @@
-
 struct Calls
     stamps::Vector{Float64} # contains the time stamps
     event::Vector{Symbol}  # name of the function that is being recorded
@@ -59,3 +58,10 @@ end
 
 reset!(calls::Calls) = calls.i[] = 0
 
+function Base.resize!(calls::Calls, n::Integer)
+  resize!(calls.stamps, n)
+  resize!(calls.event, n)
+  resize!(calls.startstop, n)
+end
+
+

docs/src/lecture_09/codeinfo.jl

@@ -16,37 +16,13 @@ function retrieve_code_info(sigtypes, world = Base.get_world_counter())
     ci
 end
 
-# # We migth consider this from IRTools. Importantly, it has partially_inline to get 
-# # rid of static parameters
-# function meta(T; types = T, world = worldcounter())
-#   F = T.parameters[1]
-#   F == typeof(invoke) && return invoke_meta(T; world = world)
-#   F isa DataType && (F.name.module === Core.Compiler ||
-#                      F <: Core.Builtin ||
-#                      F <: Core.Builtin) && return nothing
-#   _methods = Base._methods_by_ftype(T, -1, world)
-#   length(_methods) == 0 && return nothing
-#   type_signature, sps, method = last(_methods)
-#   sps = svec(map(untvar, sps)...)
-#   @static if VERSION >= v"1.2-"
-#     mi = Core.Compiler.specialize_method(method, types, sps)
-#     ci = Base.isgenerated(mi) ? Core.Compiler.get_staged(mi) : Base.uncompressed_ast(method)
-#   else
-#     mi = Core.Compiler.code_for_method(method, types, sps, world, false)
-#     ci = Base.isgenerated(mi) ? Core.Compiler.get_staged(mi) : Base.uncompressed_ast(mi)
-#   end
-#   Base.Meta.partially_inline!(ci.code, [], method.sig, Any[sps...], 0, 0, :propagate)
-#   Meta(method, mi, ci, method.nargs, sps)
-# end
-
-
 function overdubbable(ex::Expr) 
     ex.head != :call && return(false)
     length(ex.args) < 2 && return(false)
     return(overdubbable(ex.args[1]))
 end
 overdubbable(gr::Core.GlobalRef) = gr.name ∉ [:overdub, :record_start, :record_end, :promote, :convert, :tuple]
-overdubbable(gr::Symbol) = 
+# overdubbable(gr::Symbol) = 
 overdubbable(ex) = false
 timable(ex) = overdubbable(ex)
 
@@ -80,6 +56,7 @@ end
 
 
 overdub(f::Core.IntrinsicFunction, args...) = f(args...)
+overdub(f::Core.Builtin, args...) = f(args...)
 
 @generated function overdub(f::F, args...) where {F}
     ci = retrieve_code_info((F, args...))
@@ -121,9 +98,9 @@ overdub(f::Core.IntrinsicFunction, args...) = f(args...)
             push!(new_ci.codelocs, ci.codelocs[ci_no])
             newci_no += 1
             maps.goto[ci_no] = newci_no
-            if overdubbable(ex)
-                ex = Expr(:call, GlobalRef(Main, :overdub), ex.args...)
-            end
+            # if overdubbable(ex)
+            #     ex = Expr(:call, GlobalRef(Main, :overdub), ex.args...)
+            # end
             push!(new_ci.code, ex)
             push!(new_ci.codelocs, ci.codelocs[ci_no])
             newci_no += 1

docs/src/lecture_09/irtools.jl

@@ -1,7 +1,8 @@
 # Generated functions
-using Dictionaries, IRTools
+using IRTools
+using IRTools: var, xcall, insert!, insertafter!, func, recurse!, @dynamo
 include("calls.jl")
-using IRTools: var, xcall, insert!, insertafter!, func
+resize!(to, 10000)
 
 function timable(ex::Expr) 
     ex.head != :call && return(false)
@@ -12,34 +13,20 @@ function timable(ex::Expr)
 end
 timable(ex) = false
 
+recursable(gr::GlobalRef) = gr.name ∉ [:profile_fun, :record_start, :record_end]
+recursable(ex::Expr) = ex.head == :call && recursable(ex.args[1])
+recursable(ex) = false
+
 exportname(ex::GlobalRef) = QuoteNode(ex.name)
 exportname(ex::Symbol) = QuoteNode(ex)
 exportname(ex::Expr) = exportname(ex.args[1])
 exportname(i::Int) = QuoteNode(Symbol("Int(",i,")"))
 
-function foo(x, y)
-   z =  x * y
-   z + sin(y)
-end
-
-# ir = @code_ir foo(1.0, 1.0)
-ir = @code_ir sin(1.0)
+profile_fun(f::Core.IntrinsicFunction, args...) = f(args...)
+profile_fun(f::Core.Builtin, args...) = f(args...)
 
-# writing our profiler would be relatively 
-# we will iterate over the ir code and inserts appropriate logs
-for b in IRTools.blocks(ir)
-    for (v, ex) in b
-        if timable(ex.expr)
-            fname = exportname(ex.expr)
-            insert!(b, v, xcall(Main, :record_start, fname))
-            insertafter!(b, v, xcall(Main, :record_end, fname))
-        end
-    end
-end
-
-@generated function profile_fun(f, args...)
-    m = IRTools.Inner.meta(Tuple{f,args...})
-    ir = IRTools.Inner.IR(m)
+@dynamo function profile_fun(f, args...)
+    ir = IRTools.Inner.IR(f, args...)
     for b in IRTools.blocks(ir)
         for (v, ex) in b
             if timable(ex.expr)
@@ -49,19 +36,14 @@ end
             end
         end
     end
-
-    # we need to deal with the problem that ir has different set so f arguments than profile_fun(f, args...)
-    # THis is what a dynamo does for us
-    return(IRTools.Inner.build_codeinfo(ir))
+    for (x, st) in ir
+        recursable(st.expr) || continue
+        ir[x] = xcall(profile_fun, st.expr.args...)
+    end
+    # recurse!(ir)
+    return ir
 end
 
-f = func(ir)
-# f(nothing, 1.0, 1.0)
-# f = func(ir)
-f(nothing, 1.0)
-
-function func(m::Module, ir::IR)
-  @eval @generated function $(gensym())($([Symbol(:arg, i) for i = 1:length(arguments(ir))]...))
-    return build_codeinfo($ir)
-  end
-end
+reset!(to)
+profile_fun(foo, 1.0, 1.0)
+to