Profile-Guided Optimization (PGO) Principles and Practice in Go and C++

Profile-Guided Optimization (PGO), also known as feedback-directed optimization (FDO), uses runtime profiling data to recompile programs for better performance.

The typical PGO workflow consists of three steps: (1) compile the program with instrumentation flags (e.g., -fprofile-instr-generate for Clang) to generate a profile file during execution; (2) run the instrumented binary on realistic workloads to collect profiling data; (3) recompile the program using the collected profile data, dropping the instrumentation flags, to produce an optimized binary.

PGO improves performance by reducing branch mispredictions, optimizing code layout, enhancing instruction cache usage, and enabling more aggressive optimizations such as function inlining and register allocation based on hot paths identified in the profile.

In Go, PGO support began with Go 1.20 (disabled by default) and became enabled by default in Go 1.21 via the -pgo=auto flag. A CPU pprof profile (obtainable via runtime/pprof or net/http/pprof) is required. Profiles from multiple instances can be merged using go tool pprof -proto a.pprof b.pprof > merged.pprof . The build command is go build -pgo=/pprof/main.pprof . Go’s PGO implementation provides source stability and iteration stability, allowing the optimizer to gracefully handle code changes.

Practical tests on a Go sidecar service showed roughly a 5% performance gain after enabling PGO with Go 1.21, aligning with the official 2‑7% improvement range.

For C++, PGO can improve register allocation, loop vectorization, and branch prediction accuracy. A key optimization is speculative devirtualization: when the profile shows that a virtual function call most often resolves to a specific override, the compiler can replace the indirect call with a direct call followed by a guard, enabling further inlining.

The article includes an example demonstrating how adding the final specifier to a class allows devirtualization, turning an indirect call into a direct one, and shows the corresponding assembly transformation:

if condition { // 执行逻辑1 } else { // 执行逻辑2 }

class A { public: virtual int foo() { return 0; } };

class B : public A { public: int foo() final { return 2; } };

movq %rsp, %rbp

movl $2, %eax

Performance evaluation of Envoy (V1.26.0) compiled with Clang14 showed that enabling PGO increased single‑core QPS from ~20k to ~23.7k (≈15‑18% gain) and reduced average latency from 4.87 ms to 4.28 ms (≈14‑18% reduction).

Future PGO work in Go and C++ may expand to areas such as function block ordering, register allocation based on hot paths, global block sorting, indirect call devirtualization, template specialization, and pre‑allocation of maps/slices.