Eliminate dynamic dispatch to improve performance

Author: timholy

src/breakpoints.jl

@@ -21,11 +21,10 @@ function add_breakpoint(framecode, stmtidx)
     return bp
 end
 
-function shouldbreak(frame, pc=frame.pc)
-    idx = pc
+function shouldbreak(frame::Frame, pc::Int)
     bps = frame.framecode.breakpoints
-    isassigned(bps, idx) || return false
-    bp = bps[idx]
+    isassigned(bps, pc) || return false
+    bp = bps[pc]
     bp.isactive || return false
     return Base.invokelatest(bp.condition, frame)::Bool
 end

src/commands.jl

@@ -13,7 +13,7 @@ function finish!(@nospecialize(recurse), frame::Frame, istoplevel::Bool=false)
     local pc
     while true
         pc = step_expr!(recurse, frame, istoplevel)
-        (pc == nothing || isa(pc, BreakpointRef)) && return pc
+        (pc === nothing || isa(pc, BreakpointRef)) && return pc
         shouldbreak(frame, pc) && return BreakpointRef(frame.framecode, pc)
     end
 end
@@ -68,7 +68,7 @@ function finish_stack!(@nospecialize(recurse), frame::Frame, istoplevel::Bool=fa
         end
         pc += 1
         frame.pc = pc
-        shouldbreak(frame) && return BreakpointRef(frame.framecode, pc)
+        shouldbreak(frame, pc) && return BreakpointRef(frame.framecode, pc)
     end
 end
 finish_stack!(frame::Frame, istoplevel::Bool=false) = finish_stack!(finish_and_return!, frame, istoplevel)

src/construct.jl

@@ -289,12 +289,11 @@ end
 
 """
     frame = prepare_frame(framecode::FrameCode, frameargs, lenv)
-    frame = prepare_frame(caller::Frame, framecode::FrameCode, frameargs, lenv)
 
 Construct a new `Frame` for `framecode`, given lowered-code arguments `frameargs` and
 static parameters `lenv`. See [`JuliaInterpreter.prepare_call`](@ref) for information about how to prepare the inputs.
 """
-function prepare_frame(framecode, args, lenv)
+function prepare_frame(framecode::FrameCode, args::Vector{Any}, lenv::SimpleVector)
     framedata = prepare_framedata(framecode, args)
     resize!(framedata.sparams, length(lenv))
     # Add static parameters to environment
@@ -306,7 +305,7 @@ function prepare_frame(framecode, args, lenv)
     return Frame(framecode, framedata)
 end
 
-function prepare_frame(caller::Frame, framecode, args, lenv)
+function prepare_frame_caller(caller::Frame, framecode::FrameCode, args::Vector{Any}, lenv::SimpleVector)
     caller.callee = frame = prepare_frame(framecode, args, lenv)
     frame.caller = caller
     return frame

src/interpret.jl

@@ -173,7 +173,7 @@ function bypass_builtins(frame, call_expr, pc)
     return nothing
 end
 
-function evaluate_call!(::Compiled, frame::Frame, call_expr::Expr)
+function evaluate_call_compiled!(::Compiled, frame::Frame, call_expr::Expr)
     pc = frame.pc
     ret = bypass_builtins(frame, call_expr, pc)
     isa(ret, Some{Any}) && return ret.value
@@ -185,7 +185,7 @@ function evaluate_call!(::Compiled, frame::Frame, call_expr::Expr)
     return f(fargs...)
 end
 
-function evaluate_call!(@nospecialize(recurse::Function), frame::Frame, call_expr::Expr)
+function evaluate_call_recurse!(@nospecialize(recurse), frame::Frame, call_expr::Expr)
     pc = frame.pc
     ret = bypass_builtins(frame, call_expr, pc)
     isa(ret, Some{Any}) && return ret.value
@@ -206,15 +206,21 @@ function evaluate_call!(@nospecialize(recurse::Function), frame::Frame, call_exp
         end
         return framecode  # this was a Builtin
     end
-    newframe = prepare_frame(frame, framecode, fargs, lenv)
-    shouldbreak(newframe) && return BreakpointRef(newframe.framecode, newframe.pc)
-    ret = recurse(recurse, newframe)  # if this errors, handle_err will pop the stack and recycle newframe
+    newframe = prepare_frame_caller(frame, framecode, fargs, lenv)
+    npc = newframe.pc
+    shouldbreak(newframe, npc) && return BreakpointRef(newframe.framecode, npc)
+    # if the following errors, handle_err will pop the stack and recycle newframe
+    if recurse === finish_and_return!
+        # Optimize this case to avoid dynamic dispatch
+        ret = finish_and_return!(finish_and_return!, newframe, false)
+    else
+        ret = recurse(recurse, newframe, false)
+    end
     isa(ret, BreakpointRef) && return ret
     frame.callee = nothing
     recycle(newframe)
     return ret
 end
-evaluate_call!(frame::Frame, call_expr::Expr) = evaluate_call!(finish_and_return!, frame, call_expr)
 
 """
     ret = evaluate_call!(Compiled(), frame::Frame, call_expr)
@@ -225,7 +231,9 @@ The first causes it to be executed using Julia's normal dispatch (compiled code)
 whereas the second recurses in via the interpreter.
 `recurse` has a default value of [`JuliaInterpreter.finish_and_return!`](@ref).
 """
-evaluate_call!
+evaluate_call!(::Compiled, frame::Frame, call_expr::Expr) = evaluate_call_compiled!(Compiled(), frame, call_expr)
+evaluate_call!(@nospecialize(recurse), frame::Frame, call_expr::Expr) = evaluate_call_recurse!(recurse, frame, call_expr)
+evaluate_call!(frame::Frame, call_expr::Expr) = evaluate_call!(finish_and_return!, frame, call_expr)
 
 # The following come up only when evaluating toplevel code
 function evaluate_methoddef(frame, node)
@@ -317,7 +325,9 @@ function eval_rhs(@nospecialize(recurse), frame, node::Expr)
     elseif head == :isdefined
         return check_isdefined(frame, node.args[1])
     elseif head == :call
-        return evaluate_call!(recurse, frame, node)
+        # here it's crucial to avoid dynamic dispatch
+        isa(recurse, Compiled) && return evaluate_call_compiled!(recurse, frame, node)
+        return evaluate_call_recurse!(recurse, frame, node)
     elseif head == :foreigncall || head == :cfunction
         return evaluate_foreigncall(frame, node)
     elseif head == :copyast

test/utils.jl

@@ -41,7 +41,7 @@ Run `frame` until one of:
 """
 function evaluate_limited!(@nospecialize(recurse), frame::Frame, nstmts::Int, istoplevel::Bool=false)
     refnstmts = Ref(nstmts)
-    limexec!(s,f) = limited_exec!(s, f, refnstmts, istoplevel)
+    limexec!(s, f, istl) = limited_exec!(s, f, refnstmts, istl)
     # The following is like finish!, except we intercept :call expressions so that we can run them
     # with limexec! rather than the default finish_and_return!
     pc = frame.pc