+++ /dev/null
-// Copyright 2015 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.
-
-// Compilebench benchmarks the speed of the Go compiler.
-//
-// Usage:
-//
-// compilebench [options]
-//
-// It times the compilation of various packages and prints results in
-// the format used by package testing (and expected by golang.org/x/perf/cmd/benchstat).
-//
-// The options are:
-//
-// -alloc
-// Report allocations.
-//
-// -compile exe
-// Use exe as the path to the cmd/compile binary.
-//
-// -compileflags 'list'
-// Pass the space-separated list of flags to the compilation.
-//
-// -link exe
-// Use exe as the path to the cmd/link binary.
-//
-// -linkflags 'list'
-// Pass the space-separated list of flags to the linker.
-//
-// -count n
-// Run each benchmark n times (default 1).
-//
-// -cpuprofile file
-// Write a CPU profile of the compiler to file.
-//
-// -go path
-// Path to "go" command (default "go").
-//
-// -memprofile file
-// Write a memory profile of the compiler to file.
-//
-// -memprofilerate rate
-// Set runtime.MemProfileRate during compilation.
-//
-// -obj
-// Report object file statistics.
-//
-// -pkg pkg
-// Benchmark compiling a single package.
-//
-// -run regexp
-// Only run benchmarks with names matching regexp.
-//
-// -short
-// Skip long-running benchmarks.
-//
-// Although -cpuprofile and -memprofile are intended to write a
-// combined profile for all the executed benchmarks to file,
-// today they write only the profile for the last benchmark executed.
-//
-// The default memory profiling rate is one profile sample per 512 kB
-// allocated (see ``go doc runtime.MemProfileRate'').
-// Lowering the rate (for example, -memprofilerate 64000) produces
-// a more fine-grained and therefore accurate profile, but it also incurs
-// execution cost. For benchmark comparisons, never use timings
-// obtained with a low -memprofilerate option.
-//
-// Example
-//
-// Assuming the base version of the compiler has been saved with
-// ``toolstash save,'' this sequence compares the old and new compiler:
-//
-// compilebench -count 10 -compile $(toolstash -n compile) >old.txt
-// compilebench -count 10 >new.txt
-// benchstat old.txt new.txt
-//
-package main
-
-import (
- "bytes"
- "encoding/json"
- "flag"
- "fmt"
- "io/ioutil"
- "log"
- "os"
- "os/exec"
- "path/filepath"
- "regexp"
- "strconv"
- "strings"
- "time"
-)
-
-var (
- goroot string
- compiler string
- linker string
- runRE *regexp.Regexp
- is6g bool
-)
-
-var (
- flagGoCmd = flag.String("go", "go", "path to \"go\" command")
- flagAlloc = flag.Bool("alloc", false, "report allocations")
- flagObj = flag.Bool("obj", false, "report object file stats")
- flagCompiler = flag.String("compile", "", "use `exe` as the cmd/compile binary")
- flagCompilerFlags = flag.String("compileflags", "", "additional `flags` to pass to compile")
- flagLinker = flag.String("link", "", "use `exe` as the cmd/link binary")
- flagLinkerFlags = flag.String("linkflags", "", "additional `flags` to pass to link")
- flagRun = flag.String("run", "", "run benchmarks matching `regexp`")
- flagCount = flag.Int("count", 1, "run benchmarks `n` times")
- flagCpuprofile = flag.String("cpuprofile", "", "write CPU profile to `file`")
- flagMemprofile = flag.String("memprofile", "", "write memory profile to `file`")
- flagMemprofilerate = flag.Int64("memprofilerate", -1, "set memory profile `rate`")
- flagPackage = flag.String("pkg", "", "if set, benchmark the package at path `pkg`")
- flagShort = flag.Bool("short", false, "skip long-running benchmarks")
-)
-
-type test struct {
- name string
- r runner
-}
-
-type runner interface {
- long() bool
- run(name string, count int) error
-}
-
-var tests = []test{
- {"BenchmarkTemplate", compile{"html/template"}},
- {"BenchmarkUnicode", compile{"unicode"}},
- {"BenchmarkGoTypes", compile{"go/types"}},
- {"BenchmarkCompiler", compile{"cmd/compile/internal/gc"}},
- {"BenchmarkSSA", compile{"cmd/compile/internal/ssa"}},
- {"BenchmarkFlate", compile{"compress/flate"}},
- {"BenchmarkGoParser", compile{"go/parser"}},
- {"BenchmarkReflect", compile{"reflect"}},
- {"BenchmarkTar", compile{"archive/tar"}},
- {"BenchmarkXML", compile{"encoding/xml"}},
- {"BenchmarkLinkCompiler", link{"cmd/compile", ""}},
- {"BenchmarkExternalLinkCompiler", link{"cmd/compile", "-linkmode=external"}},
- {"BenchmarkLinkWithoutDebugCompiler", link{"cmd/compile", "-w"}},
- {"BenchmarkStdCmd", goBuild{[]string{"std", "cmd"}}},
- {"BenchmarkHelloSize", size{"$GOROOT/test/helloworld.go", false}},
- {"BenchmarkCmdGoSize", size{"cmd/go", true}},
-}
-
-func usage() {
- fmt.Fprintf(os.Stderr, "usage: compilebench [options]\n")
- fmt.Fprintf(os.Stderr, "options:\n")
- flag.PrintDefaults()
- os.Exit(2)
-}
-
-func main() {
- log.SetFlags(0)
- log.SetPrefix("compilebench: ")
- flag.Usage = usage
- flag.Parse()
- if flag.NArg() != 0 {
- usage()
- }
-
- s, err := exec.Command(*flagGoCmd, "env", "GOROOT").CombinedOutput()
- if err != nil {
- log.Fatalf("%s env GOROOT: %v", *flagGoCmd, err)
- }
- goroot = strings.TrimSpace(string(s))
- os.Setenv("GOROOT", goroot) // for any subcommands
-
- compiler = *flagCompiler
- if compiler == "" {
- var foundTool string
- foundTool, compiler = toolPath("compile", "6g")
- if foundTool == "6g" {
- is6g = true
- }
- }
-
- linker = *flagLinker
- if linker == "" && !is6g { // TODO: Support 6l
- _, linker = toolPath("link")
- }
-
- if is6g {
- *flagMemprofilerate = -1
- *flagAlloc = false
- *flagCpuprofile = ""
- *flagMemprofile = ""
- }
-
- if *flagRun != "" {
- r, err := regexp.Compile(*flagRun)
- if err != nil {
- log.Fatalf("invalid -run argument: %v", err)
- }
- runRE = r
- }
-
- if *flagPackage != "" {
- tests = []test{
- {"BenchmarkPkg", compile{*flagPackage}},
- {"BenchmarkPkgLink", link{*flagPackage, ""}},
- }
- runRE = nil
- }
-
- for i := 0; i < *flagCount; i++ {
- for _, tt := range tests {
- if tt.r.long() && *flagShort {
- continue
- }
- if runRE == nil || runRE.MatchString(tt.name) {
- if err := tt.r.run(tt.name, i); err != nil {
- log.Printf("%s: %v", tt.name, err)
- }
- }
- }
- }
-}
-
-func toolPath(names ...string) (found, path string) {
- var out1 []byte
- var err1 error
- for i, name := range names {
- out, err := exec.Command(*flagGoCmd, "tool", "-n", name).CombinedOutput()
- if err == nil {
- return name, strings.TrimSpace(string(out))
- }
- if i == 0 {
- out1, err1 = out, err
- }
- }
- log.Fatalf("go tool -n %s: %v\n%s", names[0], err1, out1)
- return "", ""
-}
-
-type Pkg struct {
- Dir string
- GoFiles []string
-}
-
-func goList(dir string) (*Pkg, error) {
- var pkg Pkg
- out, err := exec.Command(*flagGoCmd, "list", "-json", dir).Output()
- if err != nil {
- return nil, fmt.Errorf("go list -json %s: %v", dir, err)
- }
- if err := json.Unmarshal(out, &pkg); err != nil {
- return nil, fmt.Errorf("go list -json %s: unmarshal: %v", dir, err)
- }
- return &pkg, nil
-}
-
-func runCmd(name string, cmd *exec.Cmd) error {
- start := time.Now()
- out, err := cmd.CombinedOutput()
- if err != nil {
- return fmt.Errorf("%v\n%s", err, out)
- }
- fmt.Printf("%s 1 %d ns/op\n", name, time.Since(start).Nanoseconds())
- return nil
-}
-
-type goBuild struct{ pkgs []string }
-
-func (goBuild) long() bool { return true }
-
-func (r goBuild) run(name string, count int) error {
- args := []string{"build", "-a"}
- if *flagCompilerFlags != "" {
- args = append(args, "-gcflags", *flagCompilerFlags)
- }
- args = append(args, r.pkgs...)
- cmd := exec.Command(*flagGoCmd, args...)
- cmd.Dir = filepath.Join(goroot, "src")
- return runCmd(name, cmd)
-}
-
-type size struct {
- // path is either a path to a file ("$GOROOT/test/helloworld.go") or a package path ("cmd/go").
- path string
- isLong bool
-}
-
-func (r size) long() bool { return r.isLong }
-
-func (r size) run(name string, count int) error {
- if strings.HasPrefix(r.path, "$GOROOT/") {
- r.path = goroot + "/" + r.path[len("$GOROOT/"):]
- }
-
- cmd := exec.Command(*flagGoCmd, "build", "-o", "_compilebenchout_", r.path)
- cmd.Stdout = os.Stderr
- cmd.Stderr = os.Stderr
- if err := cmd.Run(); err != nil {
- return err
- }
- defer os.Remove("_compilebenchout_")
- info, err := os.Stat("_compilebenchout_")
- if err != nil {
- return err
- }
- out, err := exec.Command("size", "_compilebenchout_").CombinedOutput()
- if err != nil {
- return fmt.Errorf("size: %v\n%s", err, out)
- }
- lines := strings.Split(string(out), "\n")
- if len(lines) < 2 {
- return fmt.Errorf("not enough output from size: %s", out)
- }
- f := strings.Fields(lines[1])
- if strings.HasPrefix(lines[0], "__TEXT") && len(f) >= 2 { // OS X
- fmt.Printf("%s 1 %s text-bytes %s data-bytes %v exe-bytes\n", name, f[0], f[1], info.Size())
- } else if strings.Contains(lines[0], "bss") && len(f) >= 3 {
- fmt.Printf("%s 1 %s text-bytes %s data-bytes %s bss-bytes %v exe-bytes\n", name, f[0], f[1], f[2], info.Size())
- }
- return nil
-}
-
-type compile struct{ dir string }
-
-func (compile) long() bool { return false }
-
-func (c compile) run(name string, count int) error {
- // Make sure dependencies needed by go tool compile are installed to GOROOT/pkg.
- out, err := exec.Command(*flagGoCmd, "build", "-i", c.dir).CombinedOutput()
- if err != nil {
- return fmt.Errorf("go build -i %s: %v\n%s", c.dir, err, out)
- }
-
- // Find dir and source file list.
- pkg, err := goList(c.dir)
- if err != nil {
- return err
- }
-
- args := []string{"-o", "_compilebench_.o"}
- args = append(args, strings.Fields(*flagCompilerFlags)...)
- args = append(args, pkg.GoFiles...)
- if err := runBuildCmd(name, count, pkg.Dir, compiler, args); err != nil {
- return err
- }
-
- opath := pkg.Dir + "/_compilebench_.o"
- if *flagObj {
- // TODO(josharian): object files are big; just read enough to find what we seek.
- data, err := ioutil.ReadFile(opath)
- if err != nil {
- log.Print(err)
- }
- // Find start of export data.
- i := bytes.Index(data, []byte("\n$$B\n")) + len("\n$$B\n")
- // Count bytes to end of export data.
- nexport := bytes.Index(data[i:], []byte("\n$$\n"))
- fmt.Printf(" %d object-bytes %d export-bytes", len(data), nexport)
- }
- fmt.Println()
-
- os.Remove(opath)
- return nil
-}
-
-type link struct{ dir, flags string }
-
-func (link) long() bool { return false }
-
-func (r link) run(name string, count int) error {
- if linker == "" {
- // No linker. Skip the test.
- return nil
- }
-
- // Build dependencies.
- out, err := exec.Command(*flagGoCmd, "build", "-i", "-o", "/dev/null", r.dir).CombinedOutput()
- if err != nil {
- return fmt.Errorf("go build -i %s: %v\n%s", r.dir, err, out)
- }
-
- // Build the main package.
- pkg, err := goList(r.dir)
- if err != nil {
- return err
- }
- args := []string{"-o", "_compilebench_.o"}
- args = append(args, pkg.GoFiles...)
- cmd := exec.Command(compiler, args...)
- cmd.Dir = pkg.Dir
- cmd.Stdout = os.Stderr
- cmd.Stderr = os.Stderr
- err = cmd.Run()
- if err != nil {
- return fmt.Errorf("compiling: %v", err)
- }
- defer os.Remove(pkg.Dir + "/_compilebench_.o")
-
- // Link the main package.
- args = []string{"-o", "_compilebench_.exe"}
- args = append(args, strings.Fields(*flagLinkerFlags)...)
- args = append(args, strings.Fields(r.flags)...)
- args = append(args, "_compilebench_.o")
- if err := runBuildCmd(name, count, pkg.Dir, linker, args); err != nil {
- return err
- }
- fmt.Println()
- defer os.Remove(pkg.Dir + "/_compilebench_.exe")
-
- return err
-}
-
-// runBuildCmd runs "tool args..." in dir, measures standard build
-// tool metrics, and prints a benchmark line. The caller may print
-// additional metrics and then must print a newline.
-//
-// This assumes tool accepts standard build tool flags like
-// -memprofilerate, -memprofile, and -cpuprofile.
-func runBuildCmd(name string, count int, dir, tool string, args []string) error {
- var preArgs []string
- if *flagMemprofilerate >= 0 {
- preArgs = append(preArgs, "-memprofilerate", fmt.Sprint(*flagMemprofilerate))
- }
- if *flagAlloc || *flagCpuprofile != "" || *flagMemprofile != "" {
- if *flagAlloc || *flagMemprofile != "" {
- preArgs = append(preArgs, "-memprofile", "_compilebench_.memprof")
- }
- if *flagCpuprofile != "" {
- preArgs = append(preArgs, "-cpuprofile", "_compilebench_.cpuprof")
- }
- }
- cmd := exec.Command(tool, append(preArgs, args...)...)
- cmd.Dir = dir
- cmd.Stdout = os.Stderr
- cmd.Stderr = os.Stderr
- start := time.Now()
- err := cmd.Run()
- if err != nil {
- return err
- }
- end := time.Now()
-
- haveAllocs, haveRSS := false, false
- var allocs, allocbytes, rssbytes int64
- if *flagAlloc || *flagMemprofile != "" {
- out, err := ioutil.ReadFile(dir + "/_compilebench_.memprof")
- if err != nil {
- log.Print("cannot find memory profile after compilation")
- }
- for _, line := range strings.Split(string(out), "\n") {
- f := strings.Fields(line)
- if len(f) < 4 || f[0] != "#" || f[2] != "=" {
- continue
- }
- val, err := strconv.ParseInt(f[3], 0, 64)
- if err != nil {
- continue
- }
- haveAllocs = true
- switch f[1] {
- case "TotalAlloc":
- allocbytes = val
- case "Mallocs":
- allocs = val
- case "MaxRSS":
- haveRSS = true
- rssbytes = val
- }
- }
- if !haveAllocs {
- log.Println("missing stats in memprof (golang.org/issue/18641)")
- }
-
- if *flagMemprofile != "" {
- outpath := *flagMemprofile
- if *flagCount != 1 {
- outpath = fmt.Sprintf("%s_%d", outpath, count)
- }
- if err := ioutil.WriteFile(outpath, out, 0666); err != nil {
- log.Print(err)
- }
- }
- os.Remove(dir + "/_compilebench_.memprof")
- }
-
- if *flagCpuprofile != "" {
- out, err := ioutil.ReadFile(dir + "/_compilebench_.cpuprof")
- if err != nil {
- log.Print(err)
- }
- outpath := *flagCpuprofile
- if *flagCount != 1 {
- outpath = fmt.Sprintf("%s_%d", outpath, count)
- }
- if err := ioutil.WriteFile(outpath, out, 0666); err != nil {
- log.Print(err)
- }
- os.Remove(dir + "/_compilebench_.cpuprof")
- }
-
- wallns := end.Sub(start).Nanoseconds()
- userns := cmd.ProcessState.UserTime().Nanoseconds()
-
- fmt.Printf("%s 1 %d ns/op %d user-ns/op", name, wallns, userns)
- if haveAllocs {
- fmt.Printf(" %d B/op %d allocs/op", allocbytes, allocs)
- }
- if haveRSS {
- fmt.Printf(" %d maxRSS/op", rssbytes)
- }
-
- return nil
-}
projects / dotfiles / .git / blobdiff