Re: [PATCH v2 1/6] Add AutoFDO support for Clang build

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 

I removed the "code-block" directives from the rst files,
and used "::" suggested by Jonathan. The rst files themselves are now
easier to read in vi.  However, the rendered HTML output has some differences:
(1) The text that was previously in code-block no longer indents. It aligns
      with the preceding text, regardless of how many spaces I add.
(2) Previously, "code-block" removed '\' and combined the text into a
single line.
     This is no longer happening -- the '\' is not expanded.

These differences do not seem to be a blocker. I'm attaching the html files to
this email. If there is no objection, I'll change to using the new
method of "::".

-Rong

On Sat, Oct 5, 2024 at 7:43 AM Jonathan Corbet <corbet@xxxxxxx> wrote:
>
> Kees Cook <kees@xxxxxxxxxx> writes:
>
> > The tradition in kernel .rst is to do this with the trailing "::", e.g.:
> >
> > +Configure the kernel with::
> > +
> > +     CONFIG_AUTOFDO_CLANG=y
> >
> > This loses the language-specific highlighting when rendered. Perhaps the
> > "::" extension can be further extended?
> >
> > +Configure the kernel with::(make)
> > +
> > +     CONFIG_AUTOFDO_CLANG=y
> >
> > Then we could avoid the extra 2 lines but still gain the rendered language
> > highlights?
>
> The :: notation is standard Sphinx, not an extension we have done.  So
> the proposed syntax would have to be done from the beginning, I'm not
> sure how easy or hard that would be, or whether it would be worth it.
> But then, I've always seen relatively little value in the highlighting;
> others clearly differ.
>
> Thanks,
>
> jon
Title: Using AutoFDO with the Linux kernel — The Linux Kernel 6.12.0-smp-1203.99.652.34 documentation

Using AutoFDO with the Linux kernel

This enables AutoFDO build support for the kernel when using Clang compiler. AutoFDO (Auto-Feedback-Directed Optimization) is a profile-guided optimization (PGO) method used to optimize binary executables. It utilizes hardware sampling to gather information about the frequency of execution of different code paths within a binary. This information is then used to guide the compiler’s optimization decisions, resulting in a more efficient binary.

The AutoFDO optimization process involves the following steps:

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

  2. Profiling: The above kernel is then run with a representative workload to gather execution frequency data. This data is collected using hardware sampling, via perf. AutoFDO is most effective on platforms supporting advanced PMU features like LBR on Intel machines.

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

  4. Optimized build: The Clang compiler uses the AutoFDO profile to guide its optimization decisions during recompilation. The compiler focuses on optimizing the frequently executed code paths, resulting in more efficient code.

  5. Deployment: The optimized kernel binary is deployed and used in production environments, providing improved performance and reduced latency.

In a production environment, Profiling can be directly applied to the deployed kernel, eliminating the requirement for the initial build step.

AutoFDO is known to be a powerful optimization technique and the data show that it can substantially improve the kernel’s performance. It is especially advantageous for workloads that are constrained by front-end stalls.

Preparation

Configure the kernel with:

CONFIG_AUTOFDO_CLANG=y

Customization

You can enable or disable AutoFDO build for individual file and directories by adding a line similar to the following to 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 AutoFDO build config:

    CONFIG_AUTOFDO_CLANG=y

    and

    $ make LLVM=1

  2. Install the kernel on the TEST machine.

  3. Run the load tests. The ‘-c’ option in perf specifies the sample event 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:

      $ perf record -e 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. Generate AutoFDO profile. Two offline tools are available for this purpose: create_llvm_prof and llvm_profgen. The create_llvm_prof tool can be found as part of the AutoFDO project (https://github.com/google/autofdo). The llvm_profgen tool is included within the LLVM compiler itself.

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

    or

    $ create_llvm_prof --binary=<vmlinux> --profile=<perf_file> --format=extbinary -o <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.

    CONFIG_AUTOFDO_CLANG=y

    and

    $ make LLVM=1 CLANG_AUTOFDO_PROFILE=<profile_file>
©The kernel development community. | Powered by Sphinx 7.2.6 & Alabaster 0.7.12 | Page source
Title: Using AutoFDO with the Linux kernel — The Linux Kernel 6.12.0-smp-1203.99.652.34 documentation

Using AutoFDO with the Linux kernel

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

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

The AutoFDO profile often encapsulates the program’s behavior. If the performance-critical codes are architecture-independent, the profile can be applied across platforms to achieve performance gains. For instance, using the profile generated on Intel architecture to build a 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 an AutoFDO profile, the compiler only modifies the dwarf information in the kernel without impacting runtime performance. It’s advisable to use a kernel binary built with the same AutoFDO configuration to collect the perf profile. While it’s possible to use a kernel built with 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, offering some tolerance for source changes. This mode is commonly used in a production environment for profile collection.

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

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

  2. Profiling: The above kernel is then run with a representative workload to gather execution frequency data. This data is collected using hardware sampling, via perf. AutoFDO is most effective on platforms supporting advanced PMU features like LBR on Intel machines.

  3. AutoFDO profile generation: Perf output file is converted to the 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

You can enable or disable AutoFDO build for individual file and directories by adding a line similar to the following to 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 sample event 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: For Intel 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 part of 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’s important to note that the version of llvm_profgen doesn’t need to match the version of Clang. It needs to be the LLVM 19 release of Clang or 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="" --format=extbinary -o <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
©The kernel development community. | Powered by Sphinx 7.2.6 & Alabaster 0.7.12 | Page source
[Index of Archives]     [Linux&nblp;USB Development]     [Linux Media]     [Video for Linux]     [Linux Audio Users]     [Yosemite Secrets]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux