src/cmd/compile/internal/inline/inlheur/callsite.go

   1 // Copyright 2023 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package inlheur
   6
   7 import (
   8         "cmd/compile/internal/base"
   9         "cmd/compile/internal/ir"
  10         "cmd/internal/src"
  11         "fmt"
  12         "io"
  13         "path/filepath"
  14         "sort"
  15         "strings"
  16 )
  17
  18 // CallSite records useful information about a potentially inlinable
  19 // (direct) function call. "Callee" is the target of the call, "Call"
  20 // is the ir node corresponding to the call itself, "Assign" is
  21 // the top-level assignment statement containing the call (if the call
  22 // appears in the form of a top-level statement, e.g. "x := foo()"),
  23 // "Flags" contains properties of the call that might be useful for
  24 // making inlining decisions, "Score" is the final score assigned to
  25 // the site, and "ID" is a numeric ID for the site within its
  26 // containing function.
  27 type CallSite struct {
  28         Callee    *ir.Func
  29         Call      *ir.CallExpr
  30         Assign    ir.Node
  31         Flags     CSPropBits
  32         Score     int
  33         ScoreMask scoreAdjustTyp
  34         ID        uint
  35 }
  36
  37 // CallSiteTab is a table of call sites, keyed by call expr.
  38 // Ideally it would be nice to key the table by src.XPos, but
  39 // this results in collisions for calls on very long lines (the
  40 // front end saturates column numbers at 255). We also wind up
  41 // with many calls that share the same auto-generated pos.
  42 type CallSiteTab map[*ir.CallExpr]*CallSite
  43
  44 // Package-level table of callsites.
  45 var cstab = CallSiteTab{}
  46
  47 func GetCallSiteScore(ce *ir.CallExpr) (bool, int) {
  48         cs, ok := cstab[ce]
  49         if !ok {
  50                 return false, 0
  51         }
  52         return true, cs.Score
  53 }
  54
  55 func CallSiteTable() CallSiteTab {
  56         return cstab
  57 }
  58
  59 type CSPropBits uint32
  60
  61 const (
  62         CallSiteInLoop CSPropBits = 1 << iota
  63         CallSiteOnPanicPath
  64         CallSiteInInitFunc
  65 )
  66
  67 // encodedCallSiteTab is a table keyed by "encoded" callsite
  68 // (stringified src.XPos plus call site ID) mapping to a value of call
  69 // property bits and score.
  70 type encodedCallSiteTab map[string]propsAndScore
  71
  72 type propsAndScore struct {
  73         props CSPropBits
  74         score int
  75         mask  scoreAdjustTyp
  76 }
  77
  78 func (pas propsAndScore) String() string {
  79         return fmt.Sprintf("P=%s|S=%d|M=%s", pas.props.String(),
  80                 pas.score, pas.mask.String())
  81 }
  82
  83 func (cst CallSiteTab) merge(other CallSiteTab) error {
  84         for k, v := range other {
  85                 if prev, ok := cst[k]; ok {
  86                         return fmt.Errorf("internal error: collision during call site table merge, fn=%s callsite=%s", prev.Callee.Sym().Name, fmtFullPos(prev.Call.Pos()))
  87                 }
  88                 cst[k] = v
  89         }
  90         return nil
  91 }
  92
  93 func fmtFullPos(p src.XPos) string {
  94         var sb strings.Builder
  95         sep := ""
  96         base.Ctxt.AllPos(p, func(pos src.Pos) {
  97                 fmt.Fprintf(&sb, sep)
  98                 sep = "|"
  99                 file := filepath.Base(pos.Filename())
 100                 fmt.Fprintf(&sb, "%s:%d:%d", file, pos.Line(), pos.Col())
 101         })
 102         return sb.String()
 103 }
 104
 105 func EncodeCallSiteKey(cs *CallSite) string {
 106         var sb strings.Builder
 107         // FIXME: maybe rewrite line offsets relative to function start?
 108         sb.WriteString(fmtFullPos(cs.Call.Pos()))
 109         fmt.Fprintf(&sb, "|%d", cs.ID)
 110         return sb.String()
 111 }
 112
 113 func buildEncodedCallSiteTab(tab CallSiteTab) encodedCallSiteTab {
 114         r := make(encodedCallSiteTab)
 115         for _, cs := range tab {
 116                 k := EncodeCallSiteKey(cs)
 117                 r[k] = propsAndScore{
 118                         props: cs.Flags,
 119                         score: cs.Score,
 120                         mask:  cs.ScoreMask,
 121                 }
 122         }
 123         return r
 124 }
 125
 126 // dumpCallSiteComments emits comments into the dump file for the
 127 // callsites in the function of interest. If "ecst" is non-nil, we use
 128 // that, otherwise generated a fresh encodedCallSiteTab from "tab".
 129 func dumpCallSiteComments(w io.Writer, tab CallSiteTab, ecst encodedCallSiteTab) {
 130         if ecst == nil {
 131                 ecst = buildEncodedCallSiteTab(tab)
 132         }
 133         tags := make([]string, 0, len(ecst))
 134         for k := range ecst {
 135                 tags = append(tags, k)
 136         }
 137         sort.Strings(tags)
 138         for _, s := range tags {
 139                 v := ecst[s]
 140                 fmt.Fprintf(w, "// callsite: %s flagstr %q flagval %d score %d mask %d maskstr %q\n", s, v.props.String(), v.props, v.score, v.mask, v.mask.String())
 141         }
 142         fmt.Fprintf(w, "// %s\n", csDelimiter)
 143 }