SysPilot is a cross‑library performance autotuning system that uses Library Performance Contracts (LPCs) to describe each library’s resource demands and observability signals. By synthesizing contracts from documentation and code, composing them for an application, and validating conflict hypotheses through profiling, SysPilot selects configurations that mitigate resource contention among independently developed libraries. In benchmark tests, SysPilot matches the performance of manually tuned autotuners and outperforms general‑purpose autotuners by up to 38% while requiring three times fewer runs.
arXiv:2410.22229v2 Announce Type: replace-cross Abstract: Offloading stateful network functions to multi-threaded SoC SmartNICs promises significant performance and cost benefits. However, realizing...
SWE-Opt is a new benchmark that evaluates large language models (LLMs) on repository‑level software performance optimization. It is built from 102 expert‑written optimizations from open‑source projects and measures runtime, peak memory, and Time‑Weighted Memory Usage (TWMU) under varied input data, execution conditions, and noise‑aware measurements. The study finds that current LLMs achieve few runtime gains and almost no memory improvements, whereas expert implementations deliver a 15.5× speedup and 171.3× memory reduction.
arXiv:2606. 04023v1 Announce Type: cross Abstract: While large language models (LLMs) have been extensively evaluated on code generation tasks for general-purpose programming and GPU-accelerated environments (e.
HoliBench is a modular benchmarking and deployment toolkit that jointly measures accuracy, latency, and energy for foundation models across a wide range of devices, from single-board computers to GPU servers. It provides a platform abstraction layer that calibrates cross-device measurements and supports multiple model modalities, inference engines, and quantization levels. Using HoliBench, the authors evaluated 20 models on 7 device types, revealing tradeoffs such as limited latency gains from quantization on low‑precision hardware and diminishing accuracy returns relative to energy consumption, while also showing that single-model profiles can predict multi-model pipeline performance within a few percent.
The paper introduces AutoProfiler, a feedback-driven framework that learns a deterministic profiling tree for GPU kernel optimization. By iteratively refining the tree with REWRITE and SPLIT operations guided by an LLM and empirical evaluation, it selects the most useful profiling metrics for each kernel rather than relying on a fixed set. Experiments on KernelBench demonstrate that this adaptive profiling approach outperforms static configurations under limited profiling budgets.
arXiv:2606. 20373v1 Announce Type: cross Abstract: Large Language Models (LLMs) show promise for code compilation tasks, but applying them to runtime performance tuning is difficult due to complex microarchitectural effects and noisy runtime measurements.
arXiv:2607. 20806v1 Announce Type: new Abstract: Lightweight large language models (LLMs) are increasingly being deployed locally on personal computers and are expected to play a growing role in resource-constrained edge and mobile environments.
arXiv:2609.37241v1 Announce Type: new Abstract: User-written Triton kernels enable high-performance GPU computation within PyTorch, but their end-to-end latency can remain dominated by host-side orch...
arXiv:2610.02932v1 Announce Type: new Abstract: Compiling GUI procedures that agents execute repeatedly into programs can reduce their token costs. However, measuring payback and deciding when to com...
Large language models have recently shown strong potential for automatically optimizing GPU kernels, yet their effectiveness depends critically on the hardware information available to the kernel opti...
arXiv:2607. 04542v1 Announce Type: cross Abstract: Every LLM agent run re-derives its behavior token by token on a frontier model: brilliant, expensive, slow, and unbounded.
Software performance optimization is a notoriously complex and manual task. Despite the growing use of Large Language Models (LLMs) for code refinement, we still lack benchmarks that capture how optimization actually happens in real-world codebases.