Skip to content

G
go
Commit a0894ea5 authored by Matthew Dempsky's avatar Matthew Dempsky
Browse files
Options

cmd/compile: reimplement parameter leak encoding 

Currently, escape analysis is able to record at most one dereference
when a parameter leaks to the heap; that is, at call sites, it can't
distinguish between any of these three functions:

    func x1(p ****int) { sink = *p }
    func x2(p ****int) { sink = **p }
    func x3(p ****int) { sink = ***p }

Similarly, it's limited to recording parameter leaks to only the first
4 parameters, and only up to 6 dereferences.

All of these limitations are due to the awkward encoding scheme used
at the moment.

This CL replaces the encoding scheme with a simple [8]uint8 array,
which can handle up to the first 7 parameters, and up to 254
dereferences, which ought to be enough for anyone. And if not, it's
much more easily increased.

Shrinks export data size geometric mean for Kubernetes by 0.07%.

Fixes #33981.

Change-Id: I10a94b9accac9a0c91490e0d6d458316f5ca1e13
Reviewed-on: https://go-review.googlesource.com/c/go/+/197680Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
parent 05a805a6
Show whitespace changes
Inline Side-by-side
Showing with 67 additions and 157 deletions
src/cmd/compile/internal/gc/esc.go
View file @ a0894ea5
......@@ -7,8 +7,6 @@ package gc
import (
"cmd/compile/internal/types"
"fmt"
"strconv"
"strings"
)
func escapes(all []*Node) {
......@@ -36,32 +34,11 @@ func max8(a, b int8) int8 {
return b
}
// Escape constants are numbered in order of increasing "escapiness"
// to help make inferences be monotonic. With the exception of
// EscNever which is sticky, eX < eY means that eY is more exposed
// than eX, and hence replaces it in a conservative analysis.
const (
EscUnknown = iota
EscNone // Does not escape to heap, result, or parameters.
EscReturn // Is returned or reachable from returned.
EscHeap // Reachable from the heap
EscNever // By construction will not escape.
EscBits = 3
EscMask = (1 << EscBits) - 1
EscContentEscapes = 1 << EscBits // value obtained by indirect of parameter escapes to heap
EscReturnBits = EscBits + 1
// Node.esc encoding = | escapeReturnEncoding:(width-4) | contentEscapes:1 | escEnum:3
)
// For each input parameter to a function, the escapeReturnEncoding describes
// how the parameter may leak to the function's outputs. This is currently the
// "level" of the leak where level is 0 or larger (negative level means stored into
// something whose address is returned -- but that implies stored into the heap,
// hence EscHeap, which means that the details are not currently relevant. )
const (
bitsPerOutputInTag = 3 // For each output, the number of bits for a tag
bitsMaskForTag = EscLeaks(1<<bitsPerOutputInTag) - 1 // The bit mask to extract a single tag.
maxEncodedLevel = int(bitsMaskForTag - 1) // The largest level that can be stored in a tag.
)
// funcSym returns fn.Func.Nname.Sym if no nils are encountered along the way.
......@@ -200,49 +177,6 @@ func mustHeapAlloc(n *Node) bool {
n.Op == OMAKESLICE && !isSmallMakeSlice(n))
}
// Common case for escapes is 16 bits 000000000xxxEEEE
// where commonest cases for xxx encoding in-to-out pointer
// flow are 000, 001, 010, 011 and EEEE is computed Esc bits.
// Note width of xxx depends on value of constant
// bitsPerOutputInTag -- expect 2 or 3, so in practice the
// tag cache array is 64 or 128 long. Some entries will
// never be populated.
var tags [1 << (bitsPerOutputInTag + EscReturnBits)]string
// mktag returns the string representation for an escape analysis tag.
func mktag(mask EscLeaks) string {
switch mask & EscMask {
case EscHeap:
return ""
case EscNone, EscReturn:
default:
Fatalf("escape mktag")
}
if int(mask) < len(tags) && tags[mask] != "" {
return tags[mask]
}
s := fmt.Sprintf("esc:0x%x", mask)
if int(mask) < len(tags) {
tags[mask] = s
}
return s
}
// parsetag decodes an escape analysis tag and returns the esc value.
func parsetag(note string) EscLeaks {
if !strings.HasPrefix(note, "esc:") {
return EscUnknown
}
n, _ := strconv.ParseInt(note[4:], 0, 0)
em := EscLeaks(n)
if em == 0 {
return EscNone
}
return em
}
// addrescapes tags node n as having had its address taken
// by "increasing" the "value" of n.Esc to EscHeap.
// Storage is allocated as necessary to allow the address
......@@ -481,7 +415,9 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
esc.Optimize()
if Debug['m'] != 0 && !loc.escapes {
leaks := false
if esc.Empty() {
Warnl(f.Pos, "%v does not escape", name())
}
if x := esc.Heap(); x >= 0 {
if x == 0 {
Warnl(f.Pos, "leaking param: %v", name())
......@@ -489,18 +425,13 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
// TODO(mdempsky): Mention level=x like below?
Warnl(f.Pos, "leaking param content: %v", name())
}
leaks = true
}
for i := 0; i < numEscResults; i++ {
if x := esc.Result(i); x >= 0 {
res := fn.Type.Results().Field(i).Sym
Warnl(f.Pos, "leaking param: %v to result %v level=%d", name(), res, x)
leaks = true
}
}
if !leaks {
Warnl(f.Pos, "%v does not escape", name())
}
}
return esc.Encode()
......
src/cmd/compile/internal/gc/escape.go
View file @ a0894ea5
......@@ -7,6 +7,8 @@ package gc
import (
"cmd/compile/internal/types"
"fmt"
"math"
"strings"
)
// Escape analysis.
......@@ -169,11 +171,7 @@ func (e *Escape) initFunc(fn *Node) {
// Allocate locations for local variables.
for _, dcl := range fn.Func.Dcl {
if dcl.Op == ONAME {
loc := e.newLoc(dcl, false)
if dcl.Class() == PPARAM && fn.Nbody.Len() == 0 && !fn.Noescape() {
loc.paramEsc = EscHeap
}
e.newLoc(dcl, false)
}
}
}
......@@ -1305,88 +1303,56 @@ func (l *EscLocation) isName(c Class) bool {
return l.n != nil && l.n.Op == ONAME && l.n.Class() == c
}
// Parameter tags.
//
// The escape bits saved for each analyzed parameter record the
// minimal derefs (if any) from that parameter to the heap, or to any
// of its function's (first numEscResults) result parameters.
//
// Paths to the heap are encoded via EscHeap (length 0) or
// EscContentEscapes (length 1); if neither of these are set, then
// there's no path to the heap.
//
// Paths to the result parameters are encoded in the upper
// bits.
//
// There are other values stored in the escape bits by esc.go for
// vestigial reasons, and other special tag values used (e.g.,
// uintptrEscapesTag and unsafeUintptrTag). These could be simplified
// once compatibility with esc.go is no longer a concern.
const numEscResults = 7
const numEscResults = (16 - EscReturnBits) / bitsPerOutputInTag
// An EscLeaks represents a set of assignment flows from a parameter
// to the heap or to any of its function's (first numEscResults)
// result parameters.
type EscLeaks [1 + numEscResults]uint8
// An EscLeaks records the minimal deref count for assignment flows
// from a parameter to the heap or to any of its function's (first
// numEscResults) result parameters. If no assignment flow exists,
// that respective count is reported as -1.
type EscLeaks uint16
// Empty reports whether l is an empty set (i.e., no assignment flows).
func (l EscLeaks) Empty() bool { return l == EscLeaks{} }
func (l EscLeaks) Heap() int {
if l == EscHeap {
return 0
}
if l&EscContentEscapes != 0 {
return 1
}
return -1
}
// Heap returns the minimum deref count of any assignment flow from l
// to the heap. If no such flows exist, Heap returns -1.
func (l EscLeaks) Heap() int { return l.get(0) }
func (l *EscLeaks) AddHeap(derefs int) {
if *l == EscHeap {
return // already leaks to heap
}
// Result returns the minimum deref count of any assignment flow from
// l to its function's i'th result parameter. If no such flows exist,
// Result returns -1.
func (l EscLeaks) Result(i int) int { return l.get(1 + i) }
if derefs > 0 {
*l |= EscContentEscapes
} else {
*l = EscHeap
}
}
// AddHeap adds an assignment flow from l to the heap.
func (l *EscLeaks) AddHeap(derefs int) { l.add(0, derefs) }
func (l EscLeaks) Result(i int) int {
return int((l>>escReturnShift(i))&bitsMaskForTag) - 1
}
// AddResult adds an assignment flow from l to its function's i'th
// result parameter.
func (l *EscLeaks) AddResult(i, derefs int) { l.add(1+i, derefs) }
func (l *EscLeaks) AddResult(i, derefs int) {
if *l == EscHeap {
return // already leaks to heap
}
func (l *EscLeaks) setResult(i, derefs int) { l.set(1+i, derefs) }
if old := l.Result(i); old < 0 || derefs < old {
l.setResult(i, derefs)
func (l EscLeaks) get(i int) int { return int(l[i]) - 1 }
func (l *EscLeaks) add(i, derefs int) {
if old := l.get(i); old < 0 || derefs < old {
l.set(i, derefs)
}
}
func (l *EscLeaks) setResult(i, derefs int) {
if derefs < -1 {
func (l *EscLeaks) set(i, derefs int) {
v := derefs + 1
if v < 0 {
Fatalf("invalid derefs count: %v", derefs)
}
if derefs > maxEncodedLevel {
derefs = maxEncodedLevel
if v > math.MaxUint8 {
v = math.MaxUint8
}
shift := escReturnShift(i)
*l &^= bitsMaskForTag << shift
*l |= EscLeaks(derefs+1) << shift
}
func escReturnShift(i int) uint {
if uint(i) >= numEscResults {
Fatalf("esc return index out of bounds: %v", i)
}
return uint(EscReturnBits + i*bitsPerOutputInTag)
l[i] = uint8(v)
}
// Optimize removes result flow paths that are equal in length or
// longer than the shortest heap flow path.
func (l *EscLeaks) Optimize() {
// If we have a path to the heap, then there's no use in
// keeping equal or longer paths elsewhere.
......@@ -1399,22 +1365,35 @@ func (l *EscLeaks) Optimize() {
}
}
var leakTagCache = map[EscLeaks]string{}
// Encode converts l into a binary string for export data.
func (l EscLeaks) Encode() string {
if l&EscMask == 0 {
if l>>EscReturnBits != 0 {
l |= EscReturn
} else {
l |= EscNone
if l.Heap() == 0 {
// Space optimization: empty string encodes more
// efficiently in export data.
return ""
}
if s, ok := leakTagCache[l]; ok {
return s
}
return mktag(l)
n := len(l)
for n > 0 && l[n-1] == 0 {
n--
}
s := "esc:" + string(l[:n])
leakTagCache[l] = s
return s
}
// ParseLeaks parses a binary string representing an EscLeaks.
func ParseLeaks(s string) EscLeaks {
l := parsetag(s)
if l == EscUnknown {
return EscHeap
var l EscLeaks
if !strings.HasPrefix(s, "esc:") {
l.AddHeap(0)
return l
}
copy(l[:], s[4:])
return l
}
test/escape_param.go
View file @ a0894ea5
......@@ -205,7 +205,7 @@ func param7(i ***int) { // ERROR "leaking param content: i$"
func caller7() {
i := 0 // ERROR "moved to heap: i$"
p := &i // ERROR "moved to heap: p$"
p := &i
p2 := &p
param7(&p2)
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7