Add generated file

This PR adds generated files under pkg/client and vendor folder.

vendor/golang.org/x/tools/cmd/benchcmp/benchcmp.go

@@ -0,0 +1,184 @@
+// Copyright 2014 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 main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"text/tabwriter"
+
+	"golang.org/x/tools/benchmark/parse"
+)
+
+var (
+	changedOnly = flag.Bool("changed", false, "show only benchmarks that have changed")
+	magSort     = flag.Bool("mag", false, "sort benchmarks by magnitude of change")
+	best        = flag.Bool("best", false, "compare best times from old and new")
+)
+
+const usageFooter = `
+Each input file should be from:
+	go test -run=NONE -bench=. > [old,new].txt
+
+Benchcmp compares old and new for each benchmark.
+
+If -test.benchmem=true is added to the "go test" command
+benchcmp will also compare memory allocations.
+`
+
+func main() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "usage: %s old.txt new.txt\n\n", os.Args[0])
+		flag.PrintDefaults()
+		fmt.Fprint(os.Stderr, usageFooter)
+		os.Exit(2)
+	}
+	flag.Parse()
+	if flag.NArg() != 2 {
+		flag.Usage()
+	}
+
+	before := parseFile(flag.Arg(0))
+	after := parseFile(flag.Arg(1))
+
+	cmps, warnings := Correlate(before, after)
+
+	for _, warn := range warnings {
+		fmt.Fprintln(os.Stderr, warn)
+	}
+
+	if len(cmps) == 0 {
+		fatal("benchcmp: no repeated benchmarks")
+	}
+
+	w := new(tabwriter.Writer)
+	w.Init(os.Stdout, 0, 0, 5, ' ', 0)
+	defer w.Flush()
+
+	var header bool // Has the header has been displayed yet for a given block?
+
+	if *magSort {
+		sort.Sort(ByDeltaNsPerOp(cmps))
+	} else {
+		sort.Sort(ByParseOrder(cmps))
+	}
+	for _, cmp := range cmps {
+		if !cmp.Measured(parse.NsPerOp) {
+			continue
+		}
+		if delta := cmp.DeltaNsPerOp(); !*changedOnly || delta.Changed() {
+			if !header {
+				fmt.Fprint(w, "benchmark\told ns/op\tnew ns/op\tdelta\n")
+				header = true
+			}
+			fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", cmp.Name(), formatNs(cmp.Before.NsPerOp), formatNs(cmp.After.NsPerOp), delta.Percent())
+		}
+	}
+
+	header = false
+	if *magSort {
+		sort.Sort(ByDeltaMBPerS(cmps))
+	}
+	for _, cmp := range cmps {
+		if !cmp.Measured(parse.MBPerS) {
+			continue
+		}
+		if delta := cmp.DeltaMBPerS(); !*changedOnly || delta.Changed() {
+			if !header {
+				fmt.Fprint(w, "\nbenchmark\told MB/s\tnew MB/s\tspeedup\n")
+				header = true
+			}
+			fmt.Fprintf(w, "%s\t%.2f\t%.2f\t%s\n", cmp.Name(), cmp.Before.MBPerS, cmp.After.MBPerS, delta.Multiple())
+		}
+	}
+
+	header = false
+	if *magSort {
+		sort.Sort(ByDeltaAllocsPerOp(cmps))
+	}
+	for _, cmp := range cmps {
+		if !cmp.Measured(parse.AllocsPerOp) {
+			continue
+		}
+		if delta := cmp.DeltaAllocsPerOp(); !*changedOnly || delta.Changed() {
+			if !header {
+				fmt.Fprint(w, "\nbenchmark\told allocs\tnew allocs\tdelta\n")
+				header = true
+			}
+			fmt.Fprintf(w, "%s\t%d\t%d\t%s\n", cmp.Name(), cmp.Before.AllocsPerOp, cmp.After.AllocsPerOp, delta.Percent())
+		}
+	}
+
+	header = false
+	if *magSort {
+		sort.Sort(ByDeltaAllocedBytesPerOp(cmps))
+	}
+	for _, cmp := range cmps {
+		if !cmp.Measured(parse.AllocedBytesPerOp) {
+			continue
+		}
+		if delta := cmp.DeltaAllocedBytesPerOp(); !*changedOnly || delta.Changed() {
+			if !header {
+				fmt.Fprint(w, "\nbenchmark\told bytes\tnew bytes\tdelta\n")
+				header = true
+			}
+			fmt.Fprintf(w, "%s\t%d\t%d\t%s\n", cmp.Name(), cmp.Before.AllocedBytesPerOp, cmp.After.AllocedBytesPerOp, cmp.DeltaAllocedBytesPerOp().Percent())
+		}
+	}
+}
+
+func fatal(msg interface{}) {
+	fmt.Fprintln(os.Stderr, msg)
+	os.Exit(1)
+}
+
+func parseFile(path string) parse.Set {
+	f, err := os.Open(path)
+	if err != nil {
+		fatal(err)
+	}
+	defer f.Close()
+	bb, err := parse.ParseSet(f)
+	if err != nil {
+		fatal(err)
+	}
+	if *best {
+		selectBest(bb)
+	}
+	return bb
+}
+
+func selectBest(bs parse.Set) {
+	for name, bb := range bs {
+		if len(bb) < 2 {
+			continue
+		}
+		ord := bb[0].Ord
+		best := bb[0]
+		for _, b := range bb {
+			if b.NsPerOp < best.NsPerOp {
+				b.Ord = ord
+				best = b
+			}
+		}
+		bs[name] = []*parse.Benchmark{best}
+	}
+}
+
+// formatNs formats ns measurements to expose a useful amount of
+// precision. It mirrors the ns precision logic of testing.B.
+func formatNs(ns float64) string {
+	prec := 0
+	switch {
+	case ns < 10:
+		prec = 2
+	case ns < 100:
+		prec = 1
+	}
+	return strconv.FormatFloat(ns, 'f', prec, 64)
+}

vendor/golang.org/x/tools/cmd/benchcmp/benchcmp_test.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+
+	"golang.org/x/tools/benchmark/parse"
+)
+
+func TestSelectBest(t *testing.T) {
+	have := parse.Set{
+		"Benchmark1": []*parse.Benchmark{
+			{
+				Name: "Benchmark1",
+				N:    10, NsPerOp: 100, Measured: parse.NsPerOp,
+				Ord: 0,
+			},
+			{
+				Name: "Benchmark1",
+				N:    10, NsPerOp: 50, Measured: parse.NsPerOp,
+				Ord: 3,
+			},
+		},
+		"Benchmark2": []*parse.Benchmark{
+			{
+				Name: "Benchmark2",
+				N:    10, NsPerOp: 60, Measured: parse.NsPerOp,
+				Ord: 1,
+			},
+			{
+				Name: "Benchmark2",
+				N:    10, NsPerOp: 500, Measured: parse.NsPerOp,
+				Ord: 2,
+			},
+		},
+	}
+
+	want := parse.Set{
+		"Benchmark1": []*parse.Benchmark{
+			{
+				Name: "Benchmark1",
+				N:    10, NsPerOp: 50, Measured: parse.NsPerOp,
+				Ord: 0,
+			},
+		},
+		"Benchmark2": []*parse.Benchmark{
+			{
+				Name: "Benchmark2",
+				N:    10, NsPerOp: 60, Measured: parse.NsPerOp,
+				Ord: 1,
+			},
+		},
+	}
+
+	selectBest(have)
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("filtered bench set incorrectly, want %v have %v", want, have)
+	}
+}

vendor/golang.org/x/tools/cmd/benchcmp/compare.go

@@ -0,0 +1,156 @@
+// Copyright 2014 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 main
+
+import (
+	"fmt"
+	"math"
+
+	"golang.org/x/tools/benchmark/parse"
+)
+
+// BenchCmp is a pair of benchmarks.
+type BenchCmp struct {
+	Before *parse.Benchmark
+	After  *parse.Benchmark
+}
+
+// Correlate correlates benchmarks from two BenchSets.
+func Correlate(before, after parse.Set) (cmps []BenchCmp, warnings []string) {
+	cmps = make([]BenchCmp, 0, len(after))
+	for name, beforebb := range before {
+		afterbb := after[name]
+		if len(beforebb) != len(afterbb) {
+			warnings = append(warnings, fmt.Sprintf("ignoring %s: before has %d instances, after has %d", name, len(beforebb), len(afterbb)))
+			continue
+		}
+		for i, beforeb := range beforebb {
+			afterb := afterbb[i]
+			cmps = append(cmps, BenchCmp{beforeb, afterb})
+		}
+	}
+	return
+}
+
+func (c BenchCmp) Name() string           { return c.Before.Name }
+func (c BenchCmp) String() string         { return fmt.Sprintf("<%s, %s>", c.Before, c.After) }
+func (c BenchCmp) Measured(flag int) bool { return (c.Before.Measured & c.After.Measured & flag) != 0 }
+func (c BenchCmp) DeltaNsPerOp() Delta    { return Delta{c.Before.NsPerOp, c.After.NsPerOp} }
+func (c BenchCmp) DeltaMBPerS() Delta     { return Delta{c.Before.MBPerS, c.After.MBPerS} }
+func (c BenchCmp) DeltaAllocedBytesPerOp() Delta {
+	return Delta{float64(c.Before.AllocedBytesPerOp), float64(c.After.AllocedBytesPerOp)}
+}
+func (c BenchCmp) DeltaAllocsPerOp() Delta {
+	return Delta{float64(c.Before.AllocsPerOp), float64(c.After.AllocsPerOp)}
+}
+
+// Delta is the before and after value for a benchmark measurement.
+// Both must be non-negative.
+type Delta struct {
+	Before float64
+	After  float64
+}
+
+// mag calculates the magnitude of a change, regardless of the direction of
+// the change. mag is intended for sorting and has no independent meaning.
+func (d Delta) mag() float64 {
+	switch {
+	case d.Before != 0 && d.After != 0 && d.Before >= d.After:
+		return d.After / d.Before
+	case d.Before != 0 && d.After != 0 && d.Before < d.After:
+		return d.Before / d.After
+	case d.Before == 0 && d.After == 0:
+		return 1
+	default:
+		// 0 -> 1 or 1 -> 0
+		// These are significant changes and worth surfacing.
+		return math.Inf(1)
+	}
+}
+
+// Changed reports whether the benchmark quantities are different.
+func (d Delta) Changed() bool { return d.Before != d.After }
+
+// Float64 returns After / Before. If Before is 0, Float64 returns
+// 1 if After is also 0, and +Inf otherwise.
+func (d Delta) Float64() float64 {
+	switch {
+	case d.Before != 0:
+		return d.After / d.Before
+	case d.After == 0:
+		return 1
+	default:
+		return math.Inf(1)
+	}
+}
+
+// Percent formats a Delta as a percent change, ranging from -100% up.
+func (d Delta) Percent() string {
+	return fmt.Sprintf("%+.2f%%", 100*d.Float64()-100)
+}
+
+// Multiple formats a Delta as a multiplier, ranging from 0.00x up.
+func (d Delta) Multiple() string {
+	return fmt.Sprintf("%.2fx", d.Float64())
+}
+
+func (d Delta) String() string {
+	return fmt.Sprintf("Δ(%f, %f)", d.Before, d.After)
+}
+
+// ByParseOrder sorts BenchCmps to match the order in
+// which the Before benchmarks were presented to Parse.
+type ByParseOrder []BenchCmp
+
+func (x ByParseOrder) Len() int           { return len(x) }
+func (x ByParseOrder) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x ByParseOrder) Less(i, j int) bool { return x[i].Before.Ord < x[j].Before.Ord }
+
+// lessByDelta provides lexicographic ordering:
+//   * largest delta by magnitude
+//   * alphabetic by name
+func lessByDelta(i, j BenchCmp, calcDelta func(BenchCmp) Delta) bool {
+	iDelta, jDelta := calcDelta(i).mag(), calcDelta(j).mag()
+	if iDelta != jDelta {
+		return iDelta < jDelta
+	}
+	return i.Name() < j.Name()
+}
+
+// ByDeltaNsPerOp sorts BenchCmps lexicographically by change
+// in ns/op, descending, then by benchmark name.
+type ByDeltaNsPerOp []BenchCmp
+
+func (x ByDeltaNsPerOp) Len() int           { return len(x) }
+func (x ByDeltaNsPerOp) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaNsPerOp) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaNsPerOp) }
+
+// ByDeltaMBPerS sorts BenchCmps lexicographically by change
+// in MB/s, descending, then by benchmark name.
+type ByDeltaMBPerS []BenchCmp
+
+func (x ByDeltaMBPerS) Len() int           { return len(x) }
+func (x ByDeltaMBPerS) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaMBPerS) Less(i, j int) bool { return lessByDelta(x[i], x[j], BenchCmp.DeltaMBPerS) }
+
+// ByDeltaAllocedBytesPerOp sorts BenchCmps lexicographically by change
+// in B/op, descending, then by benchmark name.
+type ByDeltaAllocedBytesPerOp []BenchCmp
+
+func (x ByDeltaAllocedBytesPerOp) Len() int      { return len(x) }
+func (x ByDeltaAllocedBytesPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaAllocedBytesPerOp) Less(i, j int) bool {
+	return lessByDelta(x[i], x[j], BenchCmp.DeltaAllocedBytesPerOp)
+}
+
+// ByDeltaAllocsPerOp sorts BenchCmps lexicographically by change
+// in allocs/op, descending, then by benchmark name.
+type ByDeltaAllocsPerOp []BenchCmp
+
+func (x ByDeltaAllocsPerOp) Len() int      { return len(x) }
+func (x ByDeltaAllocsPerOp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x ByDeltaAllocsPerOp) Less(i, j int) bool {
+	return lessByDelta(x[i], x[j], BenchCmp.DeltaAllocsPerOp)
+}

vendor/golang.org/x/tools/cmd/benchcmp/compare_test.go

@@ -0,0 +1,133 @@
+// Copyright 2014 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 main
+
+import (
+	"math"
+	"reflect"
+	"sort"
+	"testing"
+
+	"golang.org/x/tools/benchmark/parse"
+)
+
+func TestDelta(t *testing.T) {
+	cases := []struct {
+		before  float64
+		after   float64
+		mag     float64
+		f       float64
+		changed bool
+		pct     string
+		mult    string
+	}{
+		{before: 1, after: 1, mag: 1, f: 1, changed: false, pct: "+0.00%", mult: "1.00x"},
+		{before: 1, after: 2, mag: 0.5, f: 2, changed: true, pct: "+100.00%", mult: "2.00x"},
+		{before: 2, after: 1, mag: 0.5, f: 0.5, changed: true, pct: "-50.00%", mult: "0.50x"},
+		{before: 0, after: 0, mag: 1, f: 1, changed: false, pct: "+0.00%", mult: "1.00x"},
+		{before: 1, after: 0, mag: math.Inf(1), f: 0, changed: true, pct: "-100.00%", mult: "0.00x"},
+		{before: 0, after: 1, mag: math.Inf(1), f: math.Inf(1), changed: true, pct: "+Inf%", mult: "+Infx"},
+	}
+	for _, tt := range cases {
+		d := Delta{tt.before, tt.after}
+		if want, have := tt.mag, d.mag(); want != have {
+			t.Errorf("%s.mag(): want %f have %f", d, want, have)
+		}
+		if want, have := tt.f, d.Float64(); want != have {
+			t.Errorf("%s.Float64(): want %f have %f", d, want, have)
+		}
+		if want, have := tt.changed, d.Changed(); want != have {
+			t.Errorf("%s.Changed(): want %t have %t", d, want, have)
+		}
+		if want, have := tt.pct, d.Percent(); want != have {
+			t.Errorf("%s.Percent(): want %q have %q", d, want, have)
+		}
+		if want, have := tt.mult, d.Multiple(); want != have {
+			t.Errorf("%s.Multiple(): want %q have %q", d, want, have)
+		}
+	}
+}
+
+func TestCorrelate(t *testing.T) {
+	// Benches that are going to be successfully correlated get N thus:
+	//   0x<counter><num benches><b = before | a = after>
+	// Read this: "<counter> of <num benches>, from <before|after>".
+	before := parse.Set{
+		"BenchmarkOneEach":   []*parse.Benchmark{{Name: "BenchmarkOneEach", N: 0x11b}},
+		"BenchmarkOneToNone": []*parse.Benchmark{{Name: "BenchmarkOneToNone"}},
+		"BenchmarkOneToTwo":  []*parse.Benchmark{{Name: "BenchmarkOneToTwo"}},
+		"BenchmarkTwoToOne": []*parse.Benchmark{
+			{Name: "BenchmarkTwoToOne"},
+			{Name: "BenchmarkTwoToOne"},
+		},
+		"BenchmarkTwoEach": []*parse.Benchmark{
+			{Name: "BenchmarkTwoEach", N: 0x12b},
+			{Name: "BenchmarkTwoEach", N: 0x22b},
+		},
+	}
+
+	after := parse.Set{
+		"BenchmarkOneEach":   []*parse.Benchmark{{Name: "BenchmarkOneEach", N: 0x11a}},
+		"BenchmarkNoneToOne": []*parse.Benchmark{{Name: "BenchmarkNoneToOne"}},
+		"BenchmarkTwoToOne":  []*parse.Benchmark{{Name: "BenchmarkTwoToOne"}},
+		"BenchmarkOneToTwo": []*parse.Benchmark{
+			{Name: "BenchmarkOneToTwo"},
+			{Name: "BenchmarkOneToTwo"},
+		},
+		"BenchmarkTwoEach": []*parse.Benchmark{
+			{Name: "BenchmarkTwoEach", N: 0x12a},
+			{Name: "BenchmarkTwoEach", N: 0x22a},
+		},
+	}
+
+	pairs, errs := Correlate(before, after)
+
+	// Fail to match: BenchmarkOneToNone, BenchmarkOneToTwo, BenchmarkTwoToOne.
+	// Correlate does not notice BenchmarkNoneToOne.
+	if len(errs) != 3 {
+		t.Errorf("Correlated expected 4 errors, got %d: %v", len(errs), errs)
+	}
+
+	// Want three correlated pairs: one BenchmarkOneEach, two BenchmarkTwoEach.
+	if len(pairs) != 3 {
+		t.Fatalf("Correlated expected 3 pairs, got %v", pairs)
+	}
+
+	for _, pair := range pairs {
+		if pair.Before.N&0xF != 0xb {
+			t.Errorf("unexpected Before in pair %s", pair)
+		}
+		if pair.After.N&0xF != 0xa {
+			t.Errorf("unexpected After in pair %s", pair)
+		}
+		if pair.Before.N>>4 != pair.After.N>>4 {
+			t.Errorf("mismatched pair %s", pair)
+		}
+	}
+}
+
+func TestBenchCmpSorting(t *testing.T) {
+	c := []BenchCmp{
+		{&parse.Benchmark{Name: "BenchmarkMuchFaster", NsPerOp: 10, Ord: 3}, &parse.Benchmark{Name: "BenchmarkMuchFaster", NsPerOp: 1}},
+		{&parse.Benchmark{Name: "BenchmarkSameB", NsPerOp: 5, Ord: 1}, &parse.Benchmark{Name: "BenchmarkSameB", NsPerOp: 5}},
+		{&parse.Benchmark{Name: "BenchmarkSameA", NsPerOp: 5, Ord: 2}, &parse.Benchmark{Name: "BenchmarkSameA", NsPerOp: 5}},
+		{&parse.Benchmark{Name: "BenchmarkSlower", NsPerOp: 10, Ord: 0}, &parse.Benchmark{Name: "BenchmarkSlower", NsPerOp: 11}},
+	}
+
+	// Test just one magnitude-based sort order; they are symmetric.
+	sort.Sort(ByDeltaNsPerOp(c))
+	want := []string{"BenchmarkMuchFaster", "BenchmarkSlower", "BenchmarkSameA", "BenchmarkSameB"}
+	have := []string{c[0].Name(), c[1].Name(), c[2].Name(), c[3].Name()}
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("ByDeltaNsOp incorrect sorting: want %v have %v", want, have)
+	}
+
+	sort.Sort(ByParseOrder(c))
+	want = []string{"BenchmarkSlower", "BenchmarkSameB", "BenchmarkSameA", "BenchmarkMuchFaster"}
+	have = []string{c[0].Name(), c[1].Name(), c[2].Name(), c[3].Name()}
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("ByParseOrder incorrect sorting: want %v have %v", want, have)
+	}
+}

vendor/golang.org/x/tools/cmd/benchcmp/doc.go

@@ -0,0 +1,37 @@
+// Copyright 2014 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.
+
+/*
+
+The benchcmp command displays performance changes between benchmarks.
+
+Benchcmp parses the output of two 'go test' benchmark runs,
+correlates the results per benchmark, and displays the deltas.
+
+To measure the performance impact of a change, use 'go test'
+to run benchmarks before and after the change:
+
+	go test -run=NONE -bench=. ./... > old.txt
+	# make changes
+	go test -run=NONE -bench=. ./... > new.txt
+
+Then feed the benchmark results to benchcmp:
+
+	benchcmp old.txt new.txt
+
+Benchcmp will summarize and display the performance changes,
+in a format like this:
+
+	$ benchcmp old.txt new.txt
+	benchmark           old ns/op     new ns/op     delta
+	BenchmarkConcat     523           68.6          -86.88%
+
+	benchmark           old allocs     new allocs     delta
+	BenchmarkConcat     3              1              -66.67%
+
+	benchmark           old bytes     new bytes     delta
+	BenchmarkConcat     80            48            -40.00%
+
+*/
+package main // import "golang.org/x/tools/cmd/benchcmp"