Hands-on Go profiling What is Go profiling? When and how to use it? and how to utilize Go build-in tools to search for bottlenecks and optimize our code. In this live demo session, we'll go over multiple examples and learn how to read the pprof output. We'll share some tips and ticks, as well as an overview of multiple open source Go profiling tools. OpsTalk presentation "Let's talk about debugging" held at January 21, 2018 in Here Mobility office, Ra'anana, Israel.

1. Hands-on Go
Profiling
Daniel Ammar

2. •‫ה‬Be the Central Hub of All
Mobility Services Exposures and Consumption

4. Agenda
• Introduction
• Profiling in Golang
- CPU Profiler
- Memory Profiler
- Block Profiler
- Goroutine Profiler
- Mutex Profiler
• runtime/trace
• Community additions
• D e m o
• Caveats
• Q&A*

5. 01
Profiling

6. Profiling
https://stackify.com/what-is-code-profiling/

7. Diagnostics
• Profiling: analyze the complexity and costs of a program such as its
memory, cpu cycles etc
• Tracing: Tracing is a way to instrument code to analyze latency
throughout the lifecycle of a request
• Debugging: Debugging allows us to pause a Go program and examine
its execution.
• Runtime statistics and events: Collection and analysis of runtime
stats and events provides a high-level overview of the health of a
program.

8. Profiling in Go
https://blog.golang.org/profiling-go-programs

9. Profiling in Go
• go test flags
• Manual profile collection
• Import “net/http/pprof” package for
side effect
• go tool pprof/trace command
• Community tools
DatacollectionDatavisualization

10. Built-in Profiles
• CPU
Determines where a program spends its time while actively consuming CPU cycles (as
opposed to while sleeping or waiting for I/O)
Sampled 100 times per second (default)
• Memory
Reports current and historical memory allocation samples
Sampled per allocation of 512KB (default)
• Block
Reports where goroutines block waiting on synchronization primitives (including
timer channels)
Not enabled by default (runtime.SetBlockProfileRate(ns))
• Goroutine
Reports the stack traces of all current goroutines
• Mutex
Reports lock contentions
Not enabled by default (runtime.SetMutexProfileFraction)

11. Runtime/trace
The tracer captures a wide range of execution events by looking directly
into the goroutine scheduling implementation.
In contrast to runtime/pprof sampling nature, the tracer gets notified
when an event occurs:
• goroutine creation/blocking/unblocking,
• syscall enter/exit/block
• GC-related events
• changes of heap size
• processor start/stop
• …

12. Community tools
• pprof - a tool for visualization and analysis of profiling data -
https://github.com/google/pprof
• Go-torch flame graph - https://github.com/uber/go-torch
• Gom a visual interface - https://github.com/rakyll/gom

13. 02
Demo

14. Fibonacci example
package main
import (
"log"
"os"
"runtime/pprof"
)
func main() {
f, err := os.Create("cpu.pprof")
if err != nil {
log.Fatal("Error creating file")
}
if err := pprof.StartCPUProfile(f); err != nil {
log.Fatal("Failed to start CPU profile: ", err)
}
defer pprof.StopCPUProfile()
z := Fibonacci(42)
log.Printf("The 42nd Fibonacci number is %dn", z)
}
func Fibonacci(n int) int {
if n < 2 {
return n
}
return Fibonacci(n-1) + Fibonacci(n-2)
}

15. Fibonacci with 10Mb example
package main
import (
"log"
"net/http"
_ "net/http/pprof"
)
func bigBytes() *[]byte {
s := make([]byte, 1000000)
return &s
}
func main() {
go func() {
log.Fatal(http.ListenAndServe(":6060", nil))
}()
for i := 0; i < 10; i++ {
s := bigBytes()
if s == nil {
log.Println("can't allocate memory")
}
}
z := Fibonacci(42)
log.Printf("The 42nd Fibonacci number is %dn", z)
select {}
}
func Fibonacci(n int) int {
if n < 2 {
return n
}
return Fibonacci(n-1) + Fibonacci(n-2)
}

16. Regex Example
Move method variable to by initialized once, i.e., outside the function
var regx = regexp.MustCompile(`^w*$`)

17. Runtime/trace Example
In theory many small & short-lived goroutines are excellent way to
handle CPU intensive tasks.
In practice our program will stay most of its time in context switching

18. Caveats
• Profilers affect service!
• Profiles are only as good as the kernel support used to generate
them
• Can interfere with each other
• runtime.pprof is sample based
• Benchmarking not on a shared host (noisy neighbors problem)
• Known bugs - https://github.com/golang/go/issues/13841

19. Q&A

20. Thank you