mirror of https://github.com/etcd-io/dbtester.git
vendor: update dependencies
This commit is contained in:
Gyu-Ho Lee
parent
94c635a10f
commit
daf9431178
|
|
@ -1,5 +1,5 @@
|
|||
hash: 43f424fe4c43c83acc5d95f3feb0364ecad9baffbe2e659fa134633c954443ad
|
||||
updated: 2017-02-04T03:46:43.459571687-08:00
|
||||
hash: 8ac3c6083047f0e4c28edc49aa0af344f05d607ebfd77731c90a9fcc41d8660e
|
||||
updated: 2017-02-04T13:20:25.110990522-08:00
|
||||
imports:
|
||||
- name: bitbucket.org/zombiezen/gopdf
|
||||
version: 1c63dc69751bc45441c2ce1f56b631c55294b4d5
|
||||
|
|
@ -23,7 +23,7 @@ imports:
|
|||
subpackages:
|
||||
- bezier
|
||||
- name: github.com/cheggaaa/pb
|
||||
version: 6e9d17711bb763b26b68b3931d47f24c1323abab
|
||||
version: d7e6ca3010b6f084d8056847f55d7f572f180678
|
||||
- name: github.com/coreos/etcd
|
||||
version: bad2f03cd027c8cee60df2f55713946b86a36659
|
||||
subpackages:
|
||||
|
|
@ -127,7 +127,7 @@ imports:
|
|||
subpackages:
|
||||
- pbutil
|
||||
- name: github.com/olekukonko/tablewriter
|
||||
version: a0225b3f23b5ce0cbec6d7a66a968f8a59eca9c4
|
||||
version: febf2d34b54a69ce7530036c7503b1c9fbfdf0bb
|
||||
- name: github.com/prometheus/client_golang
|
||||
version: c5b7fccd204277076155f10851dad72b76a49317
|
||||
subpackages:
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ import:
|
|||
- internal
|
||||
- storage
|
||||
- package: github.com/cheggaaa/pb
|
||||
version: 6e9d17711bb763b26b68b3931d47f24c1323abab
|
||||
version: d7e6ca3010b6f084d8056847f55d7f572f180678
|
||||
- package: github.com/coreos/etcd
|
||||
version: bad2f03cd027c8cee60df2f55713946b86a36659
|
||||
subpackages:
|
||||
|
|
@ -108,4 +108,4 @@ import:
|
|||
subpackages:
|
||||
- rate
|
||||
- package: github.com/olekukonko/tablewriter
|
||||
version: a0225b3f23b5ce0cbec6d7a66a968f8a59eca9c4
|
||||
version: febf2d34b54a69ce7530036c7503b1c9fbfdf0bb
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ import (
|
|||
)
|
||||
|
||||
// Current version
|
||||
const Version = "1.0.5"
|
||||
const Version = "1.0.6"
|
||||
|
||||
const (
|
||||
// Default refresh rate - 200ms
|
||||
|
|
@ -222,7 +222,10 @@ func (pb *ProgressBar) Finish() {
|
|||
pb.finishOnce.Do(func() {
|
||||
close(pb.finish)
|
||||
pb.write(atomic.LoadInt64(&pb.current))
|
||||
if !pb.NotPrint {
|
||||
switch {
|
||||
case pb.Output != nil:
|
||||
fmt.Fprintln(pb.Output)
|
||||
case !pb.NotPrint:
|
||||
fmt.Println()
|
||||
}
|
||||
pb.isFinish = true
|
||||
|
|
@ -232,7 +235,11 @@ func (pb *ProgressBar) Finish() {
|
|||
// End print and write string 'str'
|
||||
func (pb *ProgressBar) FinishPrint(str string) {
|
||||
pb.Finish()
|
||||
fmt.Println(str)
|
||||
if pb.Output != nil {
|
||||
fmt.Fprintln(pb.Output, str)
|
||||
} else {
|
||||
fmt.Println(str)
|
||||
}
|
||||
}
|
||||
|
||||
// implement io.Writer
|
||||
|
|
@ -289,11 +296,7 @@ func (pb *ProgressBar) write(current int64) {
|
|||
case <-pb.finish:
|
||||
if pb.ShowFinalTime {
|
||||
var left time.Duration
|
||||
if pb.Total > 0 {
|
||||
left = (fromStart / time.Second) * time.Second
|
||||
} else {
|
||||
left = (time.Duration(currentFromStart) / time.Second) * time.Second
|
||||
}
|
||||
left = (fromStart / time.Second) * time.Second
|
||||
timeLeftBox = fmt.Sprintf(" %s", left.String())
|
||||
}
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -1,15 +1,15 @@
|
|||
package pb
|
||||
|
||||
import (
|
||||
"github.com/mattn/go-runewidth"
|
||||
"regexp"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// Finds the control character sequences (like colors)
|
||||
var ctrlFinder = regexp.MustCompile("\x1b\x5b[0-9]+\x6d")
|
||||
|
||||
func escapeAwareRuneCountInString(s string) int {
|
||||
n := utf8.RuneCountInString(s)
|
||||
n := runewidth.StringWidth(s)
|
||||
for _, sm := range ctrlFinder.FindAllString(s, -1) {
|
||||
n -= len(sm)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,16 +0,0 @@
|
|||
// Copyright 2016 The etcd Authors
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Package report generates human-readable benchmark reports.
|
||||
package report
|
||||
|
|
@ -1,284 +0,0 @@
|
|||
// Copyright 2014 The etcd Authors
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// the file is borrowed from github.com/rakyll/boom/boomer/print.go
|
||||
|
||||
package report
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
barChar = "∎"
|
||||
)
|
||||
|
||||
// Result describes the timings for an operation.
|
||||
type Result struct {
|
||||
Start time.Time
|
||||
End time.Time
|
||||
Err error
|
||||
}
|
||||
|
||||
func (res *Result) Duration() time.Duration { return res.End.Sub(res.Start) }
|
||||
|
||||
type report struct {
|
||||
results chan Result
|
||||
precision string
|
||||
|
||||
avgTotal float64
|
||||
fastest float64
|
||||
slowest float64
|
||||
average float64
|
||||
stddev float64
|
||||
rps float64
|
||||
total time.Duration
|
||||
|
||||
errorDist map[string]int
|
||||
lats []float64
|
||||
|
||||
sps *secondPoints
|
||||
}
|
||||
|
||||
// Stats exposes results raw data.
|
||||
type Stats struct {
|
||||
AvgTotal float64
|
||||
Fastest float64
|
||||
Slowest float64
|
||||
Average float64
|
||||
Stddev float64
|
||||
RPS float64
|
||||
Total time.Duration
|
||||
ErrorDist map[string]int
|
||||
Lats []float64
|
||||
TimeSeries TimeSeries
|
||||
}
|
||||
|
||||
// Report processes a result stream until it is closed, then produces a
|
||||
// string with information about the consumed result data.
|
||||
type Report interface {
|
||||
Results() chan<- Result
|
||||
|
||||
// Run returns results in print-friendly format.
|
||||
Run() <-chan string
|
||||
|
||||
// Stats returns results in raw data.
|
||||
Stats() <-chan Stats
|
||||
}
|
||||
|
||||
func NewReport(precision string) Report {
|
||||
return &report{
|
||||
results: make(chan Result, 16),
|
||||
precision: precision,
|
||||
errorDist: make(map[string]int),
|
||||
}
|
||||
}
|
||||
|
||||
func NewReportSample(precision string) Report {
|
||||
r := NewReport(precision).(*report)
|
||||
r.sps = newSecondPoints()
|
||||
return r
|
||||
}
|
||||
|
||||
func (r *report) Results() chan<- Result { return r.results }
|
||||
|
||||
func (r *report) Run() <-chan string {
|
||||
donec := make(chan string, 1)
|
||||
go func() {
|
||||
defer close(donec)
|
||||
r.processResults()
|
||||
donec <- r.String()
|
||||
}()
|
||||
return donec
|
||||
}
|
||||
|
||||
func (r *report) Stats() <-chan Stats {
|
||||
donec := make(chan Stats, 1)
|
||||
go func() {
|
||||
defer close(donec)
|
||||
r.processResults()
|
||||
donec <- Stats{
|
||||
AvgTotal: r.avgTotal,
|
||||
Fastest: r.fastest,
|
||||
Slowest: r.slowest,
|
||||
Average: r.average,
|
||||
Stddev: r.stddev,
|
||||
RPS: r.rps,
|
||||
Total: r.total,
|
||||
ErrorDist: copyMap(r.errorDist),
|
||||
Lats: copyFloats(r.lats),
|
||||
TimeSeries: r.sps.getTimeSeries(),
|
||||
}
|
||||
}()
|
||||
return donec
|
||||
}
|
||||
|
||||
func copyMap(m map[string]int) (c map[string]int) {
|
||||
c = make(map[string]int, len(m))
|
||||
for k, v := range m {
|
||||
c[k] = v
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func copyFloats(s []float64) (c []float64) {
|
||||
c = make([]float64, len(s))
|
||||
copy(c, s)
|
||||
return
|
||||
}
|
||||
|
||||
func (r *report) String() (s string) {
|
||||
if len(r.lats) > 0 {
|
||||
s += fmt.Sprintf("\nSummary:\n")
|
||||
s += fmt.Sprintf(" Total:\t%s.\n", r.sec2str(r.total.Seconds()))
|
||||
s += fmt.Sprintf(" Slowest:\t%s.\n", r.sec2str(r.slowest))
|
||||
s += fmt.Sprintf(" Fastest:\t%s.\n", r.sec2str(r.fastest))
|
||||
s += fmt.Sprintf(" Average:\t%s.\n", r.sec2str(r.average))
|
||||
s += fmt.Sprintf(" Stddev:\t%s.\n", r.sec2str(r.stddev))
|
||||
s += fmt.Sprintf(" Requests/sec:\t"+r.precision+"\n", r.rps)
|
||||
s += r.histogram()
|
||||
s += r.sprintLatencies()
|
||||
if r.sps != nil {
|
||||
s += fmt.Sprintf("%v\n", r.sps.getTimeSeries())
|
||||
}
|
||||
}
|
||||
if len(r.errorDist) > 0 {
|
||||
s += r.errors()
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func (r *report) sec2str(sec float64) string { return fmt.Sprintf(r.precision+" secs", sec) }
|
||||
|
||||
type reportRate struct{ *report }
|
||||
|
||||
func NewReportRate(precision string) Report {
|
||||
return &reportRate{NewReport(precision).(*report)}
|
||||
}
|
||||
|
||||
func (r *reportRate) String() string {
|
||||
return fmt.Sprintf(" Requests/sec:\t"+r.precision+"\n", r.rps)
|
||||
}
|
||||
|
||||
func (r *report) processResult(res *Result) {
|
||||
if res.Err != nil {
|
||||
r.errorDist[res.Err.Error()]++
|
||||
return
|
||||
}
|
||||
dur := res.Duration()
|
||||
r.lats = append(r.lats, dur.Seconds())
|
||||
r.avgTotal += dur.Seconds()
|
||||
if r.sps != nil {
|
||||
r.sps.Add(res.Start, dur)
|
||||
}
|
||||
}
|
||||
|
||||
func (r *report) processResults() {
|
||||
st := time.Now()
|
||||
for res := range r.results {
|
||||
r.processResult(&res)
|
||||
}
|
||||
r.total = time.Since(st)
|
||||
|
||||
r.rps = float64(len(r.lats)) / r.total.Seconds()
|
||||
r.average = r.avgTotal / float64(len(r.lats))
|
||||
for i := range r.lats {
|
||||
dev := r.lats[i] - r.average
|
||||
r.stddev += dev * dev
|
||||
}
|
||||
r.stddev = math.Sqrt(r.stddev / float64(len(r.lats)))
|
||||
sort.Float64s(r.lats)
|
||||
if len(r.lats) > 0 {
|
||||
r.fastest = r.lats[0]
|
||||
r.slowest = r.lats[len(r.lats)-1]
|
||||
}
|
||||
}
|
||||
|
||||
var pctls = []float64{10, 25, 50, 75, 90, 95, 99, 99.9}
|
||||
|
||||
// Percentiles returns percentile distribution of float64 slice.
|
||||
func Percentiles(nums []float64) (pcs []float64, data []float64) {
|
||||
return pctls, percentiles(nums)
|
||||
}
|
||||
|
||||
func percentiles(nums []float64) (data []float64) {
|
||||
data = make([]float64, len(pctls))
|
||||
j := 0
|
||||
n := len(nums)
|
||||
for i := 0; i < n && j < len(pctls); i++ {
|
||||
current := float64(i) * 100.0 / float64(n)
|
||||
if current >= pctls[j] {
|
||||
data[j] = nums[i]
|
||||
j++
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (r *report) sprintLatencies() string {
|
||||
data := percentiles(r.lats)
|
||||
s := fmt.Sprintf("\nLatency distribution:\n")
|
||||
for i := 0; i < len(pctls); i++ {
|
||||
if data[i] > 0 {
|
||||
s += fmt.Sprintf(" %v%% in %s.\n", pctls[i], r.sec2str(data[i]))
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func (r *report) histogram() string {
|
||||
bc := 10
|
||||
buckets := make([]float64, bc+1)
|
||||
counts := make([]int, bc+1)
|
||||
bs := (r.slowest - r.fastest) / float64(bc)
|
||||
for i := 0; i < bc; i++ {
|
||||
buckets[i] = r.fastest + bs*float64(i)
|
||||
}
|
||||
buckets[bc] = r.slowest
|
||||
var bi int
|
||||
var max int
|
||||
for i := 0; i < len(r.lats); {
|
||||
if r.lats[i] <= buckets[bi] {
|
||||
i++
|
||||
counts[bi]++
|
||||
if max < counts[bi] {
|
||||
max = counts[bi]
|
||||
}
|
||||
} else if bi < len(buckets)-1 {
|
||||
bi++
|
||||
}
|
||||
}
|
||||
s := fmt.Sprintf("\nResponse time histogram:\n")
|
||||
for i := 0; i < len(buckets); i++ {
|
||||
// Normalize bar lengths.
|
||||
var barLen int
|
||||
if max > 0 {
|
||||
barLen = counts[i] * 40 / max
|
||||
}
|
||||
s += fmt.Sprintf(" "+r.precision+" [%v]\t|%v\n", buckets[i], counts[i], strings.Repeat(barChar, barLen))
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func (r *report) errors() string {
|
||||
s := fmt.Sprintf("\nError distribution:\n")
|
||||
for err, num := range r.errorDist {
|
||||
s += fmt.Sprintf(" [%d]\t%s\n", num, err)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
|
@ -1,134 +0,0 @@
|
|||
// Copyright 2016 The etcd Authors
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package report
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/csv"
|
||||
"fmt"
|
||||
"log"
|
||||
"math"
|
||||
"sort"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
type DataPoint struct {
|
||||
Timestamp int64
|
||||
AvgLatency time.Duration
|
||||
ThroughPut int64
|
||||
}
|
||||
|
||||
type TimeSeries []DataPoint
|
||||
|
||||
func (t TimeSeries) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
|
||||
func (t TimeSeries) Len() int { return len(t) }
|
||||
func (t TimeSeries) Less(i, j int) bool { return t[i].Timestamp < t[j].Timestamp }
|
||||
|
||||
type secondPoint struct {
|
||||
totalLatency time.Duration
|
||||
count int64
|
||||
}
|
||||
|
||||
type secondPoints struct {
|
||||
mu sync.Mutex
|
||||
tm map[int64]secondPoint
|
||||
}
|
||||
|
||||
func newSecondPoints() *secondPoints {
|
||||
return &secondPoints{tm: make(map[int64]secondPoint)}
|
||||
}
|
||||
|
||||
func (sp *secondPoints) Add(ts time.Time, lat time.Duration) {
|
||||
sp.mu.Lock()
|
||||
defer sp.mu.Unlock()
|
||||
|
||||
tk := ts.Unix()
|
||||
if v, ok := sp.tm[tk]; !ok {
|
||||
sp.tm[tk] = secondPoint{totalLatency: lat, count: 1}
|
||||
} else {
|
||||
v.totalLatency += lat
|
||||
v.count += 1
|
||||
sp.tm[tk] = v
|
||||
}
|
||||
}
|
||||
|
||||
func (sp *secondPoints) getTimeSeries() TimeSeries {
|
||||
sp.mu.Lock()
|
||||
defer sp.mu.Unlock()
|
||||
|
||||
var (
|
||||
minTs int64 = math.MaxInt64
|
||||
maxTs int64 = -1
|
||||
)
|
||||
for k := range sp.tm {
|
||||
if minTs > k {
|
||||
minTs = k
|
||||
}
|
||||
if maxTs < k {
|
||||
maxTs = k
|
||||
}
|
||||
}
|
||||
for ti := minTs; ti < maxTs; ti++ {
|
||||
if _, ok := sp.tm[ti]; !ok { // fill-in empties
|
||||
sp.tm[ti] = secondPoint{totalLatency: 0, count: 0}
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
tslice = make(TimeSeries, len(sp.tm))
|
||||
i int
|
||||
)
|
||||
for k, v := range sp.tm {
|
||||
var lat time.Duration
|
||||
if v.count > 0 {
|
||||
lat = time.Duration(v.totalLatency) / time.Duration(v.count)
|
||||
}
|
||||
tslice[i] = DataPoint{
|
||||
Timestamp: k,
|
||||
AvgLatency: lat,
|
||||
ThroughPut: v.count,
|
||||
}
|
||||
i++
|
||||
}
|
||||
|
||||
sort.Sort(tslice)
|
||||
return tslice
|
||||
}
|
||||
|
||||
func (ts TimeSeries) String() string {
|
||||
buf := new(bytes.Buffer)
|
||||
wr := csv.NewWriter(buf)
|
||||
if err := wr.Write([]string{"UNIX-TS", "AVG-LATENCY-MS", "AVG-THROUGHPUT"}); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
rows := [][]string{}
|
||||
for i := range ts {
|
||||
row := []string{
|
||||
fmt.Sprintf("%d", ts[i].Timestamp),
|
||||
fmt.Sprintf("%s", ts[i].AvgLatency),
|
||||
fmt.Sprintf("%d", ts[i].ThroughPut),
|
||||
}
|
||||
rows = append(rows, row)
|
||||
}
|
||||
if err := wr.WriteAll(rows); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
wr.Flush()
|
||||
if err := wr.Error(); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
return fmt.Sprintf("\nSample in one second (unix latency throughput):\n%s", buf.String())
|
||||
}
|
||||
Loading…
Reference in New Issue