Streamlining GCC Performance: A Guide to NVIDIA's AutoFDO Profile Generation Tool

Overview

AutoFDO (Automatic Feedback-Directed Optimization) is a powerful technique that uses runtime profiling data to guide compiler optimizations, yielding significant performance gains. Traditionally, generating AutoFDO profiles required instrumented binaries, which impose overhead. NVIDIA's compiler engineers are developing a standalone tool to generate AutoFDO profiles directly from sampled hardware performance counters, without instrumentation. This tool aims to be upstreamed into the GCC codebase, making AutoFDO more accessible and efficient for GCC users. This guide explains the concept, prerequisites, and step-by-step workflow for using such a tool, based on current AutoFDO principles and NVIDIA's announced direction.

Prerequisites

System Requirements

A Linux distribution with GCC 12 or later (targeting the eventual upstreamed version).
Perf or similar hardware performance counter sampling tool (e.g., perf record -e cycles).
Access to source code or binaries of the application to be profiled.
Debug information (DWARF) in the binary for accurate profile mapping.

Knowledge Requirements

Basic familiarity with GCC command-line options.
Understanding of profiling concepts (sampling, basic block counts).
Ability to interpret compiler optimization flags (-fauto-profile).

Step-by-Step Instructions

Step 1: Obtain the AutoFDO Generation Tool

Once NVIDIA's tool is released (likely as part of GCC contrib or separate repository), download and compile it. For now, assume a tool named autofdo-generate. Example:

git clone https://github.com/NVIDIA/autofdo-tool.git
cd autofdo-tool
./configure && make
sudo make install

Step 2: Collect Hardware Profile Data

Use Linux perf to sample the application during a representative workload. The key is to capture branch or cycle events at a frequency that produces enough samples.

perf record -e cycles -F 1000 -- ./myapp input.dat

This generates a perf.data file. Ensure the application runs long enough (at least several seconds) to collect statistically meaningful data.

Step 3: Convert Perf Data to AutoFDO Profile

Run the NVIDIA tool to transform the raw sample data into a format compatible with GCC's -fauto-profile. The tool reads perf.data and produces a .afdo file.

autofdo-generate --input=perf.data --output=myapp.afdo --binary=./myapp

The --binary flag ensures correct symbol resolution. For shared libraries, use --libs or provide paths.

Step 4: Rebuild the Application with GCC

Recompile the application (and optionally its dependencies) with the AutoFDO profile. Enable the profile feedback feature.

gcc -O2 -fauto-profile=myapp.afdo -o myapp_opt main.c

For multi-file projects, compile each translation unit with the same profile file, then link.

Step 5: Verify Performance Improvement

Run the optimized binary under the same workload and measure performance. Compare with a baseline compiled without AutoFDO.

time ./myapp_opt input.dat
time ./myapp input.dat  # baseline

Expect 5-20% improvement depending on workload and code structure.

Common Mistakes

Using Inconsistent Binary Versions

Profiling data must come from the exact same binary (same build, same source) used for final compilation. If you change code or optimizations after profiling, the profile becomes invalid. Always profile the baseline binary you intend to optimize.

Insufficient Sample Count

Too few samples lead to sparse profiles, causing GCC to make poor decisions. Ensure your workload runs long enough, or increase sampling frequency (-F). Aim for at least 1 million samples per second of execution.

Missing Debug Information

AutoFDO relies on debug info (DWARF line numbers, CFA) to map samples to source code. Compile the baseline binary with -g. Stripping or failing to include debug info will result in incomplete profiles.

Profiling with System Load Variation

Background processes can skew sample distribution. Run profiling on an isolated machine or use taskset to pin the application to a specific CPU core.

Summary

NVIDIA's upcoming standalone tool promises to simplify AutoFDO profile generation for GCC by leveraging hardware sampling without instrumentation. By following the steps outlined—collecting perf samples, converting to AutoFDO format, and recompiling with -fauto-profile—developers can unlock significant performance gains. Avoid common pitfalls like mismatched binaries or insufficient sampling, and always verify improvements. This approach makes advanced feedback-directed optimization practical for everyday use.