Using AutoFDO with the Linux kernel

This enables AutoFDO build support for the kernel when usingthe Clang compiler. AutoFDO (Auto-Feedback-Directed Optimization)is a type of profile-guided optimization (PGO) used to enhance theperformance of binary executables. It gathers information about thefrequency of execution of various code paths within a binary usinghardware sampling. This data is then used to guide the compiler’soptimization decisions, resulting in a more efficient binary. AutoFDOis a powerful optimization technique, and data indicates that it cansignificantly improve kernel performance. It’s especially beneficialfor workloads affected by front-end stalls.

For AutoFDO builds, unlike non-FDO builds, the user must supply aprofile. Acquiring an AutoFDO profile can be done in several ways.AutoFDO profiles are created by converting hardware sampling usingthe “perf” tool. It is crucial that the workload used to create theseperf files is representative; they must exhibit runtimecharacteristics similar to the workloads that are intended to beoptimized. Failure to do so will result in the compiler optimizingfor the wrong objective.

The AutoFDO profile often encapsulates the program’s behavior. If theperformance-critical codes are architecture-independent, the profilecan be applied across platforms to achieve performance gains. Forinstance, using the profile generated on Intel architecture to builda kernel for AMD architecture can also yield performance improvements.

There are two methods for acquiring a representative profile:(1) Sample real workloads using a production environment.(2) Generate the profile using a representative load test.When enabling the AutoFDO build configuration without providing anAutoFDO profile, the compiler only modifies the dwarf information inthe kernel without impacting runtime performance. It’s advisable touse a kernel binary built with the same AutoFDO configuration tocollect the perf profile. While it’s possible to use a kernel builtwith different options, it may result in inferior performance.

One can collect profiles using AutoFDO build for the previous kernel.AutoFDO employs relative line numbers to match the profiles, offeringsome tolerance for source changes. This mode is commonly used in aproduction environment for profile collection.

In a profile collection based on a load test, the AutoFDO collectionprocess consists of the following steps:

  1. Initial build: The kernel is built with AutoFDO optionswithout a profile.

  2. Profiling: The above kernel is then run with a representativeworkload to gather execution frequency data. This data iscollected using hardware sampling, via perf. AutoFDO is mosteffective on platforms supporting advanced PMU features likeLBR on Intel machines.

  3. AutoFDO profile generation: Perf output file is converted tothe AutoFDO profile via offline tools.

The support requires a Clang compiler LLVM 17 or later.

Preparation

Configure the kernel with:

CONFIG_AUTOFDO_CLANG=y

Customization

The default CONFIG_AUTOFDO_CLANG setting covers kernel space objects forAutoFDO builds. One can, however, enable or disable AutoFDO build forindividual files and directories by adding a line similar to the followingto the respective kernel Makefile:

  • For enabling a single file (e.g. foo.o)

    AUTOFDO_PROFILE_foo.o := y
  • For enabling all files in one directory

    AUTOFDO_PROFILE := y
  • For disabling one file

    AUTOFDO_PROFILE_foo.o := n
  • For disabling all files in one directory

    AUTOFDO_PROFILE := n

Workflow

Here is an example workflow for AutoFDO kernel:

  1. Build the kernel on the host machine with LLVM enabled,for example,

    $ make menuconfig LLVM=1

    Turn on AutoFDO build config:

    CONFIG_AUTOFDO_CLANG=y

    With a configuration that with LLVM enabled, use the following command:

    $ scripts/config -e AUTOFDO_CLANG

    After getting the config, build with

    $ make LLVM=1
  2. Install the kernel on the test machine.

  3. Run the load tests. The ‘-c’ option in perf specifies the sampleevent period. We suggest using a suitable prime number, like 500009,for this purpose.

    • For Intel platforms:

      $ perf record -e BR_INST_RETIRED.NEAR_TAKEN:k -a -N -b -c <count> -o <perf_file> -- <loadtest>
    • For AMD platforms:

      The supported systems are: Zen3 with BRS, or Zen4 with amd_lbr_v2. To check,

      For Zen3:

      $ cat /proc/cpuinfo | grep " brs"

      For Zen4:

      $ cat /proc/cpuinfo | grep amd_lbr_v2

      The following command generated the perf data file:

      $ perf record --pfm-events RETIRED_TAKEN_BRANCH_INSTRUCTIONS:k -a -N -b -c <count> -o <perf_file> -- <loadtest>
  4. (Optional) Download the raw perf file to the host machine.

  5. To generate an AutoFDO profile, two offline tools are available:create_llvm_prof and llvm_profgen. The create_llvm_prof tool is partof the AutoFDO project and can be found on GitHub(https://github.com/google/autofdo), version v0.30.1 or later.The llvm_profgen tool is included in the LLVM compiler itself. It’simportant to note that the version of llvm_profgen doesn’t need to matchthe version of Clang. It needs to be the LLVM 19 release of Clangor later, or just from the LLVM trunk.

    $ llvm-profgen --kernel --binary=<vmlinux> --perfdata=<perf_file> -o <profile_file>

    or

    $ create_llvm_prof --binary=<vmlinux> --profile=<perf_file> --format=extbinary --out=<profile_file>

    Note that multiple AutoFDO profile files can be merged into one via:

    $ llvm-profdata merge -o <profile_file> <profile_1> <profile_2> ... <profile_n>
  6. Rebuild the kernel using the AutoFDO profile file with the same config as step 1,(Note CONFIG_AUTOFDO_CLANG needs to be enabled):

    $ make LLVM=1 CLANG_AUTOFDO_PROFILE=<profile_file>