Add pgo inline test case

Author: jinlin-bayarea

api/go1.19.txt

@@ -244,6 +244,13 @@ pkg net/url, type URL struct, OmitHost bool #46059
 pkg os/exec, method (*Cmd) Environ() []string #50599
 pkg os/exec, type Cmd struct, Err error #43724
 pkg os/exec, var ErrDot error #43724
+pkg pgo/inline, func A() #43724
+pkg pgo/inline, func D(uint) int #43724
+pkg pgo/inline, func N(uint) *BS #43724
+pkg pgo/inline, func T(uint64) uint #43724
+pkg pgo/inline, method (*BS) NS(uint) (uint, bool) #43724
+pkg pgo/inline, method (*BS) S(uint) *BS #43724
+pkg pgo/inline, type BS struct #43724
 pkg regexp/syntax, const ErrNestingDepth = "expression nests too deeply" #51684
 pkg regexp/syntax, const ErrNestingDepth ErrorCode #51684
 pkg runtime/debug, func SetMemoryLimit(int64) int64 #48409

src/cmd/compile/internal/inline/inl.go

@@ -951,7 +951,7 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlCalls *[]*ir.Inlin
 	if _, ok := inlinedCallSites[pgo.CallSiteInfo{ir.Line(n), ir.CurFunc}]; !ok {
 		inlinedCallSites[pgo.CallSiteInfo{ir.Line(n), ir.CurFunc}] = struct{}{}
 	}
-	if base.Flag.LowerM != 0 {
+	if base.Flag.LowerM > 2 {
 		fmt.Printf("Line %v: is definitely inlined\n", ir.Line(n))
 	}
 

src/cmd/compile/internal/test/pgo_inl_test.go

@@ -0,0 +1,154 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package test
+
+import (
+	"bufio"
+	"bytes"
+	"internal/testenv"
+	"io"
+	"io/ioutil"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// TestIntendedInlining tests that specific functions are inlined.
+// This allows refactoring for code clarity and re-use without fear that
+// changes to the compiler will cause silent performance regressions.
+func TestPGOIntendedInlining(t *testing.T) {
+	testenv.MustHaveGoRun(t)
+	t.Parallel()
+
+	// Make a temporary directory to work in.
+	tmpdir, err := ioutil.TempDir("", "TestCode")
+	if err != nil {
+		t.Fatalf("Failed to create temporary directory: %v", err)
+	}
+	//defer os.RemoveAll(tmpdir)
+
+	want := map[string][]string{
+		"pgo/inline": {
+			"(*BS).NS",
+		},
+	}
+
+	// The functions which are not expected to be inlined are as follows.
+	wantNot := map[string][]string{
+		"pgo/inline": {
+			// The calling edge main->A is hot and the cost of A is large than
+			// inlineHotCalleeMaxBudget.
+			"A",
+			// The calling edge BenchmarkA" -> benchmarkB is cold
+			// and the cost of A is large than inlineMaxBudget.
+			"benchmarkB",
+		},
+	}
+
+	must := map[string]bool{
+		"(*BS).NS": true,
+	}
+
+	notInlinedReason := make(map[string]string)
+	pkgs := make([]string, 0, len(want))
+	for pname, fnames := range want {
+		pkgs = append(pkgs, pname)
+		for _, fname := range fnames {
+			fullName := pname + "." + fname
+			if _, ok := notInlinedReason[fullName]; ok {
+				t.Errorf("duplicate func: %s", fullName)
+			}
+			notInlinedReason[fullName] = "unknown reason"
+		}
+	}
+
+	// If the compiler emit "cannot inline for function A", the entry A
+	// in expectedNotInlinedList will be removed.
+	expectedNotInlinedList := make(map[string]struct{})
+	for pname, fnames := range wantNot {
+		for _, fname := range fnames {
+			fullName := pname + "." + fname
+			expectedNotInlinedList[fullName] = struct{}{}
+		}
+	}
+
+	args := append([]string{"test", "-o", filepath.Join(tmpdir, "inline_hot.test"), "-bench=.", "-cpuprofile", filepath.Join(tmpdir, "inline_hot.pprof")}, pkgs...)
+	gotool := testenv.GoToolPath(t)
+	cmd := exec.Command(gotool, args...)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err = cmd.Run()
+	if err != nil {
+		t.Fatalf("Failed: %v:\nOut: %s\nStderr: %s\n", err, &stdout, &stderr)
+	}
+
+	args = append([]string{"test", "-run=nope", "-tags=", "-timeout=9m0s", "-gcflags=-m -m -profileuse " + filepath.Join(tmpdir, "inline_hot.pprof")}, pkgs...)
+	cmd = testenv.CleanCmdEnv(exec.Command(testenv.GoToolPath(t), args...))
+
+	pr, pw := io.Pipe()
+	cmd.Stdout = pw
+	cmd.Stderr = pw
+	cmdErr := make(chan error, 1)
+	go func() {
+		cmdErr <- cmd.Run()
+		pw.Close()
+	}()
+	scanner := bufio.NewScanner(pr)
+	curPkg := ""
+	canInline := regexp.MustCompile(`: can inline ([^ ]*)`)
+	haveInlined := regexp.MustCompile(`: inlining call to ([^ ]*)`)
+	cannotInline := regexp.MustCompile(`: cannot inline ([^ ]*): (.*)`)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "# ") {
+			curPkg = line[2:]
+			splits := strings.Split(curPkg, " ")
+			curPkg = splits[0]
+			continue
+		}
+		if m := haveInlined.FindStringSubmatch(line); m != nil {
+			fname := m[1]
+			delete(notInlinedReason, curPkg+"."+fname)
+			continue
+		}
+		if m := canInline.FindStringSubmatch(line); m != nil {
+			fname := m[1]
+			fullname := curPkg + "." + fname
+			// If function must be inlined somewhere, being inlinable is not enough
+			if _, ok := must[fullname]; !ok {
+				delete(notInlinedReason, fullname)
+				continue
+			}
+		}
+		if m := cannotInline.FindStringSubmatch(line); m != nil {
+			fname, reason := m[1], m[2]
+			fullName := curPkg + "." + fname
+			if _, ok := notInlinedReason[fullName]; ok {
+				// cmd/compile gave us a reason why
+				notInlinedReason[fullName] = reason
+			}
+			delete(expectedNotInlinedList, fullName)
+			continue
+		}
+	}
+	if err := <-cmdErr; err != nil {
+		t.Fatal(err)
+	}
+	if err := scanner.Err(); err != nil {
+		t.Fatal(err)
+	}
+	for fullName, reason := range notInlinedReason {
+		t.Errorf("%s was not inlined: %s", fullName, reason)
+	}
+
+	// If the list expectedNotInlinedList is not empty, it indicates
+	// the functions in the expectedNotInlinedList are marked with caninline.
+	for fullName, _ := range expectedNotInlinedList {
+		t.Errorf("%s was expected not inlined", fullName)
+	}
+}

src/pgo/inline/inline_hot.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"time"
+)
+
+type BS struct {
+	length uint
+	s    []uint64
+}
+
+const wSize = uint(64)
+const lWSize = uint(6)
+
+func D(i uint) int {
+	return int((i + (wSize - 1)) >> lWSize)
+}
+
+func N(length uint) (bs *BS) {
+	bs = &BS{
+		length,
+		make([]uint64, D(length)),
+	}
+
+	return bs
+}
+
+func (b *BS) S(i uint) *BS {
+	b.s[i>>lWSize] |= 1 << (i & (wSize - 1))
+	return b
+}
+
+var jn = [...]byte{
+	0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4,
+	62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5,
+	63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11,
+	54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6,
+}
+
+func T(v uint64) uint {
+	return uint(jn[((v&-v)*0x03f79d71b4ca8b09)>>58])
+}
+
+func (b *BS) NS(i uint) (uint, bool) {
+	x := int(i >> lWSize)
+	if x >= len(b.s) {
+		return 0, false
+	}
+	w := b.s[x]
+	w = w >> (i & (wSize - 1))
+	if w != 0 {
+		return i + T(w), true
+	}
+	x = x + 1
+	for x < len(b.s) {
+		if b.s[x] != 0 {
+			return uint(x)*wSize + T(b.s[x]), true
+		}
+		x = x + 1
+
+	}
+	return 0, false
+}
+
+func A() {
+	s := N(100000)
+	for i := 0; i < 1000; i += 30 {
+		s.S(uint(i))
+	}
+	for j := 0; j < 1000; j++ {
+		c := uint(0)
+		for i, e := s.NS(0); e; i, e = s.NS(i + 1) {
+			c++
+		}
+	}
+}
+
+func main() {
+	time.Sleep(time.Second)
+	A()
+}

src/pgo/inline/inline_hot_test.go

@@ -0,0 +1,42 @@
+package main
+
+import "testing"
+
+func BenchmarkA(b *testing.B) {
+	benchmarkB(b)
+}
+func benchmarkB(b *testing.B) {
+
+	for i := 0; true; {
+		A()
+		i = i + 1
+		if i >= b.N {
+			break
+		}
+		A()
+		i = i + 1
+		if i >= b.N {
+			break
+		}
+		A()
+		i = i + 1
+		if i >= b.N {
+			break
+		}
+		A()
+		i = i + 1
+		if i >= b.N {
+			break
+		}
+		A()
+		i = i + 1
+		if i >= b.N {
+			break
+		}
+		A()
+		i = i + 1
+		if i >= b.N {
+			break
+		}
+	}
+}