Go Language Performance Analysis Practical: Optimizing your application with pprof

When developing high-performance Go applications, performance analysis is a crucial part. Go has a powerful performance analysis tool built into pprof, which can help us gain an in-depth understanding of the running status of the program, discover performance bottlenecks and optimize it. This article will introduce how to use pprof for performance analysis of Go applications based on practical cases.

What is pprof?

pprof is a performance analysis tool developed by Google, and Go has built-in support for pprof. It helps us analyze key performance indicators such as CPU usage, memory allocation, blocking operations, and goroutine status of the program.

Enabling pprof

Enabling pprof in a Go application is very simple, you just need to import the pprof package:

import _ "net/http/pprof"

Then start an HTTP server:

go func() {
    http.ListenAndServe("localhost:6060", nil)
}()

Main analysis types

pprof provides multiple types of performance analysis:

1. CPU analyzes

Analyze the CPU usage of the program and find out the most CPU-consuming functions.

2. Memory analysis (heap)

Analyze the memory allocation of the program to find out the parts of memory that use the most.

3. Goroutine analysis

Analyze the status of goroutine and check for goroutine leaks.

4. blocking analysis

Analyze blocking operations in programs, such as channel, mutex, etc.

Actual case analysis

In our project, pprof analysis found that memory is mainly allocated in the following modules:

Sensitive word filtering module

The github.com/iohub/ahocorasick package consumes a lot of memory
- Matcher.buildFails: 44.62%
- Cedar.childs: 17.59%

This part of memory allocation is normal because the AC automaton algorithm needs to allocate a large number of nodes to build a state transition table during construction.

Mailbox Verification Module

The github.com/AfterShip/email-verifier package creates a large number of data structures during initialization

This is a one-time overhead at package initialization and will not continue to grow.

Container list operation

Memory allocation for container/list package accounts for 28.23%

This part mainly comes from the data structure operation within the sensitive word filtering module.

Performance optimization recommendations

1. Monitor memory growth trends

Focus on whether memory usage continues to grow over time, with stable memory usage indicating no leaks.

2. Optimizing Sensitive Word Filtering Algorithm

If the number of sensitive words is large, consider:

• Implementation of optimized AC automata
• Use more efficient filtering algorithms for sensitive words
• Group sensitive words

3. Regularly check pprof data

Run pprof under different loads and compare memory allocations to ensure memory usage is within acceptable ranges.

Experimental Garbage Collector

Go 1.25 introduces an experimental garbage collector (greenteagc) that can be enabled in the following ways:

GOEXPERIMENT=greenteagc go run main.go

The garbage collector improves the performance of small object marking and scanning through better locality and CPU scalability, and is expected to reduce garbage collection overhead by 10-40%.

Conclusion

Through the pprof tool, we can gain an in-depth understanding of the performance characteristics of Go applications and discover potential performance issues. In our case, memory allocation is mainly concentrated on business logic modules, which is normal. The key is to monitor whether memory continues to grow and performance under high loads.

Using pprof for performance analysis should be part of Go developers 'daily workflow, and it can help us build more efficient and stable Go applications.