Performance and PGO

// Package perf compares ways to build the same results.
package perf

import (
	"fmt"
	"strconv"
	"strings"
)

// ConcatPlus builds a comma separated list with repeated concatenation.
func ConcatPlus(titles []string) string {
	s := ""
	for i, t := range titles {
		if i > 0 {
			s += ", "
		}
		s += t
	}
	return s
}

// ConcatBuilder uses a strings.Builder with no size hint.
func ConcatBuilder(titles []string) string {
	var b strings.Builder
	for i, t := range titles {
		if i > 0 {
			b.WriteString(", ")
		}
		b.WriteString(t)
	}
	return b.String()
}

// ConcatGrow sizes the builder once.
func ConcatGrow(titles []string) string {
	n := 2 * len(titles)
	for _, t := range titles {
		n += len(t)
	}
	var b strings.Builder
	b.Grow(n)
	for i, t := range titles {
		if i > 0 {
			b.WriteString(", ")
		}
		b.WriteString(t)
	}
	return b.String()
}

// ConcatJoin lets the standard library do the sizing.
func ConcatJoin(titles []string) string { return strings.Join(titles, ", ") }

// IDsAppend grows the result as it goes.
func IDsAppend(n int) []string {
	var out []string
	for i := range n {
		out = append(out, strconv.Itoa(i))
	}
	return out
}

// IDsPrealloc knows the final length up front.
func IDsPrealloc(n int) []string {
	out := make([]string, 0, n)
	for i := range n {
		out = append(out, strconv.Itoa(i))
	}
	return out
}

// LabelSprintf formats with fmt.
func LabelSprintf(n int) string { return fmt.Sprintf("loan-%d", n) }

// LabelConcat formats with strconv.
func LabelConcat(n int) string { return "loan-" + strconv.Itoa(n) }

// CountGrow builds a map without a size hint.
func CountGrow(keys []string) map[string]int {
	m := map[string]int{}
	for _, k := range keys {
		m[k]++
	}
	return m
}

// CountHint sizes the map for the number of keys.
func CountHint(keys []string) map[string]int {
	m := make(map[string]int, len(keys))
	for _, k := range keys {
		m[k]++
	}
	return m
}

package perf

import (
	"strconv"
	"testing"
)

var titles = func() []string {
	t := make([]string, 100)
	for i := range t {
		t[i] = "Title number " + strconv.Itoa(i)
	}
	return t
}()

var sinkS string

func BenchmarkConcat(b *testing.B) {
	funcs := []struct {
		name string
		f    func([]string) string
	}{
		{"plus", ConcatPlus},
		{"builder", ConcatBuilder},
		{"grow", ConcatGrow},
		{"join", ConcatJoin},
	}
	for _, fn := range funcs {
		b.Run(fn.name, func(b *testing.B) {
			b.ReportAllocs()
			for b.Loop() {
				sinkS = fn.f(titles)
			}
		})
	}
}

var sinkIDs []string

func BenchmarkIDs(b *testing.B) {
	b.Run("append", func(b *testing.B) {
		b.ReportAllocs()
		for b.Loop() {
			sinkIDs = IDsAppend(1000)
		}
	})
	b.Run("prealloc", func(b *testing.B) {
		b.ReportAllocs()
		for b.Loop() {
			sinkIDs = IDsPrealloc(1000)
		}
	})
}

func BenchmarkLabel(b *testing.B) {
	b.Run("sprintf", func(b *testing.B) {
		b.ReportAllocs()
		for i := 0; b.Loop(); i++ {
			sinkS = LabelSprintf(i)
		}
	})
	b.Run("strconv", func(b *testing.B) {
		b.ReportAllocs()
		for i := 0; b.Loop(); i++ {
			sinkS = LabelConcat(i)
		}
	})
}

var sinkM map[string]int

func BenchmarkCount(b *testing.B) {
	keys := make([]string, 1000)
	for i := range keys {
		keys[i] = "k" + strconv.Itoa(i)
	}
	b.Run("nohint", func(b *testing.B) {
		b.ReportAllocs()
		for b.Loop() {
			sinkM = CountGrow(keys)
		}
	})
	b.Run("hint", func(b *testing.B) {
		b.ReportAllocs()
		for b.Loop() {
			sinkM = CountHint(keys)
		}
	})
}

go test -run '^$' -bench . -benchmem ./perf

goos: darwin
goarch: arm64
pkg: example.com/shelf/perf
cpu: Apple M5
BenchmarkConcat/plus-10         	   46561	     27491 ns/op	  178513 B/op	     198 allocs/op
BenchmarkConcat/builder-10      	  780880	      1492 ns/op	    5360 B/op	       9 allocs/op
BenchmarkConcat/grow-10         	 1000000	      1021 ns/op	    1792 B/op	       1 allocs/op
BenchmarkConcat/join-10         	 1000000	      1411 ns/op	    1792 B/op	       1 allocs/op
BenchmarkIDs/append-10          	   60566	     23529 ns/op	   38016 B/op	     909 allocs/op
BenchmarkIDs/prealloc-10        	   63534	     16405 ns/op	   19264 B/op	     901 allocs/op
BenchmarkLabel/sprintf-10       	21099147	        54.44 ns/op	      24 B/op	       2 allocs/op
BenchmarkLabel/strconv-10       	36762123	        35.25 ns/op	      23 B/op	       1 allocs/op
BenchmarkCount/nohint-10        	   13058	     89998 ns/op	  109016 B/op	      22 allocs/op
BenchmarkCount/hint-10          	   62511	     17876 ns/op	   54656 B/op	       6 allocs/op

go test -run '^$' -bench 'Concat/plus' -benchtime 2s -memprofile mem.out -memprofilerate 1 ./perf
go tool pprof -sample_index=alloc_space -list ConcatPlus perf.test mem.out

ROUTINE ======================== example.com/shelf/perf.ConcatPlus in .../shelf/perf/perf.go
    1.66GB     1.66GB (flat, cum) 99.85% of Total
         .          .     11:func ConcatPlus(titles []string) string {
         .          .     12:	s := ""
         .          .     13:	for i, t := range titles {
         .          .     14:		if i > 0 {
  844.88MB   844.88MB     15:			s += ", "
         .          .     16:		}
  857.54MB   857.54MB     17:		s += t
         .          .     18:	}
         .          .     19:	return s
         .          .     20:}

// Package inl shows what the compiler's optimization passes report.
package inl

import (
	"fmt"

	"example.com/shelf/catalog"
)

// Pages is cheap enough to inline.
func Pages(words int) int { return (words + 249) / 250 }

// Describe calls fmt.Sprintf, which is too expensive to inline into callers
// but cheap to inline itself.
func Describe(b catalog.Book) string {
	return fmt.Sprintf("%s (%s)", b.Title, b.ISBN)
}

// Checksum has a loop and a branch; it is bigger than Pages.
func Checksum(d string) int {
	sum := 0
	for i := 0; i < len(d); i++ {
		w := 1
		if i%2 == 1 {
			w = 3
		}
		sum += int(d[i]-'0') * w
	}
	return sum % 10
}

//go:noinline
func Slow(n int) int { return n * 2 }

// NewBook returns a pointer to a local, which therefore escapes.
func NewBook(title string) *catalog.Book {
	b := catalog.Book{Title: title}
	return &b
}

// Total keeps its local on the stack.
func Total(titles []string) int {
	b := catalog.Book{Title: titles[0]}
	p := &b
	return len(p.Title)
}

// Print boxes its argument into an interface.
func Print(n int) {
	fmt.Println(n)
}

// Lookup calls through an interface whose concrete type is known locally.
func Lookup(isbn catalog.ISBN) bool {
	var s catalog.Store = catalog.NewMemStore()
	_, ok := s.Get(isbn)
	return ok
}

func Use() int {
	return Pages(1000) + Slow(2) + Checksum("9780134190440")
}

package inl

import (
	"strings"
	"sync"
)

var mu sync.Mutex

// Locked uses defer, which keeps a function from being inlined.
func Locked(n *int) {
	mu.Lock()
	defer mu.Unlock()
	*n++
}

// Spawn starts a goroutine, another construct that blocks inlining.
func Spawn(f func()) {
	go f()
}

// Slugify is simply too big for the inlining budget of 80.
func Slugify(title string) string {
	var b strings.Builder
	prevDash := true
	for _, r := range strings.ToLower(title) {
		switch {
		case r >= 'a' && r <= 'z', r >= '0' && r <= '9':
			b.WriteRune(r)
			prevDash = false
		case !prevDash:
			b.WriteByte('-')
			prevDash = true
		}
	}
	return strings.TrimSuffix(b.String(), "-")
}

go build -gcflags='-m=2' ./inl 2>&1 | grep -E 'can(not)? inline'

inl/inl.go:11:6: can inline Pages (cost 6)
inl/inl.go:15:6: can inline Describe (cost 69)
inl/inl.go:20:6: can inline Checksum (cost 46)
inl/inl.go:33:6: cannot inline Slow: marked go:noinline
inl/inl.go:36:6: can inline NewBook (cost 10)
inl/inl.go:42:6: can inline Total (cost 19)
inl/inl.go:49:6: can inline Print (cost 78)
inl/inl.go:54:6: can inline Lookup (cost 80)
inl/inl.go:60:6: cannot inline Use: function too complex: cost 121 exceeds budget 80
inl/limits.go:11:6: cannot inline Locked: unhandled op DEFER
inl/limits.go:13:2: can inline Locked.deferwrap1 (cost 76)
inl/limits.go:18:6: cannot inline Spawn: unhandled op GO
inl/limits.go:23:6: cannot inline Slugify: function too complex: cost 245 exceeds budget 80

go build -gcflags='-l -m' ./inl 2>&1 | grep -c 'inlining call'

0

go build -gcflags=-m ./inl 2>&1 | grep -E 'moved to heap|escapes to heap|leaking param'

inl/inl.go:15:15: leaking param: b
inl/inl.go:16:33: b.Title escapes to heap
inl/inl.go:16:42: b.ISBN escapes to heap
inl/inl.go:36:14: leaking param: title
inl/inl.go:37:2: moved to heap: b
inl/inl.go:50:14: n escapes to heap
inl/inl.go:55:43: &catalog.MemStore{...} escapes to heap
inl/inl.go:55:43: map[catalog.ISBN]catalog.Book{} escapes to heap
inl/limits.go:18:12: leaking param: f

go build -gcflags=-m ./inl 2>&1 | grep devirt

inl/inl.go:56:16: devirtualizing s.Get to *catalog.MemStore

// Package bce shows bounds-check elimination.
package bce

// SumIndex checks every access: the compiler cannot relate i to len(w).
func SumIndex(v, w []int) int {
	s := 0
	for i := range v {
		s += v[i] * w[i]
	}
	return s
}

// SumHint proves len(w) >= len(v) once, so the loop needs no checks.
func SumHint(v, w []int) int {
	w = w[:len(v)]
	s := 0
	for i := range v {
		s += v[i] * w[i]
	}
	return s
}

// SumRange iterates the elements directly: nothing to check.
func SumRange(v []int) int {
	s := 0
	for _, x := range v {
		s += x
	}
	return s
}

// Header reads four bytes; one early check covers all of them.
func Header(b []byte) uint32 {
	_ = b[3]
	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
}

// HeaderNoHint repeats a check for each index.
func HeaderNoHint(b []byte) uint32 {
	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
}

go build -gcflags=-d=ssa/check_bce/debug=1 ./bce

bce/bce.go:8:16: Found IsInBounds
bce/bce.go:15:7: Found IsSliceInBounds
bce/bce.go:34:7: Found IsInBounds
bce/bce.go:40:17: Found IsInBounds
bce/bce.go:40:32: Found IsInBounds
bce/bce.go:40:50: Found IsInBounds
bce/bce.go:40:69: Found IsInBounds

// Command collect starts a pprof endpoint on a local port, keeps the CPU
// busy for a moment and downloads a CPU profile the way a PGO pipeline
// would download one from a running service.
package main

import (
	"compress/gzip"
	"context"
	"flag"
	"fmt"
	"io"
	"log"
	"net"
	"net/http"
	_ "net/http/pprof" // registers /debug/pprof/ on http.DefaultServeMux
	"os"
	"strings"
	"time"

	"example.com/shelf/catalog"
)

func main() {
	out := flag.String("o", "collected.pprof", "where to write the profile")
	seconds := flag.Int("seconds", 1, "profile duration (use 30 or more in production)")
	flag.Parse()

	// Bind to the loopback interface only: /debug/pprof must never be
	// reachable from outside the machine without authentication.
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		log.Fatal(err)
	}
	srv := &http.Server{Handler: http.DefaultServeMux}
	go srv.Serve(ln)
	defer srv.Close()

	// Stand-in for production traffic.
	ctx, stop := context.WithCancel(context.Background())
	defer stop()
	go func() {
		store := catalog.NewMemStore()
		store.Put(catalog.Book{ISBN: "9780134190440", Title: "The Go Programming Language"})
		for ctx.Err() == nil {
			store.Get("9780134190440")
			strings.ToUpper("a title that needs normalising")
		}
	}()

	url := fmt.Sprintf("http://%s/debug/pprof/profile?seconds=%d", ln.Addr(), *seconds)
	client := &http.Client{Timeout: time.Duration(*seconds+10) * time.Second}
	resp, err := client.Get(url)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	f, err := os.Create(*out)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	n, err := io.Copy(f, resp.Body)
	if err != nil {
		log.Fatal(err)
	}

	f.Seek(0, io.SeekStart)
	if _, err := gzip.NewReader(f); err != nil {
		log.Fatalf("not a gzip stream: %v", err)
	}
	fmt.Println("status:", resp.Status)
	fmt.Println("content type:", resp.Header.Get("Content-Type"))
	fmt.Println("profile is gzip-compressed protobuf:", n > 0)
}

go run ./collect -o collected.pprof
go tool pprof -top -nodecount=5 collected.pprof

status: 200 OK
content type: application/octet-stream
profile is gzip-compressed protobuf: true

File: collect
Type: cpu
Time: 2026-10-18 03:23:54 CEST
Duration: 1.12s, Total samples = 900ms (80.50%)
Showing nodes accounting for 660ms, 73.33% of 900ms total
Showing top 5 nodes out of 42
      flat  flat%   sum%        cum   cum%
     400ms 44.44% 44.44%      680ms 75.56%  strings.ToUpper
      80ms  8.89% 53.33%       90ms 10.00%  strings.(*Builder).WriteByte (inline)
      60ms  6.67% 60.00%       60ms  6.67%  runtime.kevent
      60ms  6.67% 66.67%       60ms  6.67%  runtime.madvise
      60ms  6.67% 73.33%       90ms 10.00%  runtime.mallocgcSmallNoScanSC4

go tool pprof -proto a.pprof b.pprof > default.pgo

// Command pgo is a small search workload used to try profile-guided
// optimization. It scores every title in a generated catalogue against a
// query through a Scorer interface.
package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"runtime/pprof"
	"time"
)

// Scorer rates how well a title matches a query.
type Scorer interface {
	Score(title, query string) int
}

type prefixScorer struct{}

func (prefixScorer) Score(title, query string) int {
	n := 0
	for n < len(title) && n < len(query) && fold(title[n]) == fold(query[n]) {
		n++
	}
	return n
}

type containsScorer struct{}

func (containsScorer) Score(title, query string) int {
	best := 0
	for i := 0; i+len(query) <= len(title); i++ {
		n := 0
		for n < len(query) && fold(title[i+n]) == fold(query[n]) {
			n++
		}
		best = max(best, n)
	}
	return best
}

// fold lower-cases an ASCII letter. It is small enough to inline everywhere.
func fold(c byte) byte {
	if 'A' <= c && c <= 'Z' {
		return c + 'a' - 'A'
	}
	return c
}

// bonus is deliberately above the default inlining budget of 80, so only a
// profile can make the compiler inline it into the hot loop.
func bonus(title string, n int) int {
	switch {
	case n == 0:
		return 0
	case n == len(title):
		return 100
	case title[n-1] == ' ':
		return 20 + n
	case n > 8 && title[0] == 'T':
		return 12 + n/2
	case n > 4 && title[len(title)-1] == 's':
		return 8 + n/3
	case n > 2:
		return 4 + n/4
	}
	if title[0] == 'A' || title[0] == 'a' {
		return 2
	}
	return 1
}

func search(s Scorer, titles []string, query string) (best int, at int) {
	for i, t := range titles {
		score := s.Score(t, query)
		score += bonus(t, score)
		if score > best {
			best, at = score, i
		}
	}
	return best, at
}

func makeTitles(n int) []string {
	words := []string{"Programming", "Go", "Systems", "Concurrency", "Practice", "Design", "Patterns", "Network"}
	titles := make([]string, n)
	x := uint32(1)
	for i := range titles {
		x = x*1664525 + 1013904223
		titles[i] = words[x>>24%8] + " " + words[x>>16%8] + " " + words[x>>8%8]
	}
	return titles
}

func main() {
	profile := flag.String("cpuprofile", "", "write a CPU profile to this file")
	rounds := flag.Int("rounds", 40, "timed repetitions")
	flag.Parse()

	titles := makeTitles(20000)
	queries := []string{"programming go", "systems", "concurrency practice", "net", "design patterns"}
	// 95% of the calls use prefixScorer, the rest containsScorer: the
	// interface call is hot but not monomorphic.
	scorers := [20]Scorer{}
	for i := range scorers {
		scorers[i] = prefixScorer{}
	}
	scorers[19] = containsScorer{}

	if *profile != "" {
		f, err := os.Create(*profile)
		if err != nil {
			log.Fatal(err)
		}
		defer f.Close()
		if err := pprof.StartCPUProfile(f); err != nil {
			log.Fatal(err)
		}
		defer pprof.StopCPUProfile()
	}

	fastest := time.Duration(1<<63 - 1)
	total := 0
	for range *rounds {
		start := time.Now()
		for i := range 20 {
			for _, q := range queries {
				best, _ := search(scorers[i], titles, q)
				total += best
			}
		}
		fastest = min(fastest, time.Since(start))
	}
	fmt.Printf("checksum=%d fastest round=%v\n", total, fastest.Round(time.Microsecond))
}

go build -pgo=off -o nopgo .
./nopgo -cpuprofile a.pprof
./nopgo -cpuprofile b.pprof
go tool pprof -proto a.pprof b.pprof > default.pgo
go tool pprof -top -nodecount=6 default.pgo

File: nopgo
Type: cpu
Time: 2026-10-18 03:17:14 CEST
Duration: 2.03s, Total samples = 1360ms (66.95%)
Showing nodes accounting for 1310ms, 96.32% of 1360ms total
Showing top 6 nodes out of 21
      flat  flat%   sum%        cum   cum%
     450ms 33.09% 33.09%     1230ms 90.44%  main.search
     370ms 27.21% 60.29%      370ms 27.21%  main.prefixScorer.Score
     250ms 18.38% 78.68%      270ms 19.85%  main.containsScorer.Score
     140ms 10.29% 88.97%      140ms 10.29%  main.bonus
      80ms  5.88% 94.85%       80ms  5.88%  runtime.pthread_cond_signal
      20ms  1.47% 96.32%       20ms  1.47%  runtime.pthread_mutex_lock

go build -pgo=off -gcflags=-m=1 . 2>&1 | grep -E 'main.go:(7|8)[0-9]:'
echo ---
go build -gcflags=-m=1 . 2>&1 | grep -E 'main.go:(7|8)[0-9]:'

./main.go:86:6: can inline makeTitles
./main.go:75:13: leaking param: s
./main.go:75:23: leaking param content: titles
./main.go:75:40: leaking param: query
./main.go:87:19: []string{...} does not escape
./main.go:88:16: make([]string, n) escapes to heap
---
./main.go:77:19: PGO devirtualizing interface call s.Score to prefixScorer.Score
./main.go:75:6: can inline search
./main.go:86:6: can inline makeTitles
./main.go:77:19: inlining call to prefixScorer.Score
./main.go:78:17: inlining call to bonus
./main.go:77:19: inlining call to fold
./main.go:77:19: inlining call to fold
./main.go:75:13: leaking param: s
./main.go:75:23: leaking param content: titles
./main.go:75:40: leaking param: query
./main.go:87:19: []string{...} does not escape
./main.go:88:16: make([]string, n) escapes to heap

go build -o /dev/null -gcflags=example.com/shelf/pgo=-d=pgodebug=1 .

# example.com/shelf/pgo
hot-callsite-thres-from-CDF=0.7194244604316548
hot-node enabled increased budget=2000 for func=main.fold
hot-node enabled increased budget=2000 for func=main.prefixScorer.Score
hot-node enabled increased budget=2000 for func=main.containsScorer.Score
hot-node enabled increased budget=2000 for func=main.bonus
hot-node enabled increased budget=2000 for func=main.search
hot-budget check allows inlining for call main.bonus (cost 87) at ./main.go:78:17 in function main.search
hot-budget check allows inlining for call main.bonus (cost 87) at ./main.go:78:17 in function main.search
hot-budget check allows inlining for call main.search (cost 267) at ./main.go:130:22 in function main.main

go version -m withpgo | grep -E 'path|pgo'
go version -m nopgo | grep -E 'path|pgo'

withpgo: go1.27.2
	path	example.com/shelf/pgo
	build	-pgo=.../default.pgo
	path	example.com/shelf/pgo
	build	-buildmode=exe
	build	-compiler=gc
	build	CGO_ENABLED=1

nopgo   checksum=448200 fastest round=16.557ms
withpgo checksum=448200 fastest round=17.3ms
nopgo   checksum=448200 fastest round=16.36ms
withpgo checksum=448200 fastest round=17.307ms
nopgo   checksum=448200 fastest round=16.422ms
withpgo checksum=448200 fastest round=17.413ms
nopgo   checksum=448200 fastest round=16.514ms
withpgo checksum=448200 fastest round=17.277ms
nopgo   checksum=448200 fastest round=16.446ms
withpgo checksum=448200 fastest round=17.478ms

// Command seq compares allocating and non-allocating ways to walk a string.
package main

import (
	"fmt"
	"slices"
	"strconv"
	"strings"
	"testing"
)

var (
	sinkN int
	sinkS []string
)

func main() {
	authors := "Donovan, Kernighan, Cox, Pike, Thompson, Griesemer, Ritchie, Pratt"

	count := func(name string, f func()) {
		fmt.Printf("%-34s %.0f allocs/op\n", name, testing.AllocsPerRun(1000, f))
	}

	count("strings.Split + range", func() {
		for _, a := range strings.Split(authors, ", ") {
			sinkN += len(a)
		}
	})
	count("strings.SplitSeq + range", func() {
		for a := range strings.SplitSeq(authors, ", ") {
			sinkN += len(a)
		}
	})
	count("strings.Fields + range", func() {
		for _, a := range strings.Fields(authors) {
			sinkN += len(a)
		}
	})
	count("strings.FieldsSeq + range", func() {
		for a := range strings.FieldsSeq(authors) {
			sinkN += len(a)
		}
	})
	count("strconv.Itoa", func() { sinkN += len(strconv.Itoa(123456)) })
	buf := make([]byte, 0, 32)
	count("strconv.AppendInt into reused buf", func() {
		buf = strconv.AppendInt(buf[:0], 123456, 10)
		sinkN += len(buf)
	})
	count("slices.Collect(SplitSeq)", func() {
		sinkS = slices.Collect(strings.SplitSeq(authors, ", "))
	})
	count("slices.Grow then append", func() {
		s := slices.Grow([]string(nil), 8)
		for a := range strings.SplitSeq(authors, ", ") {
			s = append(s, a)
		}
		sinkS = s
	})
}

go run ./seq

strings.Split + range              1 allocs/op
strings.SplitSeq + range           0 allocs/op
strings.Fields + range             1 allocs/op
strings.FieldsSeq + range          0 allocs/op
strconv.Itoa                       1 allocs/op
strconv.AppendInt into reused buf  0 allocs/op
slices.Collect(SplitSeq)           4 allocs/op
slices.Grow then append            1 allocs/op

go test -run '^$' -bench Counters -benchmem -count 3 ./layout

goos: darwin
goarch: arm64
pkg: example.com/shelf/layout
cpu: Apple M5
BenchmarkCounters/shared-10         	      63	  16577969 ns/op	     211 B/op	       6 allocs/op
BenchmarkCounters/shared-10         	      70	  16439811 ns/op	     160 B/op	       6 allocs/op
BenchmarkCounters/shared-10         	      73	  15963485 ns/op	     144 B/op	       6 allocs/op
BenchmarkCounters/padded-10         	     446	   2703300 ns/op	     352 B/op	       6 allocs/op
BenchmarkCounters/padded-10         	     475	   3157026 ns/op	     414 B/op	       6 allocs/op
BenchmarkCounters/padded-10         	     286	   3849016 ns/op	     360 B/op	       6 allocs/op