The paper introduces PaRID, a software-directed soft error detection framework that uses parallel instruction duplication and LLM-tuned performance modeling. PaRID is designed to work at compile time for multithreaded programs, handling mixed serial and parallel regions while keeping performance overhead low. Experiments on NPB benchmarks show that PaRID cuts protection overhead from 162.79% to 59.84% on average and can achieve up to a 5× speedup while still detecting all errors.
arXiv:2607. 22588v1 Announce Type: new Abstract: Modern compute-intensive software must migrate across a changing ecosystem of accelerators, programming APIs, compiler stacks, and portability layers, including CUDA, OpenMP, OpenCL, and OpenMP target offload.
arXiv:2606. 29088v1 Announce Type: cross Abstract: There are various benchmarks to evaluate bugfixing capabilities of Large Language Models.
arXiv:2605. 28732v2 Announce Type: replace-cross Abstract: Memory is essential for enabling large language models to support long-horizon reasoning, yet existing memory systems remain unreliable and difficult to debug.
arXiv:2606. 23759v1 Announce Type: cross Abstract: Verilog debugging remains one of the most time-consuming stages in digital circuit design.
The paper investigates whether code large language models (CodeLLMs) inadvertently reproduce proprietary or sensitive code by evaluating seven state‑of‑the‑art training data detection (TDD) methods on eight CodeLLMs. It introduces CodeSnitch, a benchmark of 9,000 function‑level code samples across three languages, each labeled as included or excluded from training data, and applies mutation strategies based on the Type‑1 to Type‑4 code clone taxonomy to test TDD robustness. The study offers a systematic assessment of current TDD techniques for code and suggests directions for developing more effective detection methods.
The paper introduces HealBench, a benchmark of 265 runtime errors from 18 real-world repositories, and HealGuard, a safety framework that restricts healing code to an analyzable subset of Python and applies static and dynamic taint analysis. Using these tools, the authors evaluate a dedicated healing method and three general coding agents powered by different LLM backbones, achieving a 38.11% resume rate and a 28.68% test‑pass rate, while HealGuard flags 17.4% of successful healings as potentially unsafe. The study demonstrates that current LLM agents can meaningfully repair real repository crashes, but also highlights significant safety concerns that the Guardrail framework can detect, albeit with a high false‑positive rate.
Self-Decomposing Diffusion for Code (SDDC) is a new diffusion language model framework that first generates a contract outlining program decomposition and inter‑unit dependencies, then uses this contract to guide coordinated parallel implementation of complex programs. By planning decomposition before generation, SDDC balances the trade‑off between aggressive parallel decoding and maintaining program correctness. Across five benchmarks and two 7B diffusion backbones, SDDC improves pass@1 by up to 31.1 percentage points while decoding 7.5–13.7× faster than base models, and outperforms a fine‑tuning baseline by up to 23.5 points with lower latency.
arXiv:2606. 12983v1 Announce Type: new Abstract: Automated testbench generation has become a critical bottleneck in large language model (LLM)-driven Register Transfer Level (RTL) workflows, where large numbers of candidate designs must be verified rapidly and reliably.
arXiv:2606. 04594v1 Announce Type: cross Abstract: LLM serving frameworks are quickly evolving with a complex software stack and a vast number of optimizations.
arXiv:2606. 02430v1 Announce Type: cross Abstract: Large language models (LLMs) are increasingly integrated into high-performance computing (HPC) workflows, accelerating scientific discovery through diverse perspectives such as code generation and domain-specific decision-making.
CompileRover is a new optimization framework for virtual machine compilers that uses a tri‑role LLM‑driven collaboration mechanism involving a referee, an advisor, and an operator. It tackles common issues such as redundant computations, inefficient loops, and suboptimal function implementations by applying control‑flow analysis, code‑structure transformations, and dynamic execution pattern recognition. Benchmark evaluations show that CompileRover consistently outperforms existing virtual machine compilers, reducing execution overhead, improving data‑flow consistency, and enhancing overall compiler performance.
The paper introduces CETBench, a benchmark for assessing large language models (LLMs) on code-equivalence checking by generating program pairs through random code transformations. It demonstrates that even simple transformations significantly degrade LLM performance, especially in cross-lingual scenarios, and proposes a fine-tuning approach to improve results. The study provides detailed ablations on program difficulty and transformation types, offering insights into LLMs’ limited semantic understanding of code.