一、benchmark的使用

1.一個簡單的例子

go mod init test 創(chuàng)建項目test,創(chuàng)建目錄bench/fib

創(chuàng)建fib.go

package fib
 
func fib(n int) int {
	if n == 0 || n == 1 {
		return n
	}
	return fib(n-1) + fib(n-2)
}

創(chuàng)建fib_test.go

package fib
 
import (
	"testing"
)
 
func BenchmarkFib(b *testing.B) {
	for i := 0; i < b.N; i++ {
		fib(30)
	}
}

go 不管是單元測試還是基準測試，測試函數(shù)都應該寫在以_test.go 為結尾的文件中。

go 單元測試函數(shù)以Test開頭,函數(shù)參數(shù)為*testing.T

go 基準測試函數(shù)以Bench開頭，函數(shù)參數(shù)為*testing.B

2.運行用例

如何運行測試用例呢？

運行單元測試：go test -run=xxx，其中xxx為正則表達式，用來匹配單元測試函數(shù)的函數(shù)名。

運行基準測試：go test -bench=xxx，其中xxx為正則表達式，用來匹配基準測試函數(shù)的函數(shù)名。

上述命令只能運行當前目錄中的測試用例，如果想運行其他目錄的測試用例呢？

go test -bench=. test/bench/fib  ，指定目標包在項目中的絕對路徑。

go test -bench=. ./fib  , 運行當前目錄下的子目錄fib中的測試。

go test -bench=. ./... , 運行當前目錄下的所有的package中的測試。

對-bench=加上正則表達式：

go test -bench=^BenchmarkFib ./fib

3.benchmark 是如何工作的

benchmark用例的參數(shù)為b testing.B, b.N 表示要測試的內(nèi)容運行的次數(shù)，這個次數(shù)對于每個用例都不同。那么這個次數(shù)變化規(guī)律是什么呢？b.N從1開始，如果內(nèi)容在1s內(nèi)運行結束，那么b.N會增加，測試會再次執(zhí)行。b.N 的值大概以 1, 2, 3, 5, 10, 20, 30, 50, 100 這樣的序列遞增，越到后面，增加得越快。

修改測試的內(nèi)容，讓運行時間>1s

func BenchmarkFib(b *testing.B) {
	for i := 0; i < b.N; i++ {
		time.Sleep(time.Second)
		fib(30)
	}
}

 可以看到，只執(zhí)行了1次。

benchmarkFib-12 的-12的意思是 GOMAXPROCS數(shù)，即cpu核數(shù)，可以使用-cpu來指定cpu核數(shù)，-cpu=2,3  表示分別使用GOMAXPROCS=2 和GOMAXPROCS=3 進行測試。

可以看到測試用例運行了兩輪，分別以單核和12核，但我們的測試結果沒有發(fā)生變化，因為我們的測試內(nèi)容本身是單核的，與多核無緣。

4.提升準確度

對于性能測試來說，提升測試精度的一個重要手段是提升測試時間和測試次數(shù)。我們可以是用-benchtime 和 -count 來達到目的。

benchmark 默認的benchtime是1s,我們指定2s,可以看到執(zhí)行次數(shù)也提升了約1倍。

我們還能直接指定b.N ,即 -benchtime=30x 表示30次

那么count就是測試的輪數(shù)了，-count=2 測試兩輪。

5.內(nèi)存分配情況

前面的測試結果中，只能看見執(zhí)行的次數(shù)和一次執(zhí)行的時間，沒有任何與內(nèi)存相關的信息。加入 -benchmem 就可以看到。

 因為fib函數(shù)使用的空間全在棧上，不需要進行內(nèi)存分配。

下面測試切片的內(nèi)存分配。創(chuàng)建目錄 bench/cap

cap.go

// 一次性分配空間
func generateWithCap(n int) []int {
	rand.Seed(time.Now().UnixNano())
	nums := make([]int, 0, n)
	for i := 0; i < n; i++ {
		nums = append(nums, rand.Int())
	}
	return nums
}
 
// 多次分配空間
func generate(n int) []int {
	rand.Seed(time.Now().UnixNano())
	nums := make([]int, 0)
	for i := 0; i < n; i++ {
		nums = append(nums, rand.Int())
	}
	return nums
}

cap_test.go

package cap
 
import "testing"
 
func BenchmarkGenerateWithCap(b *testing.B) {
	for n := 0; n < b.N; n++ {
		generateWithCap(1000000)
	}
}
 
func BenchmarkGenerate(b *testing.B) {
	for n := 0; n < b.N; n++ {
		generate(1000000)
	}
}

 測試結果：

可以看到：

        一次性分配內(nèi)存的切片賦值函數(shù)比多次分配內(nèi)存的切片賦值函數(shù)消耗內(nèi)存更少。

        一次性分配內(nèi)存的切片賦值函數(shù)運行時間更少，因為內(nèi)存分配需要耗時間。

6.測試不同的輸入

  不同函數(shù)的復雜度不同，O(1)、O(n)、O(lgn)等，利用 benchmark 驗證復雜度一個簡單的方式，是構造不同的輸入，對剛才的generate函數(shù)構建不同的輸入可以達到這個目的。

  cap_test.go

func benchmarkGenerate(n int, b *testing.B) {
	for i := 0; i < b.N; i++ {
		generate(n)
	}
}
 
func BenchmarkGenerate1000(b *testing.B)    { benchmarkGenerate(1000, b) }
func BenchmarkGenerate10000(b *testing.B)   { benchmarkGenerate(10000, b) }
func BenchmarkGenerate100000(b *testing.B)  { benchmarkGenerate(100000, b) }
func BenchmarkGenerate1000000(b *testing.B) { benchmarkGenerate(1000000, b) }

隨著輸入按10倍的速度增長，運行時間也按10倍在增長，則函數(shù)的復雜度是線性的，即O(n).

二、benchmark的注意事項

1.ResetTimer

如果在正式執(zhí)行測試前需要進行準備工作，那么在準備工作完成后，可以使用b.ResetTimer() 函數(shù)來重置計數(shù)器。

使用sleep模擬耗時的準備工作。

fib_test.go 

func BenchmarkFib(b *testing.B) {
	time.Sleep(time.Second)
	for i := 0; i < b.N; i++ {
		fib(30)
	}
}

每次執(zhí)行fib(30)高達1s多，顯然不對。

使用b.ResetTimer()

 fib_test.go

func BenchmarkFib(b *testing.B) {
	time.Sleep(time.Second)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		fib(30)
	}
}

我們將耗時的準備工作排除在測試之外，每次調(diào)用fib(30)花費 6ms = 0.006s 

2.StopTimer & StartTimer

如果在每一次函數(shù)前后都需要準備工作和清理工作，那么就需要StopTimer + StartTimer 函數(shù)了。

例：

     sort_test.go

// 一次性分配空間
func generateWithCap(n int) []int {
	rand.Seed(time.Now().UnixNano())
	nums := make([]int, 0, n)
	for i := 0; i < n; i++ {
		nums = append(nums, rand.Int())
	}
	return nums
}
 
 
//冒泡排序
func bubbleSort(nums []int) {
	for i := 0; i < len(nums); i++ {
		for j := 1; j < len(nums)-i; j++ {
			if nums[j] < nums[j-1] {
				nums[j], nums[j-1] = nums[j-1], nums[j]
			}
		}
	}
}
 
func BenchmarkBubbleSort(b *testing.B) {
	for n := 0; n < b.N; n++ {
        //暫停計時
		b.StopTimer()
		nums := generateWithCap(10000)
        //繼續(xù)計時
		b.StartTimer()
		bubbleSort(nums)
	}
}

顯然我們只測試到排序的性能，沒有將內(nèi)存分配的時間花費算入結果。

每次排序需花費120ms的時間。

到此這篇關于go benchmark 基準測試的文章就介紹到這了,更多相關go 基準測試內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！