8-3 使用pprof进行性能调优
一、介绍pprof
go test -bench . -cpuprofile cpu.out
go tool pprof cpu.out
指定某个测试_test.go文件
go test -bench . -v nonrepeating_end_test.go
go test -bench . -cpuprofile cpu.out -v nonrepeating_end_test.go
测试更多方面的信息
go test -bench . -cpuprofile cpu.out
查看CPU结果
go tool pprof cpu.out //此时进入交互式命令，可以输入help查看帮助
web //自动弹出网页展示svg图查看结果
注意，如果报错：Failed to execute dot. Is Graphviz installed? Error: exec: "dot": executable file not found in %PATH%
请到http://www.graphviz.org/download/下载Graphviz, 并配置到环境变量中,将bin目录配置到PATH。
二、实践
1.第一个版本代码
package main
import (
"testing"
)
func lengthOfNonRepeatingSubStr(s string) int {
//lastOccurred := make(map[byte]int)
lastOccurred := make(map[rune]int)
start := 0
maxLength := 0
//for i, ch := range []byte(s) {
for i, ch := range []rune(s) {
if lastI, ok := lastOccurred[ch]; ok && lastI >= start {
start = lastOccurred[ch] + 1
}
if i-start+1 > maxLength {
maxLength = i - start + 1
}
lastOccurred[ch] = i
}
return maxLength
}
func TestSubstr(t *testing.T) {
tests := []struct {
s string
ans int
} {
// Normal cases
{"abcabcbb", 3},
{"pwwkew", 3},
// Edge cases
{"", 0},
{"b", 1},
{"bbbbbbbb", 1},
{"abcabcabcd", 4},
// Chinense cases
{"这里是慕课网", 6},
{"一二三二一", 3},
{"黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花", 8},
}
for _, tt := range tests {
actual := lengthOfNonRepeatingSubStr(tt.s)
if actual != tt.ans {
t.Errorf("got %d for input %s; " +
"expected %d",
actual, tt.s, tt.ans)
}
}
}
func BenchmarkSubstr(b *testing.B) {
s := "黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花"
ans := 8
for i := 0; i < b.N; i++ {
actual := lengthOfNonRepeatingSubStr(s)
if actual != ans {
b.Errorf("got %d for input %s; " +
"expected %d",
actual, s, ans)
}
}
}
发现性能差在map赋值，rune的utf8 decode
2.
将map（hash实现）修改slice
package main
import (
"testing"
)
func lengthOfNonRepeatingSubStr(s string) int {
//lastOccurred := make(map[byte]int)
//lastOccurred := make(map[rune]int)
// 测试性能优化
// stores las occurred pos + 1.
// 0 means not seen
var lastOccurred = make([]int, 0xffff)
start := 0
maxLength := 0
//for i, ch := range []byte(s) {
for i, ch := range []rune(s) {
if lastI := lastOccurred[ch]; lastI > start {
start = lastI
}
if i-start+1 > maxLength {
maxLength = i - start + 1
}
lastOccurred[ch] = i + 1
}
return maxLength
}
func TestSubstr(t *testing.T) {
tests := []struct {
s string
ans int
} {
// Normal cases
{"abcabcbb", 3},
{"pwwkew", 3},
// Edge cases
{"", 0},
{"b", 1},
{"bbbbbbbb", 1},
{"abcabcabcd", 4},
// Chinense cases
{"这里是慕课网", 6},
{"一二三二一", 3},
{"黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花", 8},
}
for _, tt := range tests {
actual := lengthOfNonRepeatingSubStr(tt.s)
if actual != tt.ans {
t.Errorf("got %d for input %s; " +
"expected %d",
actual, tt.s, tt.ans)
}
}
}
func BenchmarkSubstr(b *testing.B) {
s := "黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花"
ans := 8
for i := 0; i < b.N; i++ {
actual := lengthOfNonRepeatingSubStr(s)
if actual != ans {
b.Errorf("got %d for input %s; " +
"expected %d",
actual, s, ans)
}
}
}
发现图像变得复杂，耗时花在gc上，垃圾回收
3.
package main
import (
"testing"
)
var lastOccurred = make([]int, 0xffff)
func lengthOfNonRepeatingSubStr(s string) int {
//lastOccurred := make(map[byte]int)
//lastOccurred := make(map[rune]int)
// 测试性能优化
// stores las occurred pos + 1.
// 0 means not seen
for i := range lastOccurred {
lastOccurred[i] = 0
}
start := 0
maxLength := 0
//for i, ch := range []byte(s) {
for i, ch := range []rune(s) {
if lastI := lastOccurred[ch]; lastI > start {
start = lastI
}
if i-start+1 > maxLength {
maxLength = i - start + 1
}
lastOccurred[ch] = i + 1
}
return maxLength
}
func TestSubstr(t *testing.T) {
tests := []struct {
s string
ans int
} {
// Normal cases
{"abcabcbb", 3},
{"pwwkew", 3},
// Edge cases
{"", 0},
{"b", 1},
{"bbbbbbbb", 1},
{"abcabcabcd", 4},
// Chinense cases
{"这里是慕课网", 6},
{"一二三二一", 3},
{"黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花", 8},
}
for _, tt := range tests {
actual := lengthOfNonRepeatingSubStr(tt.s)
if actual != tt.ans {
t.Errorf("got %d for input %s; " +
"expected %d",
actual, tt.s, tt.ans)
}
}
}
func BenchmarkSubstr(b *testing.B) {
s := "黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花"
ans := 8
for i := 0; i < b.N; i++ {
actual := lengthOfNonRepeatingSubStr(s)
if actual != ans {
b.Errorf("got %d for input %s; " +
"expected %d",
actual, s, ans)
}
}
}
可以发现耗时消耗在
for i := range lastOccurred {
lastOccurred[i] = 0
}
所以我们，准备一个长的字符串，保证最大的耗时不是在memclr
4.
package main
import (
"testing"
)
var lastOccurred = make([]int, 0xffff)
func lengthOfNonRepeatingSubStr(s string) int {
//lastOccurred := make(map[byte]int)
//lastOccurred := make(map[rune]int)
// 测试性能优化
// stores las occurred pos + 1.
// 0 means not seen
for i := range lastOccurred {
lastOccurred[i] = 0
}
start := 0
maxLength := 0
//for i, ch := range []byte(s) {
for i, ch := range []rune(s) {
if lastI := lastOccurred[ch]; lastI > start {
start = lastI
}
if i-start+1 > maxLength {
maxLength = i - start + 1
}
lastOccurred[ch] = i + 1
}
return maxLength
}
func TestSubstr(t *testing.T) {
tests := []struct {
s string
ans int
} {
// Normal cases
{"abcabcbb", 3},
{"pwwkew", 3},
// Edge cases
{"", 0},
{"b", 1},
{"bbbbbbbb", 1},
{"abcabcabcd", 4},
// Chinense cases
{"这里是慕课网", 6},
{"一二三二一", 3},
{"黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花", 8},
}
for _, tt := range tests {
actual := lengthOfNonRepeatingSubStr(tt.s)
if actual != tt.ans {
t.Errorf("got %d for input %s; " +
"expected %d",
actual, tt.s, tt.ans)
}
}
}
func BenchmarkSubstr(b *testing.B) {
s := "黑化肥挥发发灰会花飞灰化肥挥发发黑会飞花"
for i := 0; i < 13; i++ {
s = s + s
}
b.Logf("len(s) = %d", len(s))
ans := 8
// 防止生成s计算在时间里
b.ResetTimer()
for i := 0; i < b.N; i++ {
actual := lengthOfNonRepeatingSubStr(s)
if actual != ans {
b.Errorf("got %d for input %s; " +
"expected %d",
actual, s, ans)
}
}
}
因为现在字符串很长，所以decode占用耗时最大
总结：
