Pith. sign in

REVIEW 5 major objections 6 minor 1 cited by

From Profiling to Optimization: Unveiling the Profile Guided Optimization

T0 review · 5 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This survey of five decades of profile-guided optimization claims the field reduces to a single trade-off — instrumentation buys higher peak speed, sampling buys consistent gains at far lower cost — and benchmarks both across x86-64 and…

desk verdict The survey half is a genuinely useful reference, but Section 5 contradicts its own tables so badly that the paper's central empirical claims don't survive. read the letter →

arxiv 2507.16649 v1 pith:XDOGEIIF submitted 2025-07-22 cs.PF

Bingxin Liu , Yinghui Huang , Jianhua Gao , Jianjun Shi , Yongpeng Liu , Yipin Sun , Weixing Ji This is my paper · ORCID
classification cs.PF
keywords profileguidedoptimizationfeedback-directedinstrumentationhardwaresamplingAutoFDOcompilerLLVMGCC
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper tries to establish a complete map of Profile Guided Optimization (PGO) — the family of techniques that runs a program once to learn how it behaves, then recompiles it with those observations — and to settle, with its own measurements, which flavour a practitioner should choose. On the survey side, it organizes five decades of work into a taxonomy built on how profiles are collected (exact instrumentation versus statistical sampling, hardware- or software-assisted) and when the feedback is applied (compile time, link or post-link time, runtime). On the evidence side, it reports speedups for four build modes — GCC and Clang, each with instrumentation-based FDO and sampling-based AutoFDO — across SPEC CPU 2017 and other workloads on x86-64 and ARM64. Its conclusion is that instrumentation-based PGO reaches higher peak performance but demands an expensive train-then-recompile cycle, while sampling-based PGO delivers consistent gains at much lower deployment cost. If the survey is right, it works as a one-stop decision guide for compiler and performance engineers, and its open challenges — zero-overhead sampling, dynamic workloads, and cross-architecture portability — become the field's agenda.

What carries the argument

The load-bearing machinery is the profile-reconstruction pipeline that turns raw observations into compiler decisions. On the instrumentation side, the Ball-Larus algorithms are central: optimal edge-counter placement is reduced to a maximum-spanning-tree problem, with flow-conservation equations at each vertex reconstructing all edge frequencies from a minimal counter set, and path profiling assigns each acyclic path a unique integer index by instrumenting only the chords of a spanning tree, giving complete path counts at roughly 1.3 times the cost of edge profiling. On the sampling side, the anchor is minimum-cost-flow (MCF) inference: hardware samples give sparse, noisy counts for a subset of edges, and a primal-dual successive-shortest-path solver (the paper's Algorithm 2) fills in a full, control-flow-graph-consistent frequency assignment that minimizes a cost whose edge weights encode confidence in the samples — the step credited with letting sampling-based PGO approach instrumentation accuracy. Around these two cores sit the integration objects: GCC's .gcno/.gcda and LLVM's .profraw/.profdata profile formats, the compiler passes that consume reconstructed weights (branch reordering, block placement, inlining, indirect-call promotion, loop transformations), and the post-link tools BOLT and Propeller that reorder the final binary.

What would settle it

Re-run one reported configuration exactly as described — for example, build 625.x264_s with Clang 15 instrumented FDO on an Intel Xeon Gold 6240C and measure its speedup over a plain -O3 build. Table 6 reports 1.000 for this case while Section 5.3's prose reports 1.087; a measurement matching neither value would show the reported data are not reproducible, and a full re-run of the benchmark matrix would settle which of the two conflicting accounts is correct.

Watch

Extended reading notes

Core claim

The paper's central claim is that the whole PGO landscape reduces to one engineering trade-off with a well-studied middle ground. Instrumentation inserts counters into the compiled program, yielding exact edge and path counts at the price of slowing the training run; sampling, especially hardware sampling through Intel PEBS, AMD IBS, branch-recording (LBR), and ARM SPE, gathers statistical evidence at a few percent overhead, and minimum-cost-flow inference reconstructs full control-flow-consistent frequencies from those sparse samples. The paper argues that this reconstruction machinery closes most of the quality gap, so sampling-based AutoFDO becomes competitive with instrumented FDO on compute-bound code while staying far cheaper to deploy. Its SPEC CPU 2017 measurements are offered as evidence that instrumentation-based FDO meets or beats sampling on peak speedup on both x86-64 and ARM64, with neither GCC nor LLVM systematically ahead. The survey also claims that ARM64 is a viable PGO target because SPE provides precise, low-overhead, zero-skid sampling, and that the next bottlenecks are cutting sampling overhead, keeping profiles valid when training inputs drift from production workloads, and making PGO portable across architectures.

Load-bearing premise

The paper's empirical conclusions rest on the speedup numbers in Tables 6 and 7 being accurate and internally consistent, and the surrounding prose reports several values that do not match those tables, so the architecture-level comparison of instrumentation versus sampling stands or falls with the reliability of those measurements.

Editorial extensions

If this is right

  • A practitioner choosing among GCC or Clang and FDO or AutoFDO gets a concrete answer: use instrumented FDO when a training run is affordable and peak speed matters, and sampling-based AutoFDO when deployment cost dominates.
  • Sampling is not a free lunch: on pointer-chasing, memory-bound code such as 605.mcf_s and sparse matrix-vector multiplication, AutoFDO can regress performance instead of improving it.
  • ARM64 becomes a first-class PGO target, since SPE-style sampling is claimed to support production AutoFDO workflows on ARM the way PEBS and IBS do on x86.
  • The proposed taxonomy — profiling method times optimization stage — is offered as the organizing frame for both future PGO research and tooling decisions.
  • Because neither compiler systematically dominates, workload characteristics, not toolchain choice, are what decide how much PGO helps.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Beyond the paper: the evidence it reports points toward a hybrid it never tests — instrumented profiles for the few hot kernels that justify training cost, sampled profiles for everything else — which its 'duplex sampling' future-work sketch gestures at.
  • The survey's cross-architecture sampling conclusion is stronger than its own ARM data: it reports instrumentation-based results on ARM64 but no AutoFDO measurements there, so the claim that SPE makes ARM sampling competitive rests on cited prior work, not on the paper's experiments.
  • A testable reading of the reconstruction literature it surveys: profile quality, not collection method, predicts PGO gains; one could verify the paper's central trade-off by degrading an instrumented profile to sampling-level noise and checking whether speedups converge.
  • Its fixed-input benchmark methodology leaves input robustness open; a natural follow-up would measure how speedups decay as test inputs diverge from the training inputs that produced the profiles.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 6 minor

Summary. The paper is a survey of Profile Guided Optimization (PGO/FDO) that organizes the field by profiling method (instrumentation vs. sampling), optimization stage (compile time, link/post-link time, runtime), compiler integration (GCC, LLVM), and target architecture. It reviews edge/path profiling, software and hardware sampling mechanisms (including IBS, PEBS, and ARM SPE), profile mapping and reconstruction, compiler passes, and post-link tools such as BOLT and Propeller. The paper then presents an empirical comparison of instrumentation-based FDO and sampling-based AutoFDO under GCC 12 and LLVM 15 on AMD64 and ARM, using SPEC CPU 2017 integer benchmarks, GROMACS, LAMMPS, FFTW, and microbenchmarks. The stated conclusions are that instrumentation-based FDO yields higher peak performance with more costly profile collection, while sampling-based AutoFDO gives more consistent speedups at lower deployment and runtime cost.

Significance. If the empirical core were reliable, the paper would be a useful one-stop reference: the taxonomy is broad, the algorithmic descriptions of Ball-Larus path profiling, minimum-cost-flow profile reconstruction, and the GCC/LLVM pass tables are informative, and the comparative evaluation would give practitioners concrete guidance. The survey portions alone have value, and the paper explicitly names modern systems (AutoFDO, BOLT, Propeller, CSSPGO, ARM SPE) with appropriate primary references. However, the significance of the contribution is dominated by the empirical claim, and that claim is internally inconsistent and lacks supporting overhead measurements. The strengths of the survey cannot compensate for an evaluation section whose prose and tables contradict each other on central numbers.

major comments (5)
  1. [§5.3 vs. Table 6] The prose in Section 5.3 cannot be reconciled with Table 6. The text reports 625.x264_s Clang-FDO at 1.087 and 631.deepsjeng_s GCC-FDO at 1.063, while Table 6 lists 1.000 and 0.985, respectively; it reports 605.mcf_s AutoFDO regressions of 0.982/0.976, while Table 6 shows GCC-AutoFDO 1.034 and Clang-AutoFDO 1.086. Since the abstract and conclusion draw their headline performance comparison from these measurements, at least one of the prose, the tables, or the experimental setup is wrong, and no artifact or raw data is provided to decide which.
  2. [§5.2 vs. §5.3] Section 5.2 explicitly states that the study evaluates "instrumentation-based PGO only on ARM architectures," yet Section 5.3 reports ARM AutoFDO values (0.971/0.959 for 605.mcf_s and 0.995 for 657.xz_s) that appear in neither Table 7 nor the experimental setup. This is not a local wording issue: the comparative conclusions about sampling-based PGO on ARM depend on these undocumented numbers, and the contradiction indicates that the experiments may not have been run as described.
  3. [§5.3, Table 6, Table 7] The claim that "instrumentation-based FDO consistently improves performance across all nine integer benchmarks" and the later claim of "robust, predictable speedups (2-10%) on all SPEC CPU 2017 integer benchmarks" are directly contradicted by the paper's own tables. Table 6 shows GCC-FDO slowdowns for 623.xalancbmk_s (0.949), 631.deepsjeng_s (0.985), and 641.leela_s (0.940), and Clang-FDO slowdowns for 623.xalancbmk_s (0.938) and 657.xz_s (0.970). Table 7 shows GCC-FDO values below 1.0 for 623.xalancbmk_s (0.990), 631.deepsjeng_s (0.995), and 641.leela_s (0.961). These entries undermine the central empirical conclusion as stated.
  4. [§5, Tables 6-7, §7] The paper's headline trade-off, that instrumentation-based PGO is costly while sampling-based PGO has much lower deployment and runtime costs, is not measured anywhere in Section 5. Tables 6 and 7 report only speedup ratios; there are no measurements of profile-collection phase duration, build time, or runtime overhead. Without such measurements, the conclusion in Section 7 about "costly profile-collection phases" and "much lower deployment and runtime costs" is unsupported by the presented evidence.
  5. [§5.1-§5.2] The experimental methodology is under-specified for the strength of the conclusions. Section 5.2 gives compiler versions, hardware, and the general FDO/AutoFDO workflows, but it does not state which SPEC inputs were used for profiling and for measurement, how many repetitions were performed, whether the reported ratios are geomeans or individual runs, or what variance was observed. Many reported values are within 1-3% of 1.0, so without this information the claims of consistent gains or regressions are not statistically grounded.
minor comments (6)
  1. [§5.3] The text says "bars above the 1.0 line" and "these plots," but the results are presented in tables (Tables 6 and 7), not plots.
  2. [§5.1] The microbenchmark subsection lists seven kernels (acos, asin, bubble-sort, matrix inverse, L2-norm, matrix multiplication, SpMV) after saying "six kernels," and the following sentence refers to "These nine test cases," which does not match the count of the immediately preceding list.
  3. [Table 6] The benchmark name "600.perlbech_s" should be "600.perlbench_s".
  4. [§3.2.3] The citation "nehao et al. [16]" appears to refer to Dehao Chen et al.; the author names should be corrected throughout so that cited authors are identified by surname rather than given name.
  5. [Endmatter] The closing lines "Received 20 February 2007; revised 12 March 2009; accepted 5 June 2009" appear to be a template artifact and should be removed or replaced with the actual submission dates.
  6. [Table 1] The reference list entry for [32, 32] contains a duplicated citation number; this should be cleaned up.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: this is a survey with independent empirical measurements, and no load-bearing argument reduces to its own inputs or to self-citation.

full rationale

The paper is a survey of PGO techniques followed by an original benchmark evaluation; it does not present a formal derivation chain whose conclusion is equivalent to a fitting assumption or to a prior result of the same authors. The classification of profiling techniques, compiler passes, and hardware mechanisms is descriptive and cites classic independent literature (Ball-Larus, ProfileMe, AutoFDO, BOLT, etc.), and the cited results are external, established systems rather than uniqueness theorems or ansatze imported from this paper's own authors. The empirical section reports speedup ratios for GCC-FDO, GCC-AutoFDO, Clang-FDO, and Clang-AutoFDO against an -O3 baseline; these are measured quantities, not parameters fitted to then predict the same benchmarks, so there is no fitted-input-called-prediction pattern. The abstract and conclusion draw a performance/cost trade-off between instrumentation and sampling, but the claimed trade-off is not itself derived from the data in Tables 6 and 7, which contain only speedups and no profile-collection or build-time measurements; that is a support gap or internal-consistency problem (the prose disagrees with the tables on several values, e.g., 625.x264_s Clang-FDO and 605.mcf_s AutoFDO, and ARM AutoFDO values are discussed even though Section 5.2 restricts ARM to instrumentation-based PGO), but it is not circularity. No self-referential derivation, no equation reduces to an earlier equation by construction, and no central claim is justified solely by the authors' own prior publications. Per the reviewing rule, the manuscript's internal contradictions are flagged as correctness risks rather than as circular steps, since none of them make the conclusion equivalent to its inputs.

Assumptions & free parameters 0 free parameters · 2 assumptions · 0 invented entities

The paper introduces no free parameters or invented entities. The empirical claims rest on the domain assumptions listed above, plus the general background knowledge of compiler behavior and PMU hardware that the survey cites.

assumptions (2)
  • domain assumption Speedup measurements on the two specific testbeds (Intel Xeon Gold 6240C, Phytium FT-2000+/64) are representative of AMD64 and ARM64 platforms generally.
    Section 5.2 describes one x86 and one ARM machine, while Section 5.3 draws architecture-level conclusions about PGO behavior; microarchitectural differences such as branch predictors and cache hierarchies can change relative speedups.
  • domain assumption The selected SPEC CPU 2017 subset and microbenchmarks represent the workload classes discussed in the survey.
    Section 5.1 chooses nine SPEC workloads and six kernels, but the survey conclusions about PGO techniques are stated broadly, so the benchmark set must be representative.

how reviews work

0 comments
Cite this review

Pith. "Pith review of From Profiling to Optimization: Unveiling the Profile Guided Optimization." pith.science (2026). https://pith.science/paper/XDOGEIIF

@misc{pith2026250716649,
  author       = {Pith},
  title        = {Pith review of: From Profiling to Optimization: Unveiling the Profile Guided Optimization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XDOGEIIF}},
  note         = {Machine review of arXiv:2507.16649}
}
read the original abstract

Profile Guided Optimization (PGO) uses runtime profiling to direct compiler optimization decisions, effectively combining static analysis with actual execution behavior to enhance performance. Runtime profiles, collected through instrumentation or hardware- and software-assisted sampling, provide detailed insights into control flow, branch predictions, and memory access patterns. This survey systematically categorizes PGO research by profiling method (instrumentation vs. sampling), optimizations (compile time and link/post-link time), compiler integration (GCC, LLVM), and target architectures. Key algorithms and frameworks are shown in terms of design principles. Performance evaluation on representative examples demonstrates PGO's speedups, overheads, and integration maturity. Finally, we identify open challenges, such as reducing sampling overhead, dynamic input workloads, and supporting cross-architecture portability, and propose future research directions to low-overhead profiling and advanced compilers.

Figures

Figures reproduced from arXiv: 2507.16649 by the authors.

Figure 1
Figure 1. End-to-end PGO workflow: the left most sub-figure shows normal compile stages; The middle one [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Different hot-path extractions with the same execution count. Orange-colored blocks and edges are [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. From a raw CFG to a Ball-Larus-instrumented graph: (a) raw graph, (b) value calculation, (c) final [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: GCC and LLVM profile format in memory (packed from a four-character ASCII string such as “B62r” to allow simple lexical comparisons), and a 32-bit “stamp” counter that ties together note and data generations. In the notes file only, an additional 32-bit word indicates …
Figure 5
Figure 5. Figure 5: PGO-driven block placement to improve I-cache performance. colored blocks and lines are hot. [PITH_FULL_IMAGE:figures/full_fig_p021_5.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. ML for the hKLM at the 2nd Detector

    physics.ins-det 2026-04 unverdicted novelty 6.0 of 10

    Graph neural networks trained on simulated hits outperform classical methods for energy resolution, timing, and particle identification in an iron-scintillator sampling calorimeter, with an integrated multi-objective ...

Reference graph

Works this paper leans on

61 extracted references · 50 canonical work pages · cited by 1 Pith paper

  1. [1]

    Advanced Micro Devices, Inc. 2024. AMD64 Architecture Programmer’s Manual, Volume 2: System Programming . Publication No. 24593; Rev. 3.42. Advanced Micro Devices, Inc. https://www.amd.com/content/dam/amd/en/documents/ processor-tech-docs/programmer-references/24593.pdf

    work page 2024

  2. [2]

    Glenn Ammons, Thomas Ball, and James R. Larus. 1997. Exploiting Hardware Performance Counters with Flow and Context Sensitive Profiling. In Proceedings of the ACM SIGPLAN 1997 Conference on Programming Language Design and Implementation (Las Vegas, Nevada, USA) (PLDI ’97). Association for Computing Machinery, New York, NY, USA, 85–96. doi:10.1145/258915.258924

    work page arXiv 1997

  3. [3]

    Glenn Ammons, Thomas Ball, and James R. Larus. 1997. Exploiting Hardware Performance Counters with Flow and Context Sensitive Profiling. SIGPLAN Not. 32, 5 (May 1997), 85–96. doi:10.1145/258916.258924

    work page arXiv 1997

  4. [4]

    Matthew Arnold, Stephen Fink, David Grove, Michael Hind, and Peter F. Sweeney. 2011. Adaptive Optimization in The Jalapeno JVM. SIGPLAN Not. 46, 4 (May 2011), 65–83. doi:10.1145/1988042.1988048 J. ACM, Vol. 37, No. 4, Article 111. Publication date: August 2025. From Profiling to Optimization: Unveiling the Profile Guided Optimization 111:33

    work page arXiv 2011

  5. [5]

    Matthew Arnold and Barbara G. Ryder. 2001. A Framework for Reducing the Cost of Instrumented Code. InProceedings of the ACM SIGPLAN 2001 Conference on Programming Language Design and Implementation (Snowbird, Utah, USA) (PLDI ’01). Association for Computing Machinery, New York, NY, USA, 168–179. doi:10.1145/378795.378832

    work page arXiv 2001

  6. [6]

    Amir Ayupov, Maksim Panchenko, and Sergey Pupyrev. 2024. Stale Profile Matching. In Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction (Edinburgh, United Kingdom) (CC 2024). Association for Computing Machinery, New York, NY, USA, 162–173. doi:10.1145/3640537.3641573

    work page arXiv 2024

  7. [7]

    Ball and J.R

    T. Ball and J.R. Larus. 1996. Efficient Path Profiling. InProceedings of the 29th Annual IEEE/ACM International Symposium on Microarchitecture. MICRO 29. 46–57. doi:10.1109/MICRO.1996.566449

    work page arXiv 1996

  8. [8]

    Thomas Ball and James R. Larus. 1994. Optimally Profiling and Tracing Programs. ACM Trans. Program. Lang. Syst. 16, 4 (July 1994), 1319–1360. doi:10.1145/183432.183527

    work page arXiv 1994

Show all 61 references
  1. [9]

    Bond and K.S

    M.D. Bond and K.S. McKinley. 2005. Practical Path Profiling for Dynamic Optimizers. In International Symposium on Code Generation and Optimization . 205–216. doi:10.1109/CGO.2005.28

    2005 doi

  2. [10]

    Bowman, Swaha Miller, Vincent St-Amour, and R

    William J. Bowman, Swaha Miller, Vincent St-Amour, and R. Kent Dybvig. 2015. Profile-guided MEta-programming. SIGPLAN Not. 50, 6 (June 2015), 403–412. doi:10.1145/2813885.2737990

    2015

  3. [11]

    Derek Bruening, Timothy Garnett, and Saman Amarasinghe. 2003. An Infrastructure for Adaptive Dynamic Opti- mization. In Proceedings of the International Symposium on Code Generation and Optimization: Feedback-Directed and Runtime Optimization (San Francisco, California, USA) (...

    2003

  4. [12]

    Derek Bruening, Qin Zhao, and Reid Kleckner. 2020. DynamoRIO: Dynamic Instrumentation Tool Platform. URL http://www. dynamorio. org (2020)

    2020

  5. [13]

    Cristian Cadar, Daniel Dunbar, and Dawson Engler. 2008. KLEE: Unassisted and Automatic Generation of High- coverage Tests for Complex Systems Programs. In Proceedings of the 8th USENIX Conference on Operating Systems Design and Implementation (San Diego, California) (OSDI’08)....

    2008

  6. [14]

    Chang, Scott A

    Pohua P. Chang, Scott A. Mahlke, and Wen-mei W. Hwu. 1991. Using Profile Information to Assist Classic Code Optimizations. Softw. Pract. Exper. 21, 12 (Dec. 1991), 1301–1321. doi:10.1002/spe.4380211204

    1991 doi

  7. [15]

    Dehao Chen, David Xinliang Li, and Tipp Moseley. 2016. AutoFDO: Automatic Feedback-Directed Optimization for Warehouse-Scale Applications. In CGO 2016 Proceedings of the 2016 International Symposium on Code Generation and Optimization. New York, NY, USA, 12–23

    2016

  8. [16]

    Dehao Chen, Neil Vachharajani, Robert Hundt, Shih-wei Liao, Vinodha Ramasamy, Paul Yuan, Wenguang Chen, and Weimin Zheng. 2010. Taming Hardware Event Samples for FDO Compilation. InProceedings of the 8th Annual IEEE/ACM International Symposium on Code Generation and Optimizati...

    2010

  9. [17]

    Hyoun Kyu Cho, Tipp Moseley, Richard Hank, Derek Bruening, and Scott Mahlke. 2013. Instant Profiling: Instrumen- tation Sampling for Profiling Datacenter Applications. In Proceedings of the 2013 IEEE/ACM International Symposium on Code Generation and Optimization (CGO) . 1–10....

    2013

  10. [18]

    Conte, B.A

    T.M. Conte, B.A. Patel, and J.S. Cox. 1994. Using Branch Handling Hardware to Support Profile-driven Optimization. In Proceedings of MICRO-27. The 27th Annual IEEE/ACM International Symposium on Microarchitecture . 12–21. doi:10. 1145/192724.192726

    1994

  11. [19]

    Dean, J.E

    J. Dean, J.E. Hicks, C.A. Waldspurger, W.E. Weihl, and G. Chrysos. 1997. ProfileMe: Hardware Support for Instruction- level Profiling on Out-of-order Processors. In Proceedings of 30th Annual International Symposium on Microarchitecture . 292–302. doi:10.1109/MICRO.1997.645821

    1997

  12. [20]

    Paul Drongowski, Lei Yu, Frank Swehosky, Suravee Suthikulpanit, and Robert Richter. 2010. Incorporating Instruction- Based Sampling into AMD CodeAnalyst. In 2010 IEEE International Symposium on Performance Analysis of Systems & Software (ISPASS). 119–120. doi:10.1109/ISPASS.20...

    2010

  13. [21]

    Fisher. 1981. Trace Scheduling: A Technique for Global Microcode Compaction. IEEE Trans. Comput. C-30, 7 (1981), 478–490. doi:10.1109/TC.1981.1675827

    1981

  14. [22]

    Fisher and Stefan M

    Joseph A. Fisher and Stefan M. Freudenberger. 1992. Predicting Conditional Branch Directions from Previous Runs of a Program. In Proceedings of the Fifth International Conference on Architectural Support for Programming Languages and Operating Systems (Boston, Massachusetts, U...

    1992

  15. [23]

    Gibbons and Steven S

    Philip B. Gibbons and Steven S. Muchnick. 1986. Efficient Instruction Scheduling for a Pipelined Architecture.SIGPLAN Not. 21, 7 (July 1986), 11–16. doi:10.1145/13310.13312

    1986

  16. [24]

    Wenlei He, Julián Mestre, Sergey Pupyrev, Lei Wang, and Hongtao Yu. 2022. Profile Inference Revisited. Proc. ACM Program. Lang. 6, POPL, Article 52 (Jan. 2022), 24 pages. doi:10.1145/3498714

    2022 doi

  17. [25]

    Wenlei He, Hongtao Yu, Lei Wang, and Taewook Oh. 2024. Revamping Sampling-Based PGO with Context-Sensitivity and Pseudo-instrumentation. In 2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO) . 322–333. doi:10.1109/CGO57630.2024.10444807 J. ACM, Vol...

    2024

  18. [26]

    Wenju He, Maosu Zhao, Yuxin Zou, and Feng Zou. 2023. Profile Guided Optimization Transfer-Learning for OpenCL/SYCL Kernel Compilation and Runtime. In Proceedings of the 2023 International Workshop on OpenCL (Cam- bridge, United Kingdom) (IWOCL ’23). Association for Computing M...

    2023

  19. [27]

    R. R. Heisch. 1994. Trace-directed Program Restructuring for AIX Executables.IBM Journal of Research and Development 38, 5 (1994), 595–603. doi:10.1147/rd.385.0595

    1994 doi

  20. [28]

    Michael Held and Richard M. Karp. 1971. The Traveling-salesman Problem and Minimum Spanning Trees. Operations Research 18, 6 (1971), 1138–1162. doi:10.1287/opre.18.6.1138

    1971 doi

  21. [29]

    Martin Hirzel. 2001. Bursty Tracing: A Framework for Low-Overhead Temporal Profiling. https://api.semanticscholar. org/CorpusID:1588330

    2001

  22. [30]

    Intel Corporation. 2025. Intel® 64 and IA-32 Architectures Software Developer’s Manual . Version latest. Intel Corpora- tion. https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html PDF manual updated Mar. 5, 2025

    2025

  23. [31]

    Thomas Kistler and Michael Franz. 2003. Continuous Program Optimization: A Case Study. ACM Trans. Program. Lang. Syst. 25, 4 (July 2003), 500–548. doi:10.1145/778559.778562

    2003

  24. [32]

    James R. Larus. 1999. Whole Program Paths. In Proceedings of the ACM SIGPLAN 1999 Conference on Programming Language Design and Implementation (Atlanta, Georgia, USA) (PLDI ’99). Association for Computing Machinery, New York, NY, USA, 259–269. doi:10.1145/301618.301678

    1999

  25. [33]

    Roy Levin, Ilan Newman, and Gadi Haber. 2008. Complementing Missing and Inaccurate Profiling Using a Minimum Cost Circulation Algorithm. In High Performance Embedded Architectures and Compilers , Per Stenström, Michel Dubois, Manolis Katevenis, Rajiv Gupta, and Theo Ungerer (E...

    2008

  26. [34]

    Xinliang David Li, Raksit Ashok, and Robert Hundt. 2010. Lightweight Feedback-Directed Cross-Module Optimization. In Proceedings of International Symposium on Code Generation and Optimization (CGO)

    2010

  27. [35]

    Kernighan

    Shen Lin and Brian W. Kernighan. 1973. An Effective Heuristic Algorithm for The Traveling-salesman Problem. Operations Research 21, 2 (1973), 498–516. doi:10.1287/opre.21.2.498

    1973 doi

  28. [36]

    Chi-Keung Luk, Robert Cohn, Robert Muth, Harish Patil, Artur Klauser, Geoff Lowney, Steven Wallace, Vijay Janapa Reddi, and Kim Hazelwood. 2005. Pin: Building Customized Program Analysis Tools with Dynamic Instrumentation. SIGPLAN Not. 40, 6 (June 2005), 190–200. doi:10.1145/1...

    2005

  29. [37]

    McFarling and J

    S. McFarling and J. Hennesey. 1986. Reducing The Cost of Branches. SIGARCH Comput. Archit. News 14, 2 (May 1986), 396–403. doi:10.1145/17356.17402

    1986

  30. [38]

    David Gordon Melski and Thomas Reps. 2002. Interprocedural Path Profiling and The Interprocedural Express-lane Transformation. Ph. D. Dissertation. AAI3049391

    2002

  31. [39]

    Samuel Miksits, Ruimin Shi, Maya Gokhale, Jacob Wahlgren, Gabin Schieffer, and Ivy Peng. 2025. Multi-level Memory- Centric Profiling on ARM Processors with ARM SPE. In Proceedings of the SC ’24 Workshops of the International Conference on High Performance Computing, Network, S...

    2025

  32. [40]

    Tipp Moseley, Alex Shye, Vijay Janapa Reddi, Dirk Grunwald, and Ramesh Peri. 2007. Shadow Profiling: Hiding Instrumentation Costs with Parallelism. In International Symposium on Code Generation and Optimization (CGO’07) . 198–208. doi:10.1109/CGO.2007.35

    2007 doi

  33. [41]

    Nicholas Nethercote and Julian Seward. 2007. Valgrind: a Framework for Heavyweight Dynamic Binary Instrumentation. In Proceedings of the 28th ACM SIGPLAN Conference on Programming Language Design and Implementation (San Diego, California, USA) (PLDI ’07). Association for Compu...

    2007 doi

  34. [42]

    Maksim Panchenko, Rafael Auler, Bill Nell, and Guilherme Ottoni. 2019. BOLT: A Practical Binary Optimizer for Data Centers and Beyond. In Proceedings of the 2019 IEEE/ACM International Symposium on Code Generation and Optimization (Washington, DC, USA) (CGO 2019). IEEE Press, 2–14

    2019

  35. [43]

    Maksim Panchenko, Rafael Auler, Laith Sakka, and Guilherme Ottoni. 2021. Lightning BOLT: Powerful, Fast, and Scalable Binary Optimization. InProceedings of the 30th ACM SIGPLAN International Conference on Compiler Construction (Virtual, Republic of Korea) (CC 2021). Associatio...

    2021

  36. [44]

    Karl Pettis and Robert C. Hansen. 1990. Profile Guided Code Positioning. SIGPLAN Not. 25, 6 (June 1990), 16–27. doi:10.1145/93548.93550

    1990

  37. [45]

    Vinodha Ramasamy, Paul Yuan, Dehao Chen, and Robert Hundt. 2008. Feedback-Directed Optimizations in GCC with Estimated Edge Profiles from Hardware Event Sampling. In Proceedings of GCC Summit 2008 . 87–102. http: //www.capsl.udel.edu/conferences/open64/2008/Papers/113.pdf

    2008

  38. [46]

    Han Shen, Krzysztof Pszeniczny, Rahman Lavaee, Snehasish Kumar, Sriraman Tallam, and Xinliang David Li. 2023. Pro- peller: A Profile Guided, Relinking Optimizer for Warehouse-Scale Applications. In Proceedings of the 28th ACM J. ACM, Vol. 37, No. 4, Article 111. Publication da...

    2023

  39. [47]

    Michael D. Smith. 2000. Overcoming The Challenges to Feedback-directed Optimization (Keynote Talk). SIGPLAN Not. 35, 7 (Jan. 2000), 1–11. doi:10.1145/351403.351408

    2000

  40. [48]

    Zhendong Su and Min Zhou. [n. d.]. A Comparative Analysis of Branch Prediction Schemes . https://www.cs.ucdavis. edu/~su/Berkeley/cs252/project.html

  41. [49]

    Toshio Suganuma, Toshiaki Yasue, and Toshio Nakatani. 2006. A Region-based Compilation Technique for Dynamic Compilers. ACM Trans. Program. Lang. Syst. 28, 1 (Jan. 2006), 134–174. doi:10.1145/1111596.1111600

    2006

  42. [50]

    Robert Endre Tarjan. 1983. Data Structures and Network Algorithms . Society for Industrial and Applied Mathematics. doi:10.1137/1.9781611970265 arXiv:https://epubs.siam.org/doi/pdf/10.1137/1.9781611970265

    1983 doi

  43. [51]

    Omri Traub, Stuart Schechter, and Michael D Smith. 2000. Ephemeral Instrumentation for Lightweight Program Profiling. Unpublished technical report, Department of Electrical Engineering and Computer Science, Hardward University, Cambridge, Massachusetts (2000)

    2000

  44. [52]

    John Whaley. 2000. A Portable Sampling-based Profiler for Java Virtual Machines. In Proceedings of the ACM 2000 Conference on Java Grande (San Francisco, California, USA) (JA V A ’00). Association for Computing Machinery, New York, NY, USA, 78–87. doi:10.1145/337449.337483

    2000

  45. [53]

    John Whaley. 2001. Partial Method Compilation Using Dynamic Profile Information. In Proceedings of the 16th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (Tampa Bay, FL, USA) (OOPSLA ’01). Association for Computing Machinery, New Y...

    2001

  46. [54]

    Vitillo, Dehao Chen, and David Levinthal

    Baptiste Wicht, Roberto A. Vitillo, Dehao Chen, and David Levinthal. 2014. Hardware Counted Profile-Guided Optimization. CoRR abs/1411.6361 (2014). arXiv:1411.6361 http://arxiv.org/abs/1411.6361

    2014 arXiv

  47. [55]

    David Williams-King and Junfeng Yang. 2019. CodeMason: Binary-Level Profile-Guided Optimization. InProceedings of the 3rd ACM Workshop on Forming an Ecosystem Around Software Transformation (London, United Kingdom) (FEAST’19). Association for Computing Machinery, New York, NY,...

    2019

  48. [56]

    Bo Wu, Mingzhou Zhou, Xipeng Shen, Yaoqing Gao, Raul Silvera, and Graham Yiu. 2013. Simple Profile Rectifications Go a Long Way. In ECOOP 2013 – Object-Oriented Programming , Giuseppe Castagna (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 654–678

    2013

  49. [57]

    Johnson, Michael D

    Cliff Young, David S. Johnson, Michael D. Smith, and David R. Karger. 1997. Near-optimal Intraprocedural Branch Alignment. In Proceedings of the ACM SIGPLAN 1997 Conference on Programming Language Design and Implementation (Las Vegas, Nevada, USA) (PLDI ’97). Association for C...

    1997

  50. [58]

    Cliff Young and Michael D. Smith. 1999. Static Correlated Branch Prediction. ACM Trans. Program. Lang. Syst. 21, 5 (Sept. 1999), 1028–1075. doi:10.1145/330249.330255

    1999

  51. [59]

    Mingzhou Zhou, Bo Wu, Xipeng Shen, Yaoqing Gao, and Graham Yiu. 2016. Examining and Reducing the Influence of Sampling Errors on Feedback-Driven Optimizations. ACM Trans. Archit. Code Optim. 13, 1, Article 6 (April 2016), 24 pages. doi:10.1145/2851502

    2016 doi

  52. [60]

    Craig Zilles and Gurindar Sohi. 2001. Execution-based Prediction Using Speculative Slices. SIGARCH Comput. Archit. News 29, 2 (May 2001), 2–13. doi:10.1145/384285.379246

    2001

  53. [61]

    Zilles and G.S

    C.B. Zilles and G.S. Sohi. 2001. A Programmable Co-processor for Profiling. In Proceedings HPCA Seventh International Symposium on High-Performance Computer Architecture . 241–252. doi:10.1109/HPCA.2001.903267 Received 20 February 2007; revised 12 March 2009; accepted 5 June 2...

    2001

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.