-
Notifications
You must be signed in to change notification settings - Fork 0
/
parse.go
135 lines (122 loc) · 3.19 KB
/
parse.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
// 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 (
"bufio"
"bytes"
"fmt"
"io"
"strconv"
"strings"
)
// Flags used by Bench.Measured to indicate
// which measurements a Bench contains.
const (
NsOp = 1 << iota
MbS
BOp
AllocsOp
)
// Bench is one run of a single benchmark.
type Bench struct {
Name string // benchmark name
N int // number of iterations
NsOp float64 // nanoseconds per iteration
MbS float64 // MB processed per second
BOp uint64 // bytes allocated per iteration
AllocsOp uint64 // allocs per iteration
Measured int // which measurements were recorded
ord int // ordinal position within a benchmark run, used for sorting
}
// ParseLine extracts a Bench from a single line of testing.B output.
func ParseLine(line string) (*Bench, error) {
fields := strings.Fields(line)
// Two required, positional fields: Name and iterations.
if len(fields) < 2 {
return nil, fmt.Errorf("two fields required, have %d", len(fields))
}
if !strings.HasPrefix(fields[0], "Benchmark") {
return nil, fmt.Errorf(`first field does not start with "Benchmark`)
}
n, err := strconv.Atoi(fields[1])
if err != nil {
return nil, err
}
b := &Bench{Name: fields[0], N: n}
// Parse any remaining pairs of fields; we've parsed one pair already.
for i := 1; i < len(fields)/2; i++ {
b.parseMeasurement(fields[i*2], fields[i*2+1])
}
return b, nil
}
func (b *Bench) parseMeasurement(quant string, unit string) {
switch unit {
case "ns/op":
if f, err := strconv.ParseFloat(quant, 64); err == nil {
b.NsOp = f
b.Measured |= NsOp
}
case "MB/s":
if f, err := strconv.ParseFloat(quant, 64); err == nil {
b.MbS = f
b.Measured |= MbS
}
case "B/op":
if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
b.BOp = i
b.Measured |= BOp
}
case "allocs/op":
if i, err := strconv.ParseUint(quant, 10, 64); err == nil {
b.AllocsOp = i
b.Measured |= AllocsOp
}
}
}
func (b *Bench) String() string {
buf := new(bytes.Buffer)
fmt.Fprintf(buf, "%s %d", b.Name, b.N)
if b.Measured&NsOp != 0 {
fmt.Fprintf(buf, " %.2f ns/op", b.NsOp)
}
if b.Measured&MbS != 0 {
fmt.Fprintf(buf, " %.2f MB/s", b.MbS)
}
if b.Measured&BOp != 0 {
fmt.Fprintf(buf, " %d B/op", b.BOp)
}
if b.Measured&AllocsOp != 0 {
fmt.Fprintf(buf, " %d allocs/op", b.AllocsOp)
}
return buf.String()
}
// BenchSet is a collection of benchmarks from one
// testing.B run, keyed by name to facilitate comparison.
type BenchSet map[string][]*Bench
// Parse extracts a BenchSet from testing.B output. Parse
// preserves the order of benchmarks that have identical names.
func ParseBenchSet(r io.Reader) (BenchSet, error) {
bb := make(BenchSet)
scan := bufio.NewScanner(r)
ord := 0
for scan.Scan() {
if b, err := ParseLine(scan.Text()); err == nil {
b.ord = ord
ord++
old := bb[b.Name]
if *best && old != nil {
if old[0].NsOp < b.NsOp {
continue
}
b.ord = old[0].ord
bb[b.Name] = old[:0]
}
bb[b.Name] = append(bb[b.Name], b)
}
}
if err := scan.Err(); err != nil {
return nil, err
}
return bb, nil
}