c++ performance optimization

This work addresses key challenges in Profile-Guided Optimization (PGO): high sampling overhead, poor adaptability to dynamic inputs, and weak cross-architecture portability. We systematically survey and restructure the PGO technical landscape, proposing the first multi-dimensional classification framework for PGO—explicitly identifying three core research directions: low-overhead profiling, dynamic workload adaptation, and cross-architecture profile migration. Our approach unifies instrumentation- and sampling-based analysis, enabling compiler- and linker-time collaborative optimization in GCC and LLVM across heterogeneous targets including x86 and ARM. Empirical evaluation on standard benchmarks demonstrates an average performance improvement of 12.3%, while reducing profiling overhead to under 0.8%. These results significantly enhance the industrial deployability and generalization capability of PGO.

This work addresses the subtle microarchitectural performance inefficiencies often introduced by modern compiler optimizations, which can lead to significant yet overlooked performance losses. The authors propose a top-down differential analysis methodology that systematically identifies and categorizes the root causes of such optimization defects by integrating fine-grained microarchitectural performance counter sampling with cross-compiler (GCC/Clang) binary comparisons. Innovatively combining top-down microarchitectural analysis with differential testing, the approach further introduces a portable binary patching framework to precisely locate and rectify inefficient code segments. Empirical evaluation demonstrates that the method effectively uncovers substantial but commonly neglected performance discrepancies between GCC and Clang and successfully recovers performance through targeted binary patches.

Low-level systems (e.g., network stacks) resist efficient compile-time specialization for dynamic workloads and runtime environments due to high implementation complexity, difficulty in predicting optimal strategies, and continuously evolving conditions. This paper introduces Iridescent—the first online, automatic, measurement-driven JIT code specialization framework for low-level systems. Developers annotate only lightweight specialization points; the system autonomously explores and deploys optimal specialization strategies via JIT compilation and dynamic binary rewriting, guided by real-time performance feedback (e.g., latency, throughput), eliminating reliance on static compilation and manual modeling. Evaluated on real-world network stacks, Iridescent achieves significant performance improvements—up to 2.3× latency reduction and 1.8× throughput gain—while imposing minimal developer overhead. Crucially, it enables continuous optimization in response to dynamic workload shifts and heterogeneous hardware platforms, demonstrating robust adaptability across diverse deployment scenarios.

Existing benchmarks inadequately capture the complexity of performance optimization in real-world codebases, often neglecting trade-offs between runtime and memory usage, measurement noise, and input variability. To address this gap, this work proposes SWE-Pro—the first repository-scale benchmark for performance optimization—constructed from expert-driven optimization cases across 102 open-source projects. SWE-Pro introduces multidimensional evaluation metrics, including parameterized testing, noise-aware measurement protocols, and Time-Weighted Memory Usage (TWMU), to holistically reflect practical engineering challenges. Experimental results demonstrate that current large language models exhibit limited effectiveness on this benchmark, achieving negligible runtime improvements and virtually no memory optimization, whereas expert solutions yield an average speedup of 15.5× and a 171.3× reduction in peak memory consumption, underscoring both the benchmark’s realism and its difficulty.

Programming heterogeneous exascale HPC systems is hindered by the proliferation of complex, incompatible programming models (e.g., CUDA, SYCL, OpenMP) and the lack of traceability across CPU/GPU execution contexts. Method: We propose the first semantic-aware, full-stack API tracing framework built upon LTTng kernel tracing, integrating user-space dynamic instrumentation with multi-model API signature parsing to capture fine-grained, low-overhead, configurable API call chains across hardware and programming abstractions. Contribution/Results: Unlike conventional tracers logging only function names and timestamps, our framework enables cross-vendor, cross-abstraction behavioral correlation and end-to-end call-chain reconstruction in real HPC applications. It accurately identifies cross-model performance bottlenecks and implementation flaws, improving debugging efficiency by over 3× and significantly enhancing portability and debuggability of heterogeneous programming models.

研究通过结合静态代码特征、动态执行轨迹和内核级资源数据，发现13种性能原型，并提出一个多信号回归检测框架，以提高软件性能分析和预测的准确性。

Existing benchmarks for C++ performance repair are often based on competitive programming code or focus on other languages, lacking executable, real-world evaluation data. This work proposes CppPerf-Mine, an automated pipeline that mines genuine performance-improving commits from GitHub repositories and constructs CppPerf-DB—the first large-scale, multi-file, reproducible dataset of C++ performance enhancements. The pipeline integrates structured filtering, large language model–based classification, and Dockerized build-and-test validation. CppPerf-DB comprises 347 human-verified patches spanning 42 mature projects, with 39% involving modifications across multiple files. Preliminary evaluation shows that OpenHands, a state-of-the-art tool, successfully repairs only 13.5% of the cases, underscoring the dataset’s critical value for advancing repository-level performance repair research.

This study addresses the absence of open standards for CPU pipeline visualization tools and the difficulty in localizing performance bottlenecks. To this end, it proposes an open-source event stream format alongside Catscan, an interactive viewer. Methodologically, this work introduces a structured event stream based on transactional relationships, integrating typed event modeling, persistent highlighting techniques, and domain-specific search algorithms to enable microarchitectural trace analysis from symptoms down to individual instructions. Furthermore, it supports resource-oriented views synchronized with comparative trace alignment. By successfully reproducing industry-grade debugging workflows, this project provides the community with production-validated microarchitectural visualization infrastructure.

Existing benchmarks for execution-time optimization patches primarily target Python, C++, or .NET, lacking configurable, reproducible solutions tailored to Java. This work proposes JETO-Mine, the first framework for automatically mining and validating Java performance patches with customizable filtering and statistically rigorous validation. JETO-Mine employs a three-stage pipeline integrating static analysis, LLM-driven issue categorization, Docker-based dynamic testing, and significance testing to construct JETO-Bench—a benchmark comprising 660 candidate patches and 91 manually verified effective ones. Experimental evaluation demonstrates that JETO-Bench effectively assesses patch generation tools (e.g., OpenHands achieves a 14.3% repair success rate) and reveals a widespread absence of performance validation tests in Java projects.

Performance bugs in just-in-time (JIT) compilers can severely degrade program efficiency, yet systematic studies and automated detection approaches have been lacking. This work presents the first empirical analysis of 191 real-world JIT performance bugs, uncovering their triggering mechanisms, manifestation patterns, and root causes. To address this challenge, the authors propose a lightweight, hierarchical differential performance testing method that integrates test case prioritization with an automated deduplication and filtering mechanism, substantially improving both detection efficiency and precision. The implemented tool, Jittery, identified 12 previously unknown performance bugs in Oracle HotSpot and GraalVM—11 confirmed and 6 already fixed—while reducing testing time by 92.40%.