Skip to main content

Benchmarking in Go

Considered one of the more powerful features of Go, benchmarking allows you to measure and monitor the performance of your code. As a result, you'll be able to find bottlenecks and areas for improvement in your applications. Benchmarking in Go is made easier by the built-in testing tools in the language.

In this tutorial, we'll learn about benchmarking in Go, how to write benchmark tests, and how to interpret the results.

What is Benchmarking?​

Benchmarking is the process of measuring the performance of a piece of code or a system, under a certain load, to understand its efficiency and effectiveness. In Go, benchmark functions allow you to test the performance of your code by running it multiple times and measuring the time it takes.

Writing a Benchmark in Go​

In Go, benchmark tests reside in a _test.go file, and each of them must begin with the word Benchmark, take a pointer to testing.B, and return nothing.

Here is a simple benchmark function:

package main

import (
    "testing"
)

func BenchmarkExample(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // Your code here
    }
}

The b.N gives a large enough number to get a reasonable measurement. The testing.B will adjust b.N until it's satisfied with the stability of the benchmark result.

Running Benchmarks​

To run a benchmark, use the go test command with the -bench flag, which takes a regular expression that matches the benchmarks to be run.

go test -bench=.

The . after the = sign is a regular expression that matches all benchmarks in your package. If you want to match a specific benchmark, replace the . with the name of the benchmark.

Understanding Benchmark Results​

A benchmark result might look something like this:

BenchmarkExample-8      1000000000           0.275 ns/op

In this line, BenchmarkExample-8 is the name of the benchmark and the 8 signifies the number of CPUs involved in the process. 1000000000 is the number of iterations ran by the benchmark. 0.275 ns/op tells you that each operation took an average of 0.275 nanoseconds.

Benchmarking HTTP Server​

Let's take a real-world example. Suppose, you have a HTTP server and you want to measure its performance. Here's how you can do it:

package main

import (
    "net/http"
    "net/http/httptest"
    "testing"
)

func BenchmarkExample(b *testing.B) {
    handler := func(w http.ResponseWriter, r *http.Request) {}
    req := httptest.NewRequest("GET", "http://example.com/foo", nil)
    w := httptest.NewRecorder()

    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        handler(w, req)
    }
}

In this example, we're simulating a HTTP GET request to 'http://example.com/foo' and measuring how long it takes for the handler to process the request.

Remember, benchmarking is not only about writing benchmark tests, but also about understanding the results and using them to improve the performance of your code. It's an ongoing process that should be a part of your development cycle.

In conclusion, the Go language's built-in benchmarking feature is a powerful tool for performance testing. By using it effectively, you can write efficient and performant Go code.