Hi,

This patch series is to integrate AutoFDO and Propeller support into
the Linux kernel. AutoFDO is a profile-guided optimization technique
that leverages hardware sampling to enhance binary performance.
Unlike Instrumentation-based FDO (iFDO), AutoFDO offers a user-friendly
and straightforward application process. While iFDO generally yields
superior profile quality and performance, our findings reveal that
AutoFDO achieves remarkable effectiveness, bringing performance close
to iFDO for benchmark applications.

Propeller is a profile-guided, post-link optimizer that improves
the performance of large-scale applications compiled with LLVM. It
operates by relinking the binary based on an additional round of runtime
profiles, enabling precise optimizations that are not possible at
compile time.  Similar to AutoFDO, Propeller too utilizes hardware
sampling to collect profiles and apply post-link optimizations to improve
the benchmark’s performance over and above AutoFDO.

Our empirical data demonstrates significant performance improvements
with AutoFDO and Propeller, up to 10% on microbenchmarks and up to 5%
on large warehouse-scale benchmarks. This makes a strong case for their
inclusion as supported features in the upstream kernel.

Background

A significant fraction of fleet processing cycles (excluding idle time)
from data center workloads are attributable to the kernel. Ware-house
scale workloads maximize performance by optimizing the production kernel
using iFDO (a.k.a instrumented PGO, Profile Guided Optimization).

iFDO can significantly enhance application performance but its use
within the kernel has raised concerns. AutoFDO is a variant of FDO that
uses the hardware’s Performance Monitoring Unit (PMU) to collect
profiling data. While AutoFDO typically yields smaller performance
gains than iFDO, it presents unique benefits for optimizing kernels.

AutoFDO eliminates the need for instrumented kernels, allowing a single
optimized kernel to serve both execution and profile collection. It also
minimizes slowdown during profile collection, potentially yielding
higher-fidelity profiling, especially for time-sensitive code, compared
to iFDO. Additionally, AutoFDO profiles can be obtained from production
environments via the hardware’s PMU whereas iFDO profiles require
carefully curated load tests that are representative of real-world
traffic.

AutoFDO facilitates profile collection across diverse targets.
Preliminary studies indicate significant variation in kernel hot spots
within Google’s infrastructure, suggesting potential performance gains
through target-specific kernel customization.

Furthermore, other advanced compiler optimization techniques, including
ThinLTO and Propeller can be stacked on top of AutoFDO, similar to iFDO.
ThinLTO achieves better runtime performance through whole-program
analysis and cross module optimizations. The main difference between
traditional LTO and ThinLTO is that the latter is scalable in time and
memory.

This patch series adds AutoFDO and Propeller support to the kernel. The
actual solution comes in six parts:

[P 1] Add the build support for using AutoFDO in Clang

      Add the basic support for AutoFDO build and provide the
      instructions for using AutoFDO.

[P 2] Fix objtool for bogus warnings when -ffunction-sections is enabled

[P 3] Change the subsection ordering when -ffunction-sections is enabled

[P 4] Enable –ffunction-sections for the AutoFDO build

[P 5] Enable Machine Function Split (MFS) optimization for AutoFDO

[P 6] Add Propeller configuration to the kernel build

Patch 1 provides basic AutoFDO build support. Patches 2 to 5 further
enhance the performance of AutoFDO builds and are functionally dependent
on Patch 1. Patch 6 enables support for Propeller and is dependent on
patch 2 and patch 3.

Caveats

AutoFDO is compatible with both GCC and Clang, but the patches in this
series are exclusively applicable to LLVM 17 or newer for AutoFDO and
LLVM 19 or newer for Propeller. For profile conversion, two different
tools could be used, llvm_profgen or create_llvm_prof. llvm_profgen
needs to be the LLVM 19 or newer, or just the LLVM trunk. Alternatively,
create_llvm_prof v0.30.1 or newer can be used instead of llvm-profgen.

Additionally, the build is only supported on x86 platforms equipped
with PMU capabilities, such as LBR on Intel machines. More
specifically:
 * Intel platforms: works on every platform that supports LBR;
   we have tested on Skylake.
 * AMD platforms: tested on AMD Zen3 with the BRS feature. The kernel
   needs to be configured with “CONFIG_PERF_EVENTS_AMD_BRS=y", To
   check, use
   $ cat /proc/cpuinfo | grep “ brs”
   For the AMD Zen4, AMD LBRV2 is supported, but we suspect a bug with
   AMD LBRv2 implementation in Genoa which blocks the usage.

Experiments and Results

Experiments were conducted to compare the performance of AutoFDO-optimized
kernel images (version 6.9.x) against default builds.. The evaluation
encompassed both open source microbenchmarks and real-world production
services from Google and Meta. The selected microbenchmarks included Neper,
a network subsystem benchmark, and UnixBench which is a comprehensive suite
for assessing various kernel operations.

For Neper, AutoFDO optimization resulted in a 6.1% increase in throughput
and a 10.6% reduction in latency. Unixbench saw a 2.2% improvement in its
index score under low system load and a 2.6% improvement under high system
load.

For further details on the improvements observed in Google and Meta's
production services, please refer to the LLVM discourse post:
https://discourse.llvm.org/t/optimizing-the-linux-kernel-with-autofdo-including-thinlto-and-propeller/79108

Thanks,

Rong Xu and Han Shen

Change-Logs in V2:
Rebased the source to e32cde8d2bd7 (Merge tag 'sched_ext-for-6.12-rc1-fixes-1')
1. Cover-letter: moved the Propeller description to the top (Peter Zijlstra)
2. [P 1]: (1) Makefile: fixed file order (Masahiro Yamada)
          (2) scripts/Makefile.lib: used is-kernel-object to exclude
              files (Masahiro Yamada)
          (3) scripts/Makefile.autofdo: improved the code (Masahiro Yamada)
          (4) scripts/Makefile.autofdo: handled when DEBUG_INFO disabled (Nick Desaulniers)
3. [P 2]: tools/objtool/elf.c: updated the comments (Peter Zijlstra)
4. [P 3]: include/asm-generic/vmlinux.lds.h:
          (1) explicit set cold text function aligned (Peter Zijlstra and Peter Anvin)
          (2) set hot-text page aligned
5. [P 6]: (1) include/asm-generic/vmlinux.lds.h: made Propeller not depending
              on AutoFDO
          (2) Makefile: fixed file order (Masahiro Yamada)
          (3) scripts/Makefile.lib: used is-kernel-object to exclude
              files (Masahiro Yamada). This removed the change in
              arch/x86/platform/efi/Makefile,
              drivers/firmware/efi/libstub/Makefile, and
              arch/x86/boot/compressed/Makefile.
              And this also addressed the comment from Arnd Bergmann regarding
              arch/x86/purgatory/Makefile.
          (4) scripts/Makefile.propeller: improved the code (Masahiro Yamada)

Change-Logs in V3:
Rebased the source to eb952c47d154 (Merge tag 'for-6.12-rc2-tag').
1. [P 1]: autofdo.rst: removed code-block directives and used "::" (Mike Rapoport)
2. [P 6]: propeller.rst: removed code-block directives and use "::" (Mike Rapoport)

Change-Logs in V4:
1. [P 1]: autofdo.rst: fixed a typo for create_llvm_prof commmand.

Rong Xu (6):
  Add AutoFDO support for Clang build
  objtool: Fix unreachable instruction warnings for weak funcitons
  Change the symbols order when --ffuntion-sections is enabled
  AutoFDO: Enable -ffunction-sections for the AutoFDO build
  AutoFDO: Enable machine function split optimization for AutoFDO
  Add Propeller configuration for kernel build.

 Documentation/dev-tools/autofdo.rst   | 165 ++++++++++++++++++++++++++
 Documentation/dev-tools/index.rst     |   2 +
 Documentation/dev-tools/propeller.rst | 161 +++++++++++++++++++++++++
 MAINTAINERS                           |  14 +++
 Makefile                              |   2 +
 arch/Kconfig                          |  42 +++++++
 arch/x86/Kconfig                      |   2 +
 arch/x86/kernel/vmlinux.lds.S         |   4 +
 include/asm-generic/vmlinux.lds.h     |  54 +++++++--
 scripts/Makefile.autofdo              |  25 ++++
 scripts/Makefile.lib                  |  20 ++++
 scripts/Makefile.propeller            |  28 +++++
 tools/objtool/check.c                 |   2 +
 tools/objtool/elf.c                   |  15 ++-
 14 files changed, 524 insertions(+), 12 deletions(-)
 create mode 100644 Documentation/dev-tools/autofdo.rst
 create mode 100644 Documentation/dev-tools/propeller.rst
 create mode 100644 scripts/Makefile.autofdo
 create mode 100644 scripts/Makefile.propeller


base-commit: eb952c47d154ba2aac794b99c66c3c45eb4cc4ec
-- 
2.47.0.rc1.288.g06298d1525-goog

Thanks to all for the feedback and suggestions! We are ready to make any further
changes needed. Is there anything else we can address for this patch?

Also, we know it's not easy to test this patch, but if anyone has had a chance
to try building AutoFDO/Propeller kernels with it, we'd really appreciate your
input here. Any confirmation that it works as expected would be very helpful.

-Rong

On Mon, Oct 14, 2024 at 2:33 PM Rong Xu <xur@google.com> wrote:
>
> Hi,
>
> This patch series is to integrate AutoFDO and Propeller support into
> the Linux kernel. AutoFDO is a profile-guided optimization technique
> that leverages hardware sampling to enhance binary performance.
> Unlike Instrumentation-based FDO (iFDO), AutoFDO offers a user-friendly
> and straightforward application process. While iFDO generally yields
> superior profile quality and performance, our findings reveal that
> AutoFDO achieves remarkable effectiveness, bringing performance close
> to iFDO for benchmark applications.
>
> Propeller is a profile-guided, post-link optimizer that improves
> the performance of large-scale applications compiled with LLVM. It
> operates by relinking the binary based on an additional round of runtime
> profiles, enabling precise optimizations that are not possible at
> compile time.  Similar to AutoFDO, Propeller too utilizes hardware
> sampling to collect profiles and apply post-link optimizations to improve
> the benchmark’s performance over and above AutoFDO.
>
> Our empirical data demonstrates significant performance improvements
> with AutoFDO and Propeller, up to 10% on microbenchmarks and up to 5%
> on large warehouse-scale benchmarks. This makes a strong case for their
> inclusion as supported features in the upstream kernel.
>
> Background
>
> A significant fraction of fleet processing cycles (excluding idle time)
> from data center workloads are attributable to the kernel. Ware-house
> scale workloads maximize performance by optimizing the production kernel
> using iFDO (a.k.a instrumented PGO, Profile Guided Optimization).
>
> iFDO can significantly enhance application performance but its use
> within the kernel has raised concerns. AutoFDO is a variant of FDO that
> uses the hardware’s Performance Monitoring Unit (PMU) to collect
> profiling data. While AutoFDO typically yields smaller performance
> gains than iFDO, it presents unique benefits for optimizing kernels.
>
> AutoFDO eliminates the need for instrumented kernels, allowing a single
> optimized kernel to serve both execution and profile collection. It also
> minimizes slowdown during profile collection, potentially yielding
> higher-fidelity profiling, especially for time-sensitive code, compared
> to iFDO. Additionally, AutoFDO profiles can be obtained from production
> environments via the hardware’s PMU whereas iFDO profiles require
> carefully curated load tests that are representative of real-world
> traffic.
>
> AutoFDO facilitates profile collection across diverse targets.
> Preliminary studies indicate significant variation in kernel hot spots
> within Google’s infrastructure, suggesting potential performance gains
> through target-specific kernel customization.
>
> Furthermore, other advanced compiler optimization techniques, including
> ThinLTO and Propeller can be stacked on top of AutoFDO, similar to iFDO.
> ThinLTO achieves better runtime performance through whole-program
> analysis and cross module optimizations. The main difference between
> traditional LTO and ThinLTO is that the latter is scalable in time and
> memory.
>
> This patch series adds AutoFDO and Propeller support to the kernel. The
> actual solution comes in six parts:
>
> [P 1] Add the build support for using AutoFDO in Clang
>
>       Add the basic support for AutoFDO build and provide the
>       instructions for using AutoFDO.
>
> [P 2] Fix objtool for bogus warnings when -ffunction-sections is enabled
>
> [P 3] Change the subsection ordering when -ffunction-sections is enabled
>
> [P 4] Enable –ffunction-sections for the AutoFDO build
>
> [P 5] Enable Machine Function Split (MFS) optimization for AutoFDO
>
> [P 6] Add Propeller configuration to the kernel build
>
> Patch 1 provides basic AutoFDO build support. Patches 2 to 5 further
> enhance the performance of AutoFDO builds and are functionally dependent
> on Patch 1. Patch 6 enables support for Propeller and is dependent on
> patch 2 and patch 3.
>
> Caveats
>
> AutoFDO is compatible with both GCC and Clang, but the patches in this
> series are exclusively applicable to LLVM 17 or newer for AutoFDO and
> LLVM 19 or newer for Propeller. For profile conversion, two different
> tools could be used, llvm_profgen or create_llvm_prof. llvm_profgen
> needs to be the LLVM 19 or newer, or just the LLVM trunk. Alternatively,
> create_llvm_prof v0.30.1 or newer can be used instead of llvm-profgen.
>
> Additionally, the build is only supported on x86 platforms equipped
> with PMU capabilities, such as LBR on Intel machines. More
> specifically:
>  * Intel platforms: works on every platform that supports LBR;
>    we have tested on Skylake.
>  * AMD platforms: tested on AMD Zen3 with the BRS feature. The kernel
>    needs to be configured with “CONFIG_PERF_EVENTS_AMD_BRS=y", To
>    check, use
>    $ cat /proc/cpuinfo | grep “ brs”
>    For the AMD Zen4, AMD LBRV2 is supported, but we suspect a bug with
>    AMD LBRv2 implementation in Genoa which blocks the usage.
>
> Experiments and Results
>
> Experiments were conducted to compare the performance of AutoFDO-optimized
> kernel images (version 6.9.x) against default builds.. The evaluation
> encompassed both open source microbenchmarks and real-world production
> services from Google and Meta. The selected microbenchmarks included Neper,
> a network subsystem benchmark, and UnixBench which is a comprehensive suite
> for assessing various kernel operations.
>
> For Neper, AutoFDO optimization resulted in a 6.1% increase in throughput
> and a 10.6% reduction in latency. Unixbench saw a 2.2% improvement in its
> index score under low system load and a 2.6% improvement under high system
> load.
>
> For further details on the improvements observed in Google and Meta's
> production services, please refer to the LLVM discourse post:
> https://discourse.llvm.org/t/optimizing-the-linux-kernel-with-autofdo-including-thinlto-and-propeller/79108
>
> Thanks,
>
> Rong Xu and Han Shen
>
> Change-Logs in V2:
> Rebased the source to e32cde8d2bd7 (Merge tag 'sched_ext-for-6.12-rc1-fixes-1')
> 1. Cover-letter: moved the Propeller description to the top (Peter Zijlstra)
> 2. [P 1]: (1) Makefile: fixed file order (Masahiro Yamada)
>           (2) scripts/Makefile.lib: used is-kernel-object to exclude
>               files (Masahiro Yamada)
>           (3) scripts/Makefile.autofdo: improved the code (Masahiro Yamada)
>           (4) scripts/Makefile.autofdo: handled when DEBUG_INFO disabled (Nick Desaulniers)
> 3. [P 2]: tools/objtool/elf.c: updated the comments (Peter Zijlstra)
> 4. [P 3]: include/asm-generic/vmlinux.lds.h:
>           (1) explicit set cold text function aligned (Peter Zijlstra and Peter Anvin)
>           (2) set hot-text page aligned
> 5. [P 6]: (1) include/asm-generic/vmlinux.lds.h: made Propeller not depending
>               on AutoFDO
>           (2) Makefile: fixed file order (Masahiro Yamada)
>           (3) scripts/Makefile.lib: used is-kernel-object to exclude
>               files (Masahiro Yamada). This removed the change in
>               arch/x86/platform/efi/Makefile,
>               drivers/firmware/efi/libstub/Makefile, and
>               arch/x86/boot/compressed/Makefile.
>               And this also addressed the comment from Arnd Bergmann regarding
>               arch/x86/purgatory/Makefile.
>           (4) scripts/Makefile.propeller: improved the code (Masahiro Yamada)
>
> Change-Logs in V3:
> Rebased the source to eb952c47d154 (Merge tag 'for-6.12-rc2-tag').
> 1. [P 1]: autofdo.rst: removed code-block directives and used "::" (Mike Rapoport)
> 2. [P 6]: propeller.rst: removed code-block directives and use "::" (Mike Rapoport)
>
> Change-Logs in V4:
> 1. [P 1]: autofdo.rst: fixed a typo for create_llvm_prof commmand.
>
> Rong Xu (6):
>   Add AutoFDO support for Clang build
>   objtool: Fix unreachable instruction warnings for weak funcitons
>   Change the symbols order when --ffuntion-sections is enabled
>   AutoFDO: Enable -ffunction-sections for the AutoFDO build
>   AutoFDO: Enable machine function split optimization for AutoFDO
>   Add Propeller configuration for kernel build.
>
>  Documentation/dev-tools/autofdo.rst   | 165 ++++++++++++++++++++++++++
>  Documentation/dev-tools/index.rst     |   2 +
>  Documentation/dev-tools/propeller.rst | 161 +++++++++++++++++++++++++
>  MAINTAINERS                           |  14 +++
>  Makefile                              |   2 +
>  arch/Kconfig                          |  42 +++++++
>  arch/x86/Kconfig                      |   2 +
>  arch/x86/kernel/vmlinux.lds.S         |   4 +
>  include/asm-generic/vmlinux.lds.h     |  54 +++++++--
>  scripts/Makefile.autofdo              |  25 ++++
>  scripts/Makefile.lib                  |  20 ++++
>  scripts/Makefile.propeller            |  28 +++++
>  tools/objtool/check.c                 |   2 +
>  tools/objtool/elf.c                   |  15 ++-
>  14 files changed, 524 insertions(+), 12 deletions(-)
>  create mode 100644 Documentation/dev-tools/autofdo.rst
>  create mode 100644 Documentation/dev-tools/propeller.rst
>  create mode 100644 scripts/Makefile.autofdo
>  create mode 100644 scripts/Makefile.propeller
>
>
> base-commit: eb952c47d154ba2aac794b99c66c3c45eb4cc4ec
> --
> 2.47.0.rc1.288.g06298d1525-goog
>

Hi Rong,

On Fri, Oct 18, 2024 at 11:20:02PM -0700, Rong Xu wrote:
> Thanks to all for the feedback and suggestions! We are ready to make any further
> changes needed. Is there anything else we can address for this patch?

I will reply in a separate thread for visibility but I think one of the
biggest open questions at the moment is trying to find someone to
shepherd this code into mainline.

> Also, we know it's not easy to test this patch, but if anyone has had a chance
> to try building AutoFDO/Propeller kernels with it, we'd really appreciate your
> input here. Any confirmation that it works as expected would be very helpful.

I went to take this series for a spin in a virtual machine first as a
smoke test before attempting to boot on bare metal. This was done on a
server with an Intel Xeon Gold 6314U. The kernel booted fine but when I
went to run the command to generate the perf data from the
documentation, I get an error.

  $ perf record -e BR_INST_RETIRED.NEAR_TAKEN:k -a -N -b -c 500009 -o /tmp/perf.data -- make -j$(nproc) O=out mrproper defconfig all
  Error:
  BR_INST_RETIRED.NEAR_TAKEN:k: PMU Hardware or event type doesn't support branch stack sampling.

Do you know if this is expected for a virtual machine setup? I will
attempt to test the series on real hardware here soon, it is currently
tied up with investigating a regression in -next at the moment.

Cheers,
Nathan

On Sat, Oct 19, 2024 at 8:25 PM Nathan Chancellor <nathan@kernel.org> wrote:
>
> Hi Rong,
>
> On Fri, Oct 18, 2024 at 11:20:02PM -0700, Rong Xu wrote:
> > Thanks to all for the feedback and suggestions! We are ready to make any further
> > changes needed. Is there anything else we can address for this patch?
>
> I will reply in a separate thread for visibility but I think one of the
> biggest open questions at the moment is trying to find someone to
> shepherd this code into mainline.
>
> > Also, we know it's not easy to test this patch, but if anyone has had a chance
> > to try building AutoFDO/Propeller kernels with it, we'd really appreciate your
> > input here. Any confirmation that it works as expected would be very helpful.
>
> I went to take this series for a spin in a virtual machine first as a
> smoke test before attempting to boot on bare metal. This was done on a
> server with an Intel Xeon Gold 6314U. The kernel booted fine but when I
> went to run the command to generate the perf data from the
> documentation, I get an error.
>
>   $ perf record -e BR_INST_RETIRED.NEAR_TAKEN:k -a -N -b -c 500009 -o /tmp/perf.data -- make -j$(nproc) O=out mrproper defconfig all
>   Error:
>   BR_INST_RETIRED.NEAR_TAKEN:k: PMU Hardware or event type doesn't support branch stack sampling.
>
> Do you know if this is expected for a virtual machine setup? I will
> attempt to test the series on real hardware here soon, it is currently
> tied up with investigating a regression in -next at the moment.

We have never tested this patch in a KVM setup.

As far as we know, LBR support in KVM is currently limited, and varies
depending on the PMU virtualization model:
(1) For legacy mode, LBR profiling might work under LBR virtualization
(VLBR). However, we have not tested this.
(2) For the new "Mediated vPMU passthru' mode, there is no LBR
virtualization support at this point. So LBR profiling is not working.

I've included Stephance here. He should have more expertise on this topic.

>
> Cheers,
> Nathan

On 10/18/24 11:20 PM, Rong Xu wrote:
> Thanks to all for the feedback and suggestions! We are ready to make any further
> changes needed. Is there anything else we can address for this patch?
>
> Also, we know it's not easy to test this patch, but if anyone has had a chance
> to try building AutoFDO/Propeller kernels with it, we'd really appreciate your
> input here. Any confirmation that it works as expected would be very helpful.
>
> -Rong
>
> On Mon, Oct 14, 2024 at 2:33 PM Rong Xu <xur@google.com> wrote:
>> Hi,
>>
>> This patch series is to integrate AutoFDO and Propeller support into
>> the Linux kernel. AutoFDO is a profile-guided optimization technique
>> that leverages hardware sampling to enhance binary performance.
>> Unlike Instrumentation-based FDO (iFDO), AutoFDO offers a user-friendly
>> and straightforward application process. While iFDO generally yields
>> superior profile quality and performance, our findings reveal that
>> AutoFDO achieves remarkable effectiveness, bringing performance close
>> to iFDO for benchmark applications.
>>
>> Propeller is a profile-guided, post-link optimizer that improves
>> the performance of large-scale applications compiled with LLVM. It
>> operates by relinking the binary based on an additional round of runtime
>> profiles, enabling precise optimizations that are not possible at
>> compile time.  Similar to AutoFDO, Propeller too utilizes hardware
>> sampling to collect profiles and apply post-link optimizations to improve
>> the benchmark’s performance over and above AutoFDO.
>>
>> Our empirical data demonstrates significant performance improvements
>> with AutoFDO and Propeller, up to 10% on microbenchmarks and up to 5%
>> on large warehouse-scale benchmarks. This makes a strong case for their
>> inclusion as supported features in the upstream kernel.
>>
>> Background
>>
>> A significant fraction of fleet processing cycles (excluding idle time)
>> from data center workloads are attributable to the kernel. Ware-house
>> scale workloads maximize performance by optimizing the production kernel
>> using iFDO (a.k.a instrumented PGO, Profile Guided Optimization).
>>
>> iFDO can significantly enhance application performance but its use
>> within the kernel has raised concerns. AutoFDO is a variant of FDO that
>> uses the hardware’s Performance Monitoring Unit (PMU) to collect
>> profiling data. While AutoFDO typically yields smaller performance
>> gains than iFDO, it presents unique benefits for optimizing kernels.
>>
>> AutoFDO eliminates the need for instrumented kernels, allowing a single
>> optimized kernel to serve both execution and profile collection. It also
>> minimizes slowdown during profile collection, potentially yielding
>> higher-fidelity profiling, especially for time-sensitive code, compared
>> to iFDO. Additionally, AutoFDO profiles can be obtained from production
>> environments via the hardware’s PMU whereas iFDO profiles require
>> carefully curated load tests that are representative of real-world
>> traffic.
>>
>> AutoFDO facilitates profile collection across diverse targets.
>> Preliminary studies indicate significant variation in kernel hot spots
>> within Google’s infrastructure, suggesting potential performance gains
>> through target-specific kernel customization.
>>
>> Furthermore, other advanced compiler optimization techniques, including
>> ThinLTO and Propeller can be stacked on top of AutoFDO, similar to iFDO.
>> ThinLTO achieves better runtime performance through whole-program
>> analysis and cross module optimizations. The main difference between
>> traditional LTO and ThinLTO is that the latter is scalable in time and
>> memory.
>>
>> This patch series adds AutoFDO and Propeller support to the kernel. The
>> actual solution comes in six parts:
>>
>> [P 1] Add the build support for using AutoFDO in Clang
>>
>>        Add the basic support for AutoFDO build and provide the
>>        instructions for using AutoFDO.
>>
>> [P 2] Fix objtool for bogus warnings when -ffunction-sections is enabled
>>
>> [P 3] Change the subsection ordering when -ffunction-sections is enabled
>>
>> [P 4] Enable –ffunction-sections for the AutoFDO build
>>
>> [P 5] Enable Machine Function Split (MFS) optimization for AutoFDO
>>
>> [P 6] Add Propeller configuration to the kernel build
>>
>> Patch 1 provides basic AutoFDO build support. Patches 2 to 5 further
>> enhance the performance of AutoFDO builds and are functionally dependent
>> on Patch 1. Patch 6 enables support for Propeller and is dependent on
>> patch 2 and patch 3.
>>
>> Caveats
>>
>> AutoFDO is compatible with both GCC and Clang, but the patches in this
>> series are exclusively applicable to LLVM 17 or newer for AutoFDO and
>> LLVM 19 or newer for Propeller. For profile conversion, two different
>> tools could be used, llvm_profgen or create_llvm_prof. llvm_profgen
>> needs to be the LLVM 19 or newer, or just the LLVM trunk. Alternatively,
>> create_llvm_prof v0.30.1 or newer can be used instead of llvm-profgen.
>>
>> Additionally, the build is only supported on x86 platforms equipped
>> with PMU capabilities, such as LBR on Intel machines. More
>> specifically:
>>   * Intel platforms: works on every platform that supports LBR;
>>     we have tested on Skylake.
>>   * AMD platforms: tested on AMD Zen3 with the BRS feature. The kernel
>>     needs to be configured with “CONFIG_PERF_EVENTS_AMD_BRS=y", To
>>     check, use
>>     $ cat /proc/cpuinfo | grep “ brs”
>>     For the AMD Zen4, AMD LBRV2 is supported, but we suspect a bug with
>>     AMD LBRv2 implementation in Genoa which blocks the usage.
>>
>> Experiments and Results
>>
>> Experiments were conducted to compare the performance of AutoFDO-optimized
>> kernel images (version 6.9.x) against default builds.. The evaluation
>> encompassed both open source microbenchmarks and real-world production
>> services from Google and Meta. The selected microbenchmarks included Neper,
>> a network subsystem benchmark, and UnixBench which is a comprehensive suite
>> for assessing various kernel operations.
>>
>> For Neper, AutoFDO optimization resulted in a 6.1% increase in throughput
>> and a 10.6% reduction in latency. Unixbench saw a 2.2% improvement in its
>> index score under low system load and a 2.6% improvement under high system
>> load.
>>
>> For further details on the improvements observed in Google and Meta's
>> production services, please refer to the LLVM discourse post:
>> https://discourse.llvm.org/t/optimizing-the-linux-kernel-with-autofdo-including-thinlto-and-propeller/79108
>>
>> Thanks,
>>
>> Rong Xu and Han Shen
>>
>> Change-Logs in V2:
>> Rebased the source to e32cde8d2bd7 (Merge tag 'sched_ext-for-6.12-rc1-fixes-1')
>> 1. Cover-letter: moved the Propeller description to the top (Peter Zijlstra)
>> 2. [P 1]: (1) Makefile: fixed file order (Masahiro Yamada)
>>            (2) scripts/Makefile.lib: used is-kernel-object to exclude
>>                files (Masahiro Yamada)
>>            (3) scripts/Makefile.autofdo: improved the code (Masahiro Yamada)
>>            (4) scripts/Makefile.autofdo: handled when DEBUG_INFO disabled (Nick Desaulniers)
>> 3. [P 2]: tools/objtool/elf.c: updated the comments (Peter Zijlstra)
>> 4. [P 3]: include/asm-generic/vmlinux.lds.h:
>>            (1) explicit set cold text function aligned (Peter Zijlstra and Peter Anvin)
>>            (2) set hot-text page aligned
>> 5. [P 6]: (1) include/asm-generic/vmlinux.lds.h: made Propeller not depending
>>                on AutoFDO
>>            (2) Makefile: fixed file order (Masahiro Yamada)
>>            (3) scripts/Makefile.lib: used is-kernel-object to exclude
>>                files (Masahiro Yamada). This removed the change in
>>                arch/x86/platform/efi/Makefile,
>>                drivers/firmware/efi/libstub/Makefile, and
>>                arch/x86/boot/compressed/Makefile.
>>                And this also addressed the comment from Arnd Bergmann regarding
>>                arch/x86/purgatory/Makefile.
>>            (4) scripts/Makefile.propeller: improved the code (Masahiro Yamada)
>>
>> Change-Logs in V3:
>> Rebased the source to eb952c47d154 (Merge tag 'for-6.12-rc2-tag').
>> 1. [P 1]: autofdo.rst: removed code-block directives and used "::" (Mike Rapoport)
>> 2. [P 6]: propeller.rst: removed code-block directives and use "::" (Mike Rapoport)
>>
>> Change-Logs in V4:
>> 1. [P 1]: autofdo.rst: fixed a typo for create_llvm_prof commmand.
>>
>> Rong Xu (6):
>>    Add AutoFDO support for Clang build
>>    objtool: Fix unreachable instruction warnings for weak funcitons
>>    Change the symbols order when --ffuntion-sections is enabled
>>    AutoFDO: Enable -ffunction-sections for the AutoFDO build
>>    AutoFDO: Enable machine function split optimization for AutoFDO
>>    Add Propeller configuration for kernel build.
>>
>>   Documentation/dev-tools/autofdo.rst   | 165 ++++++++++++++++++++++++++
>>   Documentation/dev-tools/index.rst     |   2 +
>>   Documentation/dev-tools/propeller.rst | 161 +++++++++++++++++++++++++
>>   MAINTAINERS                           |  14 +++
>>   Makefile                              |   2 +
>>   arch/Kconfig                          |  42 +++++++
>>   arch/x86/Kconfig                      |   2 +
>>   arch/x86/kernel/vmlinux.lds.S         |   4 +
>>   include/asm-generic/vmlinux.lds.h     |  54 +++++++--
>>   scripts/Makefile.autofdo              |  25 ++++
>>   scripts/Makefile.lib                  |  20 ++++
>>   scripts/Makefile.propeller            |  28 +++++
>>   tools/objtool/check.c                 |   2 +
>>   tools/objtool/elf.c                   |  15 ++-
>>   14 files changed, 524 insertions(+), 12 deletions(-)
>>   create mode 100644 Documentation/dev-tools/autofdo.rst
>>   create mode 100644 Documentation/dev-tools/propeller.rst
>>   create mode 100644 scripts/Makefile.autofdo
>>   create mode 100644 scripts/Makefile.propeller
>>
>>
>> base-commit: eb952c47d154ba2aac794b99c66c3c45eb4cc4ec
>> --
>> 2.47.0.rc1.288.g06298d1525-goog
>>
I tried this patch set on our production machine.
I am using llvm19, built by myself from the llvm19 release branch. I tried
with x86_64 intel processor only. The base config file is based on Meta internal
config file (production version).

Overall, I didn't find any issues. I checked IR file with both non-lto and lto
version and in both cases, the expected sample PGO loader indeed added
some profiles to IR. For non-lto versions during normal compilation. For lto
version both optimization before lto and during lto.

The propeller works fine too. I downloaded the binary from the autofdo git
repo as directed in the commit message of patch 6. create_llvm_prof dumps
a lot of information which shows quite some functions with profile data.
I also checked some asm code and does see basic-block level section
are encoded in .s file (it should be in .o file as well but .s file is easier
to reason.)

The training data is collected with some workloads in the machine, not heavy
but for testing purposes it should be enough.
I run bpf selftests on the eventual kernel (after autofdo and propeller).
Everything works fine.

Of course I didn't try all possible combination. But for the config I am using
(heavily geared for bpf selftests), things work fine. So

Tested-by: Yonghong Song <yonghong.song@linux.dev>

Hi Masahiro and Andrew,

Top posting only for visibility. Would it make more sense to have this
land via the Kbuild tree or -mm? The core of the series really touches
Kbuild and I think the x86 stuff can just land with Acks, unless the
-tip folks feel differently. I would like Rong to have a relatively
clear path forward to mainline once the requisite review and testing has
accomplished, which requires a shepherd :)

Cheers,
Nathan

On Mon, Oct 14, 2024 at 02:33:34PM -0700, Rong Xu wrote:
> Hi,
> 
> This patch series is to integrate AutoFDO and Propeller support into
> the Linux kernel. AutoFDO is a profile-guided optimization technique
> that leverages hardware sampling to enhance binary performance.
> Unlike Instrumentation-based FDO (iFDO), AutoFDO offers a user-friendly
> and straightforward application process. While iFDO generally yields
> superior profile quality and performance, our findings reveal that
> AutoFDO achieves remarkable effectiveness, bringing performance close
> to iFDO for benchmark applications.
> 
> Propeller is a profile-guided, post-link optimizer that improves
> the performance of large-scale applications compiled with LLVM. It
> operates by relinking the binary based on an additional round of runtime
> profiles, enabling precise optimizations that are not possible at
> compile time.  Similar to AutoFDO, Propeller too utilizes hardware
> sampling to collect profiles and apply post-link optimizations to improve
> the benchmark’s performance over and above AutoFDO.
> 
> Our empirical data demonstrates significant performance improvements
> with AutoFDO and Propeller, up to 10% on microbenchmarks and up to 5%
> on large warehouse-scale benchmarks. This makes a strong case for their
> inclusion as supported features in the upstream kernel.
> 
> Background
> 
> A significant fraction of fleet processing cycles (excluding idle time)
> from data center workloads are attributable to the kernel. Ware-house
> scale workloads maximize performance by optimizing the production kernel
> using iFDO (a.k.a instrumented PGO, Profile Guided Optimization).
> 
> iFDO can significantly enhance application performance but its use
> within the kernel has raised concerns. AutoFDO is a variant of FDO that
> uses the hardware’s Performance Monitoring Unit (PMU) to collect
> profiling data. While AutoFDO typically yields smaller performance
> gains than iFDO, it presents unique benefits for optimizing kernels.
> 
> AutoFDO eliminates the need for instrumented kernels, allowing a single
> optimized kernel to serve both execution and profile collection. It also
> minimizes slowdown during profile collection, potentially yielding
> higher-fidelity profiling, especially for time-sensitive code, compared
> to iFDO. Additionally, AutoFDO profiles can be obtained from production
> environments via the hardware’s PMU whereas iFDO profiles require
> carefully curated load tests that are representative of real-world
> traffic.
> 
> AutoFDO facilitates profile collection across diverse targets.
> Preliminary studies indicate significant variation in kernel hot spots
> within Google’s infrastructure, suggesting potential performance gains
> through target-specific kernel customization.
> 
> Furthermore, other advanced compiler optimization techniques, including
> ThinLTO and Propeller can be stacked on top of AutoFDO, similar to iFDO.
> ThinLTO achieves better runtime performance through whole-program
> analysis and cross module optimizations. The main difference between
> traditional LTO and ThinLTO is that the latter is scalable in time and
> memory.
> 
> This patch series adds AutoFDO and Propeller support to the kernel. The
> actual solution comes in six parts:
> 
> [P 1] Add the build support for using AutoFDO in Clang
> 
>       Add the basic support for AutoFDO build and provide the
>       instructions for using AutoFDO.
> 
> [P 2] Fix objtool for bogus warnings when -ffunction-sections is enabled
> 
> [P 3] Change the subsection ordering when -ffunction-sections is enabled
> 
> [P 4] Enable –ffunction-sections for the AutoFDO build
> 
> [P 5] Enable Machine Function Split (MFS) optimization for AutoFDO
> 
> [P 6] Add Propeller configuration to the kernel build
> 
> Patch 1 provides basic AutoFDO build support. Patches 2 to 5 further
> enhance the performance of AutoFDO builds and are functionally dependent
> on Patch 1. Patch 6 enables support for Propeller and is dependent on
> patch 2 and patch 3.
> 
> Caveats
> 
> AutoFDO is compatible with both GCC and Clang, but the patches in this
> series are exclusively applicable to LLVM 17 or newer for AutoFDO and
> LLVM 19 or newer for Propeller. For profile conversion, two different
> tools could be used, llvm_profgen or create_llvm_prof. llvm_profgen
> needs to be the LLVM 19 or newer, or just the LLVM trunk. Alternatively,
> create_llvm_prof v0.30.1 or newer can be used instead of llvm-profgen.
> 
> Additionally, the build is only supported on x86 platforms equipped
> with PMU capabilities, such as LBR on Intel machines. More
> specifically:
>  * Intel platforms: works on every platform that supports LBR;
>    we have tested on Skylake.
>  * AMD platforms: tested on AMD Zen3 with the BRS feature. The kernel
>    needs to be configured with “CONFIG_PERF_EVENTS_AMD_BRS=y", To
>    check, use
>    $ cat /proc/cpuinfo | grep “ brs”
>    For the AMD Zen4, AMD LBRV2 is supported, but we suspect a bug with
>    AMD LBRv2 implementation in Genoa which blocks the usage.
> 
> Experiments and Results
> 
> Experiments were conducted to compare the performance of AutoFDO-optimized
> kernel images (version 6.9.x) against default builds.. The evaluation
> encompassed both open source microbenchmarks and real-world production
> services from Google and Meta. The selected microbenchmarks included Neper,
> a network subsystem benchmark, and UnixBench which is a comprehensive suite
> for assessing various kernel operations.
> 
> For Neper, AutoFDO optimization resulted in a 6.1% increase in throughput
> and a 10.6% reduction in latency. Unixbench saw a 2.2% improvement in its
> index score under low system load and a 2.6% improvement under high system
> load.
> 
> For further details on the improvements observed in Google and Meta's
> production services, please refer to the LLVM discourse post:
> https://discourse.llvm.org/t/optimizing-the-linux-kernel-with-autofdo-including-thinlto-and-propeller/79108
...
> Rong Xu (6):
>   Add AutoFDO support for Clang build
>   objtool: Fix unreachable instruction warnings for weak funcitons
>   Change the symbols order when --ffuntion-sections is enabled
>   AutoFDO: Enable -ffunction-sections for the AutoFDO build
>   AutoFDO: Enable machine function split optimization for AutoFDO
>   Add Propeller configuration for kernel build.
> 
>  Documentation/dev-tools/autofdo.rst   | 165 ++++++++++++++++++++++++++
>  Documentation/dev-tools/index.rst     |   2 +
>  Documentation/dev-tools/propeller.rst | 161 +++++++++++++++++++++++++
>  MAINTAINERS                           |  14 +++
>  Makefile                              |   2 +
>  arch/Kconfig                          |  42 +++++++
>  arch/x86/Kconfig                      |   2 +
>  arch/x86/kernel/vmlinux.lds.S         |   4 +
>  include/asm-generic/vmlinux.lds.h     |  54 +++++++--
>  scripts/Makefile.autofdo              |  25 ++++
>  scripts/Makefile.lib                  |  20 ++++
>  scripts/Makefile.propeller            |  28 +++++
>  tools/objtool/check.c                 |   2 +
>  tools/objtool/elf.c                   |  15 ++-
>  14 files changed, 524 insertions(+), 12 deletions(-)
>  create mode 100644 Documentation/dev-tools/autofdo.rst
>  create mode 100644 Documentation/dev-tools/propeller.rst
>  create mode 100644 scripts/Makefile.autofdo
>  create mode 100644 scripts/Makefile.propeller
> 
> 
> base-commit: eb952c47d154ba2aac794b99c66c3c45eb4cc4ec
> -- 
> 2.47.0.rc1.288.g06298d1525-goog
> 

On Sun, Oct 20, 2024 at 12:31 PM Nathan Chancellor <nathan@kernel.org> wrote:
>
> Hi Masahiro and Andrew,
>
> Top posting only for visibility. Would it make more sense to have this
> land via the Kbuild tree or -mm? The core of the series really touches
> Kbuild and I think the x86 stuff can just land with Acks, unless the
> -tip folks feel differently. I would like Rong to have a relatively
> clear path forward to mainline once the requisite review and testing has
> accomplished, which requires a shepherd :)


I think I can pick it up if 2/6 gains Ack from an objtool maintainer.






> Cheers,
> Nathan
>
> On Mon, Oct 14, 2024 at 02:33:34PM -0700, Rong Xu wrote:
> > Hi,
> >
> > This patch series is to integrate AutoFDO and Propeller support into
> > the Linux kernel. AutoFDO is a profile-guided optimization technique
> > that leverages hardware sampling to enhance binary performance.
> > Unlike Instrumentation-based FDO (iFDO), AutoFDO offers a user-friendly
> > and straightforward application process. While iFDO generally yields
> > superior profile quality and performance, our findings reveal that
> > AutoFDO achieves remarkable effectiveness, bringing performance close
> > to iFDO for benchmark applications.
> >
> > Propeller is a profile-guided, post-link optimizer that improves
> > the performance of large-scale applications compiled with LLVM. It
> > operates by relinking the binary based on an additional round of runtime
> > profiles, enabling precise optimizations that are not possible at
> > compile time.  Similar to AutoFDO, Propeller too utilizes hardware
> > sampling to collect profiles and apply post-link optimizations to improve
> > the benchmark’s performance over and above AutoFDO.
> >
> > Our empirical data demonstrates significant performance improvements
> > with AutoFDO and Propeller, up to 10% on microbenchmarks and up to 5%
> > on large warehouse-scale benchmarks. This makes a strong case for their
> > inclusion as supported features in the upstream kernel.
> >
> > Background
> >
> > A significant fraction of fleet processing cycles (excluding idle time)
> > from data center workloads are attributable to the kernel. Ware-house
> > scale workloads maximize performance by optimizing the production kernel
> > using iFDO (a.k.a instrumented PGO, Profile Guided Optimization).
> >
> > iFDO can significantly enhance application performance but its use
> > within the kernel has raised concerns. AutoFDO is a variant of FDO that
> > uses the hardware’s Performance Monitoring Unit (PMU) to collect
> > profiling data. While AutoFDO typically yields smaller performance
> > gains than iFDO, it presents unique benefits for optimizing kernels.
> >
> > AutoFDO eliminates the need for instrumented kernels, allowing a single
> > optimized kernel to serve both execution and profile collection. It also
> > minimizes slowdown during profile collection, potentially yielding
> > higher-fidelity profiling, especially for time-sensitive code, compared
> > to iFDO. Additionally, AutoFDO profiles can be obtained from production
> > environments via the hardware’s PMU whereas iFDO profiles require
> > carefully curated load tests that are representative of real-world
> > traffic.
> >
> > AutoFDO facilitates profile collection across diverse targets.
> > Preliminary studies indicate significant variation in kernel hot spots
> > within Google’s infrastructure, suggesting potential performance gains
> > through target-specific kernel customization.
> >
> > Furthermore, other advanced compiler optimization techniques, including
> > ThinLTO and Propeller can be stacked on top of AutoFDO, similar to iFDO.
> > ThinLTO achieves better runtime performance through whole-program
> > analysis and cross module optimizations. The main difference between
> > traditional LTO and ThinLTO is that the latter is scalable in time and
> > memory.
> >
> > This patch series adds AutoFDO and Propeller support to the kernel. The
> > actual solution comes in six parts:
> >
> > [P 1] Add the build support for using AutoFDO in Clang
> >
> >       Add the basic support for AutoFDO build and provide the
> >       instructions for using AutoFDO.
> >
> > [P 2] Fix objtool for bogus warnings when -ffunction-sections is enabled
> >
> > [P 3] Change the subsection ordering when -ffunction-sections is enabled
> >
> > [P 4] Enable –ffunction-sections for the AutoFDO build
> >
> > [P 5] Enable Machine Function Split (MFS) optimization for AutoFDO
> >
> > [P 6] Add Propeller configuration to the kernel build
> >
> > Patch 1 provides basic AutoFDO build support. Patches 2 to 5 further
> > enhance the performance of AutoFDO builds and are functionally dependent
> > on Patch 1. Patch 6 enables support for Propeller and is dependent on
> > patch 2 and patch 3.
> >
> > Caveats
> >
> > AutoFDO is compatible with both GCC and Clang, but the patches in this
> > series are exclusively applicable to LLVM 17 or newer for AutoFDO and
> > LLVM 19 or newer for Propeller. For profile conversion, two different
> > tools could be used, llvm_profgen or create_llvm_prof. llvm_profgen
> > needs to be the LLVM 19 or newer, or just the LLVM trunk. Alternatively,
> > create_llvm_prof v0.30.1 or newer can be used instead of llvm-profgen.
> >
> > Additionally, the build is only supported on x86 platforms equipped
> > with PMU capabilities, such as LBR on Intel machines. More
> > specifically:
> >  * Intel platforms: works on every platform that supports LBR;
> >    we have tested on Skylake.
> >  * AMD platforms: tested on AMD Zen3 with the BRS feature. The kernel
> >    needs to be configured with “CONFIG_PERF_EVENTS_AMD_BRS=y", To
> >    check, use
> >    $ cat /proc/cpuinfo | grep “ brs”
> >    For the AMD Zen4, AMD LBRV2 is supported, but we suspect a bug with
> >    AMD LBRv2 implementation in Genoa which blocks the usage.
> >
> > Experiments and Results
> >
> > Experiments were conducted to compare the performance of AutoFDO-optimized
> > kernel images (version 6.9.x) against default builds.. The evaluation
> > encompassed both open source microbenchmarks and real-world production
> > services from Google and Meta. The selected microbenchmarks included Neper,
> > a network subsystem benchmark, and UnixBench which is a comprehensive suite
> > for assessing various kernel operations.
> >
> > For Neper, AutoFDO optimization resulted in a 6.1% increase in throughput
> > and a 10.6% reduction in latency. Unixbench saw a 2.2% improvement in its
> > index score under low system load and a 2.6% improvement under high system
> > load.
> >
> > For further details on the improvements observed in Google and Meta's
> > production services, please refer to the LLVM discourse post:
> > https://discourse.llvm.org/t/optimizing-the-linux-kernel-with-autofdo-including-thinlto-and-propeller/79108
> ...
> > Rong Xu (6):
> >   Add AutoFDO support for Clang build
> >   objtool: Fix unreachable instruction warnings for weak funcitons
> >   Change the symbols order when --ffuntion-sections is enabled
> >   AutoFDO: Enable -ffunction-sections for the AutoFDO build
> >   AutoFDO: Enable machine function split optimization for AutoFDO
> >   Add Propeller configuration for kernel build.
> >
> >  Documentation/dev-tools/autofdo.rst   | 165 ++++++++++++++++++++++++++
> >  Documentation/dev-tools/index.rst     |   2 +
> >  Documentation/dev-tools/propeller.rst | 161 +++++++++++++++++++++++++
> >  MAINTAINERS                           |  14 +++
> >  Makefile                              |   2 +
> >  arch/Kconfig                          |  42 +++++++
> >  arch/x86/Kconfig                      |   2 +
> >  arch/x86/kernel/vmlinux.lds.S         |   4 +
> >  include/asm-generic/vmlinux.lds.h     |  54 +++++++--
> >  scripts/Makefile.autofdo              |  25 ++++
> >  scripts/Makefile.lib                  |  20 ++++
> >  scripts/Makefile.propeller            |  28 +++++
> >  tools/objtool/check.c                 |   2 +
> >  tools/objtool/elf.c                   |  15 ++-
> >  14 files changed, 524 insertions(+), 12 deletions(-)
> >  create mode 100644 Documentation/dev-tools/autofdo.rst
> >  create mode 100644 Documentation/dev-tools/propeller.rst
> >  create mode 100644 scripts/Makefile.autofdo
> >  create mode 100644 scripts/Makefile.propeller
> >
> >
> > base-commit: eb952c47d154ba2aac794b99c66c3c45eb4cc4ec
> > --
> > 2.47.0.rc1.288.g06298d1525-goog
> >



--
Best Regards
Masahiro Yamada