DEV Community

Myoungjin Jeon
Myoungjin Jeon

Posted on • Updated on • Originally published at jeongoon.github.io

Benchmark with Go

Credit

Go Built-in Benchmark and Test

As a modern development tool, go language is shipped with built-in benchmark tool(module)! And there are some rules to follow. let's find out.

File Name with surfix "_test.go"

go test -bench=. in the shell (or command) will find any files have the name ends with _test.go to recognize handle it as a test code. For example I'd like make a benchmark code about combinations, I need to make a file with combinations_test.go

sh> head -n 6 combinations_test.go
package main

import "testing"

/* my own module for go lang */
import jeongoon "github.com/jeongoon/go-combinations"
Enter fullscreen mode Exit fullscreen mode

Package name as "main"

as it says:

package main
Enter fullscreen mode Exit fullscreen mode

otherwise cannot find the module automatically by running go test

  sh> go test -bench=.
  can't load package: package .: found packages main (someCode.go) and in /your/path/to/code
Enter fullscreen mode Exit fullscreen mode

Importing "testing" module

import "testing"
Enter fullscreen mode Exit fullscreen mode

This is the package all we need. simple.

Any Function has prefix "Benchmark"

In your code, there might be some helper function which does not perform benchmark,
On the other hand, your benchmark code should start with Benchmark prefix.

func Benchmark_something(b *testing B) {
        // do your benchmark
}
Enter fullscreen mode Exit fullscreen mode

And also note that the argument it will take is b *testing B.

please note that you don't need to put '_' between Benchmark and something.
you only need Benchmark prefix. That's only personal taste matters.

Issues

Go language has simple and easy rule to follow. however I found some issues about unreliable benchmark time elapsed.

WARNING
This is not proved but only my opinion. I hope this information will help you get more accurate result out of the benchmark in go language.

warming up code

when you are running and compare the performance between two similar functions do the same job. you might need to put some extra codes which wrap around your real benchmark code.

To test aFunc, you might need to put a warming up code before doing that.

func aFunc() {
        // some codes go here
}

func Benchmark_warmingup_aFunc() {
        someTimes := 10
        for j := 0; j < someTimes; j++ {
                aFunc()
        }
}

func Benchmark_actually_aFunc() {
        for j := 0; j < 10000; j++ {
                aFunc()
        }
}
Enter fullscreen mode Exit fullscreen mode

Otherwise the results looks slower on the first run or vice versa.

code after another

I used the same function(aFunc) in the prior example, however when we are comparing other types of codes, we need another warming up code will be required to achieve the even effects as the prior code.

func aFunc() {
        // some codes go here
}

func bFunc() {
        // another implementation goes here
}

// .. snip ..

func Benchmark_actually_bFunc() {
        for j := 0; j < 10000; j++ {
                aFunc()
        }
}

// and warming up again
func Benchmark_warmingup_bFunc() {
        someTimes := 10
        for j := 0; j < someTimes; j++ {
                aFunc()
        }
}

func Benchmark_actually_bFunc() {
        for j := 0; j < 10000; j++ {
                aFunc()
        }
}
Enter fullscreen mode Exit fullscreen mode

outro code for last test

And for some unknown reason, last benchmark does not seems to show correct measured time. Last one looked like finishing rashly. This is because maybe I have perception already. but if the last code block get affected by the position, we will need to re-arrange them to see the changes.

Or just put another outro code. And it will not harm if there was no effect depending on whether it is located on the last or not, either.

So, I tried to put another cFunc or just another aFunc after testing bFunc block.

func Benchmark_actually_bFunc() {
        for j := 0; j < 10000; j++ {
                bFunc()
        }
}
func Benchmark_byebye_aFunc() {
        for j := 0; j < 10; j++ {
                aFunc
        }
Enter fullscreen mode Exit fullscreen mode

Again, I hope it will help you find the more trustful benchmark result out of go benchmark.

If you'd like to get an example of the benchmark code of mine,
please visit my combinations-bench repository.

Top comments (0)