simplify inline cost computation, update its docs (#42997)

Removes a special inline treatment that seems probably antiquated.

Author: aviatesk

base/compiler/optimize.jl

@@ -174,29 +174,6 @@ const TOP_TUPLE = GlobalRef(Core, :tuple)
 
 _topmod(sv::OptimizationState) = _topmod(sv.mod)
 
-function isinlineable(m::Method, me::OptimizationState, params::OptimizationParams, union_penalties::Bool, bonus::Int=0)
-    # compute the cost (size) of inlining this code
-    inlineable = false
-    cost_threshold = params.inline_cost_threshold
-    if m.module === _topmod(m.module)
-        # a few functions get special treatment
-        name = m.name
-        sig = m.sig
-        if ((name === :+ || name === :* || name === :min || name === :max) &&
-            isa(sig,DataType) &&
-            sig == Tuple{sig.parameters[1],Any,Any,Any,Vararg{Any}})
-            inlineable = true
-        elseif (name === :iterate || name === :unsafe_convert ||
-                name === :cconvert)
-            cost_threshold *= 4
-        end
-    end
-    if !inlineable
-        inlineable = inline_worthy(me.ir::IRCode, params, union_penalties, cost_threshold + bonus)
-    end
-    return inlineable
-end
-
 is_stmt_inline(stmt_flag::UInt8)      = stmt_flag & IR_FLAG_INLINE      ≠ 0
 is_stmt_noinline(stmt_flag::UInt8)    = stmt_flag & IR_FLAG_NOINLINE    ≠ 0
 is_stmt_throw_block(stmt_flag::UInt8) = stmt_flag & IR_FLAG_THROW_BLOCK ≠ 0
@@ -296,19 +273,27 @@ function finish(interp::AbstractInterpreter, opt::OptimizationState, params::Opt
         if src.inlineable && isdispatchtuple(specTypes)
             # obey @inline declaration if a dispatch barrier would not help
         else
-            bonus = 0
+            # compute the cost (size) of inlining this code
+            cost_threshold = default = params.inline_cost_threshold
             if result ⊑ Tuple && !isconcretetype(widenconst(result))
-                bonus = params.inline_tupleret_bonus
+                cost_threshold += params.inline_tupleret_bonus
             end
+            # if the method is declared as `@inline`, increase the cost threshold 20x
             if src.inlineable
-                # For functions declared @inline, increase the cost threshold 20x
-                bonus += params.inline_cost_threshold*19
+                cost_threshold += 19*default
+            end
+            # a few functions get special treatment
+            if def.module === _topmod(def.module)
+                name = def.name
+                if name === :iterate || name === :unsafe_convert || name === :cconvert
+                    cost_threshold += 4*default
+                end
             end
-            src.inlineable = isinlineable(def, opt, params, union_penalties, bonus)
+            src.inlineable = inline_worthy(ir, params, union_penalties, cost_threshold)
         end
     end
 
-    nothing
+    return nothing
 end
 
 # run the optimization work
@@ -393,7 +378,9 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
     cfg = compute_basic_blocks(code)
     types = Any[]
     stmts = InstructionStream(code, types, stmtinfo, codelocs, ssaflags)
-    ir = IRCode(stmts, cfg, collect(LineInfoNode, ci.linetable::Union{Vector{LineInfoNode},Vector{Any}}), sv.slottypes, meta, sv.sptypes)
+    linetable = ci.linetable
+    isa(linetable, Vector{LineInfoNode}) || (linetable = collect(LineInfoNode, linetable::Vector{Any}))
+    ir = IRCode(stmts, cfg, linetable, sv.slottypes, meta, sv.sptypes)
     return ir
 end
 

base/operators.jl

@@ -636,7 +636,7 @@ for op in (:+, :*, :&, :|, :xor, :min, :max, :kron)
         # note: these definitions must not cause a dispatch loop when +(a,b) is
         # not defined, and must only try to call 2-argument definitions, so
         # that defining +(a,b) is sufficient for full functionality.
-        ($op)(a, b, c, xs...) = afoldl($op, ($op)(($op)(a,b),c), xs...)
+        ($op)(a, b, c, xs...) = (@inline; afoldl($op, ($op)(($op)(a,b),c), xs...))
         # a further concern is that it's easy for a type like (Int,Int...)
         # to match many definitions, so we need to keep the number of
         # definitions down to avoid losing type information.

doc/src/devdocs/inference.md

@@ -49,16 +49,12 @@ A `CodeInfo` object may be obtained with
 ci = (@code_typed convert(Int, UInt(1)))[1]
 ```
 
-## The inlining algorithm (inline_worthy)
+## The inlining algorithm (`inline_worthy`)
 
-Much of the hardest work for inlining runs in
-`inlining_pass`. However, if your question is "why didn't my function
-inline?" then you will most likely be interested in `isinlineable` and
-its primary callee, `inline_worthy`. `isinlineable` handles a number
-of special cases (e.g., critical functions like `next` and `done`,
-incorporating a bonus for functions that return tuples, etc.). The
-main decision-making happens in `inline_worthy`, which returns `true`
-if the function should be inlined.
+Much of the hardest work for inlining runs in `ssa_inlining_pass!`.
+However, if your question is "why didn't my function inline?"
+then you will most likely be interested in `inline_worthy`,
+which makes a decision to inline the function call or not.
 
 `inline_worthy` implements a cost-model, where "cheap" functions get
 inlined; more specifically, we inline functions if their anticipated
@@ -90,7 +86,7 @@ input and output types were inferred in advance) is assigned a fixed
 cost (currently 20 cycles). In contrast, a `:call` expression, for
 functions other than intrinsics/builtins, indicates that the call will
 require dynamic dispatch, in which case we assign a cost set by
-`Params.inline_nonleaf_penalty` (currently set at 1000). Note
+`Params.inline_nonleaf_penalty` (currently set at `1000`). Note
 that this is not a "first-principles" estimate of the raw cost of
 dynamic dispatch, but a mere heuristic indicating that dynamic
 dispatch is extremely expensive.