In this tutorial, We are going to learn about BlockProfile of runtime package in go with example in details.
BlockProfile of runtime package in go records the time spent waiting for synchronization primitives such as mutexes and channels. BlockProfile provides facilities for collecting and analyzing profiling data. Block profiling helps developers identify bottlenecks caused by contention or synchronization issues. By analyzing the data, you can optimize your program’s performance by reducing contention or parallelizing work.
Using BlockProfile
To use BlockProfile, you must first enable block profiling in your program. You can do this by setting the BlockProfileRate, which determines the fraction of goroutine blocking events that are recorded. A higher rate will provide more accurate profiling data but will also increase the overhead.
Example:
package main
import (
"fmt"
"os"
"runtime"
"runtime/pprof"
"sync"
"time"
)
func slowFunction() {
time.Sleep(100 * time.Millisecond)
}
func main() {
runtime.SetBlockProfileRate(1) // Enable block profiling
f, err := os.Create("block_profile.prof")
if err != nil {
fmt.Println(err)
return
}
defer f.Close()
wg := sync.WaitGroup{}
wg.Add(10)
for i := 0; i < 10; i++ {
go func() {
mu := sync.Mutex{}
mu.Lock()
defer mu.Unlock()
slowFunction()
wg.Done()
}()
}
wg.Wait()
pprof.Lookup("block").WriteTo(f, 0)
}
In this example, we first enable block profiling by calling ‘runtime.SetBlockProfileRate(1)’. We create a file called ‘block_profile.prof’ to store the BlockProfile data. The program simulates contention by running 10 goroutines that lock a mutex and call a slow function. After waiting for the goroutines to finish, we write the block profile data to the file using ‘pprof.Lookup(“block”).WriteTo(f, 0)’.
Analyzing BlockProfile Data
To analyze the BlockProfile data, use the ‘go tool pprof’ command-line interface:
$ go tool pprof block_profile.prof
Using the ‘top‘ command in the pprof tool, you can see the functions that contributed the most to blocking time. In our example, you would observe that the ‘slowFunction’ is the primary source of contention.
Output:
(pprof) top
Showing nodes accounting for 2s, 100% of 2s total
flat flat% sum% cum cum%
2s 100% 100% 2s 100% sync.(*WaitGroup).Wait
0 0% 100% 2s 100% main.main
0 0% 100% 2s 100% runtime.main
Optimizing the Code
Based on the BlockProfile data, you can take steps to optimize your code. For example, in this case, we could parallelize the slow function or use a more efficient locking mechanism to reduce contention and improve performance.
To learn more about golang, You can refer given below link:
https://www.techieindoor.com/go-runtime-package-in-go/
References: