vitalif
/
ceph-gobench
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Round sub-millisecond values to 0.1ms, fix avg speed calculation

master
Vitaliy Filippov 2019-02-27 18:39:13 +03:00
parent bc202f2f55
commit 7b72c2c98e
1 changed files with 36 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
ceph-gobench.go
View File

@ -40,16 +40,27 @@ func bench(cephconn *Cephconnection, osddevice Device, buffs *[][]byte, bs int64
} }
} }
close(threadresult) close(threadresult)
latencygrade := map[int]int{} latencygrade := map[int64]int{}
latencyavg := map[int64]int64{}
latencytotal := int64(0)
for _, lat := range osdlatencies { for _, lat := range osdlatencies {
micro := lat.Nanoseconds()/1000
rounded := micro
switch { switch {
case lat < time.Millisecond*10: case micro < 1000: // 0-1ms round to 0.1ms
latencygrade[int(lat.Round(time.Millisecond).Nanoseconds()/1000000)]++ rounded = (micro/100)*100
case lat < time.Millisecond*100: case micro < 10000: // 2-10ms round to 1ms
latencygrade[int(lat.Round(time.Millisecond*10)/1000000)]++ rounded = (micro/1000)*1000
default: case micro < 100000: // 10-100ms round to 10ms
latencygrade[int(lat.Round(time.Millisecond*100)/1000000)]++ rounded = (micro/10000)*10000
case micro < 1000000: // 100-1000ms round to 100ms
rounded = (micro/100000)*100000
default: // 1000+ms round to 1s
rounded = (micro/1000000)*1000000
} }
latencytotal += micro
latencygrade[rounded]++
latencyavg[rounded] += micro
} }
var buffer bytes.Buffer var buffer bytes.Buffer
@ -83,31 +94,37 @@ func bench(cephconn *Cephconnection, osddevice Device, buffs *[][]byte, bs int64
} }
//sort latencies //sort latencies
var keys []int var keys []int64
for k := range latencygrade { for k := range latencygrade {
keys = append(keys, k) keys = append(keys, k)
latencyavg[k] /= int64(latencygrade[k])
} }
sort.Ints(keys) latencytotal = latencytotal/int64(len(osdlatencies))
sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
for _, k := range keys { for _, k := range keys {
var blocks bytes.Buffer var blocks bytes.Buffer
var mseconds string var mseconds string
switch { switch {
case 10 <= k && k < 20: case k < 1000:
mseconds = green(fmt.Sprintf("[%v-%v]", k, k+9)) mseconds = green(fmt.Sprintf("[%.1f-%.1f)", float64(k)/1000, 0.1+float64(k)/1000))
case 20 <= k && k < 100: case k < 2000:
mseconds = red(fmt.Sprintf("[%v-%v]", k, k+9)) mseconds = yellow(fmt.Sprintf("[%.1f-%.1f)", float64(k)/1000, 0.1+float64(k)/1000))
case k >= 100: case k < 10000:
mseconds = darkred(fmt.Sprintf("[%v-%v]", k, k+99)) mseconds = yellow(fmt.Sprintf("[%3v-%3v)", k/1000, 1+k/1000))
case k < 100000:
mseconds = red(fmt.Sprintf("[%3v-%3v)", k/1000, 10+k/1000))
case k < 1000000:
mseconds = darkred(fmt.Sprintf("[%3v-%3v]", k/1000, 99+k/1000))
default: default:
mseconds = green(k) mseconds = darkred(fmt.Sprintf("[%2vs-%2vs]", k/1000000, 1+k/1000000))
} }
for i := 0; i < 50*(latencygrade[k]*100/len(osdlatencies))/100; i++ { for i := 0; i < 50*(latencygrade[k]*100/len(osdlatencies))/100; i++ {
blocks.WriteString("#") blocks.WriteString("#")
} }
iops := latencygrade[k] / int(params.duration.Seconds()) iops := int64(latencygrade[k]) * 1000 / latencyavg[k]
avgspeed := (float64(latencygrade[k]) * float64(params.blocksize) / float64(params.duration.Seconds())) / 1024 / 1024 //mb/sec avgspeed := (float64(latencygrade[k]) * float64(params.blocksize) / float64(latencyavg[k])) / 1024 / 1024 //mb/sec
megabyteswritten := (float64(latencygrade[k]) * float64(params.blocksize)) / 1024 / 1024 megabyteswritten := (float64(latencygrade[k]) * float64(params.blocksize)) / 1024 / 1024
buffer.WriteString(fmt.Sprintf("%+9v ms: [%-50v] Count: %-5v IOPS: %-5v Avg speed: %-6.3f Mb/Sec Summary written: %6.3f Mb\n", buffer.WriteString(fmt.Sprintf("%+9v ms: [%-50v] Count: %-5v IOPS: %-5v Avg speed: %-6.3f Mb/Sec Total written: %6.3f Mb\n",
mseconds, blocks.String(), latencygrade[k], iops, avgspeed, megabyteswritten)) mseconds, blocks.String(), latencygrade[k], iops, avgspeed, megabyteswritten))
} }
result <- buffer.String() result <- buffer.String()