inlheur

func AnalyzeFunc ¶

func AnalyzeFunc(fn *ir.Func, canInline func(*ir.Func), budgetForFunc func(*ir.Func) int32, inlineMaxBudget int)

AnalyzeFunc computes function properties for fn and its contained closures, updating the global 'fpmap' table. It is assumed that "CanInline" has been run on fn and on the closures that feed directly into calls; other closures not directly called will also be checked inlinability for inlinability here in case they are returned as a result.

func BudgetExpansion ¶

func BudgetExpansion(maxBudget int32) int32

BudgetExpansion returns the amount to relax/expand the base inlining budget when the new inliner is turned on; the inliner will add the returned value to the hairyness budget.

Background: with the new inliner, the score for a given callsite can be adjusted down by some amount due to heuristics, however we won't know whether this is going to happen until much later after the CanInline call. This function returns the amount to relax the budget initially (to allow for a large score adjustment); later on in RevisitInlinability we'll look at each individual function to demote it if needed.

func DumpFuncProps ¶

func DumpFuncProps(fn *ir.Func, dumpfile string)

DumpFuncProps computes and caches function properties for the func 'fn', writing out a description of the previously computed set of properties to the file given in 'dumpfile'. Used for the "-d=dumpinlfuncprops=..." command line flag, intended for use primarily in unit testing.

func DumpInlCallSiteScores ¶

func DumpInlCallSiteScores(profile *pgo.Profile, budgetCallback func(fn *ir.Func, profile *pgo.Profile) (int32, bool))

DumpInlCallSiteScores is invoked by the inliner if the debug flag "-d=dumpinlcallsitescores" is set; it dumps out a human-readable summary of all (potentially) inlinable callsites in the package, along with info on call site scoring and the adjustments made to a given score. Here profile is the PGO profile in use (may be nil), budgetCallback is a callback that can be invoked to find out the original pre-adjustment hairyness limit for the function, and inlineHotMaxBudget is the constant of the same name used in the inliner. Sample output lines:

Score Adjustment Status Callee CallerPos ScoreFlags 115 40 DEMOTED cmd/compile/internal/abi.(*ABIParamAssignment).Offset expand_calls.go:1679:14|6 panicPathAdj 76 -5n PROMOTED runtime.persistentalloc mcheckmark.go:48:45|3 inLoopAdj 201 0 --- PGO unicode.DecodeRuneInString utf8.go:312:30|1 7 -5 --- PGO internal/abi.Name.DataChecked type.go:625:22|0 inLoopAdj

In the dump above, "Score" is the final score calculated for the callsite, "Adjustment" is the amount added to or subtracted from the original hairyness estimate to form the score. "Status" shows whether anything changed with the site -- did the adjustment bump it down just below the threshold ("PROMOTED") or instead bump it above the threshold ("DEMOTED"); this will be blank ("---") if no threshold was crossed as a result of the heuristics. Note that "Status" also shows whether PGO was involved. "Callee" is the name of the function called, "CallerPos" is the position of the callsite, and "ScoreFlags" is a digest of the specific properties we used to make adjustments to callsite score via heuristics.

func Enabled ¶

func Enabled() bool

func EncodeCallSiteKey ¶

func EncodeCallSiteKey(cs *CallSite) string

func GetCallSiteScore ¶

func GetCallSiteScore(fn *ir.Func, call *ir.CallExpr) (int, bool)

GetCallSiteScore returns the previously calculated score for call within fn.

func LargestNegativeScoreAdjustment ¶

func LargestNegativeScoreAdjustment(fn *ir.Func, props *FuncProps) int

LargestNegativeScoreAdjustment tries to estimate the largest possible negative score adjustment that could be applied to a call of the function with the specified props. Example:

func foo() {                  func bar(x int, p *int) int {
   ...                          if x < 0 { *p = x }
}                               return 99
                              }

Function 'foo' above on the left has no interesting properties, thus as a result the most we'll adjust any call to is the value for "call in loop". If the calculated cost of the function is 150, and the in-loop adjustment is 5 (for example), then there is not much point treating it as inlinable. On the other hand "bar" has a param property (parameter "x" feeds unmodified to an "if" statement") and a return property (always returns same constant) meaning that a given call _could_ be rescored down as much as -35 points-- thus if the size of "bar" is 100 (for example) then there is at least a chance that scoring will enable inlining.

func LargestPositiveScoreAdjustment ¶

func LargestPositiveScoreAdjustment(fn *ir.Func) int

LargestPositiveScoreAdjustment tries to estimate the largest possible positive score adjustment that could be applied to a given callsite. At the moment we don't have very many positive score adjustments, so this is just hard-coded, not table-driven.

func ScoreCalls ¶

func ScoreCalls(fn *ir.Func)

ScoreCalls assigns numeric scores to each of the callsites in function 'fn'; the lower the score, the more helpful we think it will be to inline.

Unlike a lot of the other inline heuristics machinery, callsite scoring can't be done as part of the CanInline call for a function, due to fact that we may be working on a non-trivial SCC. So for example with this SCC:

func foo(x int) {           func bar(x int, f func()) {
  if x != 0 {                  f()
    bar(x, func(){})           foo(x-1)
  }                         }
}

We don't want to perform scoring for the 'foo' call in "bar" until after foo has been analyzed, but it's conceivable that CanInline might visit bar before foo for this SCC.

func ScoreCallsCleanup ¶

func ScoreCallsCleanup()

ScoreCallsCleanup resets the state of the callsite cache once ScoreCalls is done with a function.

func SetupScoreAdjustments ¶

func SetupScoreAdjustments()

SetupScoreAdjustments interprets the value of the -d=inlscoreadj debugging option, if set. The value of this flag is expected to be a series of "/"-separated clauses of the form adj1:value1. Example: -d=inlscoreadj=inLoopAdj=0/passConstToIfAdj=-99

func ShouldFoldIfNameConstant ¶

func ShouldFoldIfNameConstant(n ir.Node, names []*ir.Name) bool

ShouldFoldIfNameConstant analyzes expression tree 'e' to see whether it contains only combinations of simple references to all of the names in 'names' with selected constants + operators. The intent is to identify expression that could be folded away to a constant if the value of 'n' were available. Return value is TRUE if 'e' does look foldable given the value of 'n', and given that 'e' actually makes reference to 'n'. Some examples where the type of "n" is int64, type of "s" is string, and type of "p" is *byte:

Simple?		Expr
yes			n<10
yes			n*n-100
yes			(n < 10 || n > 100) && (n >= 12 || n <= 99 || n != 101)
yes			s == "foo"
yes			p == nil
no			n<foo()
no			n<1 || n>m
no			float32(n)<1.0
no			*p == 1
no			1 + 100
no			1 / n
no			1 + unsafe.Sizeof(n)

To avoid complexities (e.g. nan, inf) we stay way from folding and floating point or complex operations (integers, bools, and strings only). We also try to be conservative about avoiding any operation that might result in a panic at runtime, e.g. for "n" with type int64:

1<<(n-9) < 100/(n<<9999)

we would return FALSE due to the negative shift count and/or potential divide by zero.

func TearDown ¶

func TearDown()

TearDown is invoked at the end of the main inlining pass; doing function analysis and call site scoring is unlikely to help a lot after this point, so nil out fpmap and other globals to reclaim storage.

func UnitTesting ¶

func UnitTesting() bool

func UpdateCallsiteTable ¶

func UpdateCallsiteTable(callerfn *ir.Func, n *ir.CallExpr, ic *ir.InlinedCallExpr)

UpdateCallsiteTable handles updating of callerfn's call site table after an inlined has been carried out, e.g. the call at 'n' as been turned into the inlined call expression 'ic' within function callerfn. The chief thing of interest here is to make sure that any call nodes within 'ic' are added to the call site table for 'callerfn' and scored appropriately.