sectionPGO - Block 1 2026 [a9fde3e6]

• Two most important IPO passes are function inlining and indirect function call promotion

• Basically:

  1. We want to have a smarter way of combining things without making fat .o files
  2. We can use FDO analysis to determine which functions are hot and worth inlining or promoting
  3. In order to do so, we can use a greedy algorithm to generate families, which help link these together
• We push linking earlier by using the profiled data

• Profile data is augmented FDO data, so

  • After training run is done, the in-memory info contains a callgraph, using a greedy clustering algorithm to decide on "friends"
  • afterwards, we have a standard FDO data (raw counts of how many times each branch was taken), and also module grouping decisions
• In order to make this workable for Buck / Blaze / Bazel, an auxillery file needs to get shipped so the build system knows which sources to include, even when they're not strictly dependant, as a form of dynamic dependency injection
• Predacessor to LTO (and ThinLTO)
• lists.llvm.org/pipermail/llvm-dev/2019-September/135393.html

• How does this interact with ASLR?
• I-cache much more constrained than Dcache

• Largely leverages the LBT, but also has to decide on the CFG
• The control flow graph has some nuances
• Optimization is one way, a binary once optimized may not be easily reversible back. Inlined functions are destructive transforms

• Context sensitive -> it uses the path taken to measure hotness for a function

  • i.e. foo -> bar -> baz. Baz might be cold globally, but baz might be really hot for the path itself

• Calculating edge frequency

  • Moves data into equvilance classes

    • Basic blocks within the same loop or dominated by the same condition have the same equivlance class
  • A function might be frequently called, but the functions inside it are varied, so we need the calling context
  • Flow based heuristic is iterative
• Compiler needs to basically map the control flow structure to map what's show in the profiler

• icache is frontend, and must be saved, because there's no out of order execuation
• figure 12 - multiple basic blocks are blocked
• Think hard about basic blocks and how they relate to this

• Uses the cycle counter in the LBR
• Uses the graph only, out of the CRONO suite

Disassembly is one of the primary serializing bottlenecks in state of the art PLO tools [52]. Accurate recursive disassembly [7] of complex applications is challenging to distribute across many machines due to the incremental nature of discovery.

Why? Can we not parallelize these?