Merge pull request JuliaLang#33955 from JuliaLang/sf/abstract_interpr…

…etation_plumbing

Add `AbstractInterpreter` to parameterize compilation pipeline

base/compiler/bootstrap.jl

@@ -6,7 +6,9 @@
 # since we won't be able to specialize & infer them at runtime
 
 let fs = Any[typeinf_ext, typeinf, typeinf_edge, pure_eval_call, run_passes],
- world = get_world_counter()
+ world = get_world_counter(),
+ interp = NativeInterpreter(world)
+
  for x in T_FFUNC_VAL
  push!(fs, x[3])
  end
@@ -27,7 +29,7 @@ let fs = Any[typeinf_ext, typeinf, typeinf_edge, pure_eval_call, run_passes],
  typ[i] = typ[i].ub
  end
  end
- typeinf_type(m[3], Tuple{typ...}, m[2], Params(world))
+ typeinf_type(interp, m[3], Tuple{typ...}, m[2])
  end
  end
 end

base/compiler/compiler.jl

@@ -94,11 +94,11 @@ using .Sort
 # compiler #
 ############
 
+include("compiler/types.jl")
 include("compiler/utilities.jl")
 include("compiler/validation.jl")
 
 include("compiler/inferenceresult.jl")
-include("compiler/params.jl")
 include("compiler/inferencestate.jl")
 
 include("compiler/typeutils.jl")
@@ -111,7 +111,7 @@ include("compiler/typeinfer.jl")
 include("compiler/optimize.jl") # TODO: break this up further + extract utilities
 
 include("compiler/bootstrap.jl")
-ccall(:jl_set_typeinf_func, Cvoid, (Any,), typeinf_ext)
+ccall(:jl_set_typeinf_func, Cvoid, (Any,), typeinf_ext_toplevel)
 
 end # baremodule Compiler
 ))

base/compiler/inferenceresult.jl

@@ -2,18 +2,6 @@
 
 const EMPTY_VECTOR = Vector{Any}()
 
-mutable struct InferenceResult
- linfo::MethodInstance
- argtypes::Vector{Any}
- overridden_by_const::BitVector
- result # ::Type, or InferenceState if WIP
- src #::Union{CodeInfo, OptimizationState, Nothing} # if inferred copy is available
- function InferenceResult(linfo::MethodInstance, given_argtypes = nothing)
- argtypes, overridden_by_const = matching_cache_argtypes(linfo, given_argtypes)
- return new(linfo, argtypes, overridden_by_const, Any, nothing)
- end
-end
-
 function is_argtype_match(@nospecialize(given_argtype),
  @nospecialize(cache_argtype),
  overridden_by_const::Bool)

base/compiler/inferencestate.jl

@@ -3,7 +3,7 @@
 const LineNum = Int
 
 mutable struct InferenceState
- params::Params # describes how to compute the result
+ params::InferenceParams
  result::InferenceResult # remember where to put the result
  linfo::MethodInstance
  sptypes::Vector{Any} # types of static parameter
@@ -13,6 +13,7 @@ mutable struct InferenceState
 
  # info on the state of inference and the linfo
  src::CodeInfo
+ world::UInt
  min_valid::UInt
  max_valid::UInt
  nargs::Int
@@ -47,7 +48,7 @@ mutable struct InferenceState
 
  # src is assumed to be a newly-allocated CodeInfo, that can be modified in-place to contain intermediate results
  function InferenceState(result::InferenceResult, src::CodeInfo,
- cached::Bool, params::Params)
+ cached::Bool, interp::AbstractInterpreter)
  linfo = result.linfo
  code = src.code::Array{Any,1}
  toplevel = !isa(linfo.def, Method)
@@ -95,9 +96,9 @@ mutable struct InferenceState
  max_valid = src.max_world == typemax(UInt) ?
  get_world_counter() : src.max_world
  frame = new(
- params, result, linfo,
+ InferenceParams(interp), result, linfo,
  sp, slottypes, inmodule, 0,
- src, min_valid, max_valid,
+ src, get_world_counter(interp), min_valid, max_valid,
  nargs, s_types, s_edges,
  Union{}, W, 1, n,
  cur_hand, handler_at, n_handlers,
@@ -108,17 +109,17 @@ mutable struct InferenceState
  cached, false, false, false,
  IdDict{Any, Tuple{Any, UInt, UInt}}())
  result.result = frame
- cached && push!(params.cache, result)
+ cached && push!(get_inference_cache(interp), result)
  return frame
  end
 end
 
-function InferenceState(result::InferenceResult, cached::Bool, params::Params)
+function InferenceState(result::InferenceResult, cached::Bool, interp::AbstractInterpreter)
  # prepare an InferenceState object for inferring lambda
  src = retrieve_code_info(result.linfo)
  src === nothing && return nothing
  validate_code_in_debug_mode(result.linfo, src, "lowered")
- return InferenceState(result, src, cached, params)
+ return InferenceState(result, src, cached, interp)
 end
 
 function sptypes_from_meth_instance(linfo::MethodInstance)
@@ -195,8 +196,7 @@ _topmod(sv::InferenceState) = _topmod(sv.mod)
 function update_valid_age!(min_valid::UInt, max_valid::UInt, sv::InferenceState)
  sv.min_valid = max(sv.min_valid, min_valid)
  sv.max_valid = min(sv.max_valid, max_valid)
- @assert(sv.min_valid <= sv.params.world <= sv.max_valid,
- "invalid age range update")
+ @assert(sv.min_valid <= sv.world <= sv.max_valid, "invalid age range update")
  nothing
 end
 

base/compiler/optimize.jl

@@ -5,36 +5,38 @@
 #####################
 
 mutable struct OptimizationState
+ params::OptimizationParams
  linfo::MethodInstance
  calledges::Vector{Any}
  src::CodeInfo
  mod::Module
  nargs::Int
+ world::UInt
  min_valid::UInt
  max_valid::UInt
- params::Params
  sptypes::Vector{Any} # static parameters
  slottypes::Vector{Any}
  const_api::Bool
  # cached results of calling `_methods_by_ftype` from inference, including
  # `min_valid` and `max_valid`
  matching_methods_cache::IdDict{Any, Tuple{Any, UInt, UInt}}
- function OptimizationState(frame::InferenceState)
+ # TODO: This will be eliminated once optimization no longer needs to do method lookups
+ interp::AbstractInterpreter
+ function OptimizationState(frame::InferenceState, params::OptimizationParams, interp::AbstractInterpreter)
  s_edges = frame.stmt_edges[1]
  if s_edges === nothing
  s_edges = []
  frame.stmt_edges[1] = s_edges
  end
  src = frame.src
- return new(frame.linfo,
+ return new(params, frame.linfo,
  s_edges::Vector{Any},
  src, frame.mod, frame.nargs,
- frame.min_valid, frame.max_valid,
- frame.params, frame.sptypes, frame.slottypes, false,
- frame.matching_methods_cache)
+ frame.world, frame.min_valid, frame.max_valid,
+ frame.sptypes, frame.slottypes, false,
+ frame.matching_methods_cache, interp)
  end
- function OptimizationState(linfo::MethodInstance, src::CodeInfo,
- params::Params)
+ function OptimizationState(linfo::MethodInstance, src::CodeInfo, params::OptimizationParams, interp::AbstractInterpreter)
  # prepare src for running optimization passes
  # if it isn't already
  nssavalues = src.ssavaluetypes
@@ -57,19 +59,19 @@ mutable struct OptimizationState
  inmodule = linfo.def::Module
  nargs = 0
  end
- return new(linfo,
+ return new(params, linfo,
  s_edges::Vector{Any},
  src, inmodule, nargs,
- UInt(1), get_world_counter(),
- params, sptypes_from_meth_instance(linfo), slottypes, false,
- IdDict{Any, Tuple{Any, UInt, UInt}}())
+ get_world_counter(), UInt(1), get_world_counter(),
+ sptypes_from_meth_instance(linfo), slottypes, false,
+ IdDict{Any, Tuple{Any, UInt, UInt}}(), interp)
  end
 end
 
-function OptimizationState(linfo::MethodInstance, params::Params)
+function OptimizationState(linfo::MethodInstance, params::OptimizationParams, interp::AbstractInterpreter)
  src = retrieve_code_info(linfo)
  src === nothing && return nothing
- return OptimizationState(linfo, src, params)
+ return OptimizationState(linfo, src, params, interp)
 end
 
 
@@ -109,7 +111,7 @@ _topmod(sv::OptimizationState) = _topmod(sv.mod)
 function update_valid_age!(min_valid::UInt, max_valid::UInt, sv::OptimizationState)
  sv.min_valid = max(sv.min_valid, min_valid)
  sv.max_valid = min(sv.max_valid, max_valid)
- @assert(sv.min_valid <= sv.params.world <= sv.max_valid,
+ @assert(sv.min_valid <= sv.world <= sv.max_valid,
  "invalid age range update")
  nothing
 end
@@ -127,10 +129,10 @@ function add_backedge!(li::CodeInstance, caller::OptimizationState)
  nothing
 end
 
-function isinlineable(m::Method, me::OptimizationState, bonus::Int=0)
+function isinlineable(m::Method, me::OptimizationState, params::OptimizationParams, bonus::Int=0)
  # compute the cost (size) of inlining this code
  inlineable = false
- cost_threshold = me.params.inline_cost_threshold
+ cost_threshold = params.inline_cost_threshold
  if m.module === _topmod(m.module)
  # a few functions get special treatment
  name = m.name
@@ -145,7 +147,7 @@ function isinlineable(m::Method, me::OptimizationState, bonus::Int=0)
  end
  end
  if !inlineable
- inlineable = inline_worthy(me.src.code, me.src, me.sptypes, me.slottypes, me.params, cost_threshold + bonus)
+ inlineable = inline_worthy(me.src.code, me.src, me.sptypes, me.slottypes, params, cost_threshold + bonus)
  end
  return inlineable
 end
@@ -168,7 +170,7 @@ function stmt_affects_purity(@nospecialize(stmt), ir)
 end
 
 # run the optimization work
-function optimize(opt::OptimizationState, @nospecialize(result))
+function optimize(opt::OptimizationState, params::OptimizationParams, @nospecialize(result))
  def = opt.linfo.def
  nargs = Int(opt.nargs) - 1
  @timeit "optimizer" ir = run_passes(opt.src, nargs, opt)
@@ -247,13 +249,13 @@ function optimize(opt::OptimizationState, @nospecialize(result))
  else
  bonus = 0
  if result ⊑ Tuple && !isbitstype(widenconst(result))
- bonus = opt.params.inline_tupleret_bonus
+ bonus = params.inline_tupleret_bonus
  end
  if opt.src.inlineable
  # For functions declared @inline, increase the cost threshold 20x
- bonus += opt.params.inline_cost_threshold*19
+ bonus += params.inline_cost_threshold*19
  end
- opt.src.inlineable = isinlineable(def, opt, bonus)
+ opt.src.inlineable = isinlineable(def, opt, params, bonus)
  end
  end
  nothing
@@ -282,7 +284,7 @@ plus_saturate(x::Int, y::Int) = max(x, y, x+y)
 # known return type
 isknowntype(@nospecialize T) = (T === Union{}) || isa(T, Const) || isconcretetype(widenconst(T))
 
-function statement_cost(ex::Expr, line::Int, src::CodeInfo, sptypes::Vector{Any}, slottypes::Vector{Any}, params::Params)
+function statement_cost(ex::Expr, line::Int, src::CodeInfo, sptypes::Vector{Any}, slottypes::Vector{Any}, params::OptimizationParams)
  head = ex.head
  if is_meta_expr_head(head)
  return 0
@@ -372,7 +374,7 @@ function statement_cost(ex::Expr, line::Int, src::CodeInfo, sptypes::Vector{Any}
 end
 
 function inline_worthy(body::Array{Any,1}, src::CodeInfo, sptypes::Vector{Any}, slottypes::Vector{Any},
- params::Params, cost_threshold::Integer=params.inline_cost_threshold)
+ params::OptimizationParams, cost_threshold::Integer=params.inline_cost_threshold)
  bodycost::Int = 0
  for line = 1:length(body)
  stmt = body[line]