💻 computer science

An End-to-End Approach for Fixing Concurrency Bugs via SHB-Based Context Extractor

This paper presents ConFixAgent, an LLM-driven agent that employs a novel Static Happens-Before Graph-based context extraction method to automatically fix diverse concurrency bugs in an end-to-end manner without requiring prior bug-related information, significantly outperforming existing state-of-the-art tools.

Original authors: Zhuang Li, Qiuping Yi, Keyang Xiao, Zongcheng Ji, Hongliang Liang

Published 2026-04-08

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Zhuang Li, Qiuping Yi, Keyang Xiao, Zongcheng Ji, Hongliang Liang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are managing a busy kitchen with multiple chefs (threads) working at the same time. They are all trying to use the same stove, the same cutting board, and the same ingredients. Sometimes, they get in each other's way, grab the wrong pot, or forget to put the lid on the soup. These mistakes are concurrency bugs.

In the real world of software, these bugs are nightmares. They happen randomly, are incredibly hard to find, and fixing them manually is like trying to untangle a knot of headphones while wearing boxing gloves.

This paper introduces ConFixAgent, a new "AI Chef" designed to automatically find and fix these kitchen disasters without needing a human to point out exactly where the mess is.

Here is how it works, broken down into simple concepts:

1. The Problem: The "Needle in a Haystack"

Imagine you have a 1,000-page cookbook (the computer program). Somewhere in there, two chefs are fighting over a knife, causing a spill.

Old Tools: Most automated repair tools are like detectives who only look at the knife fight if you tell them, "Hey, look at page 452!" If you don't give them that hint, they get lost. Others try to guess by looking at every single page, but they often fix the wrong thing or miss the real problem.
The Human Cost: Programmers spend half their time just trying to find these bugs. It's slow and frustrating.

2. The Solution: ConFixAgent (The Smart Intern)

ConFixAgent is an AI agent that acts like a super-smart, tireless intern. It doesn't need you to tell it where the bug is. It does three things in a loop:

The Stress Test (Bug Detector): It runs the program thousands of times, trying to make the chefs fight in every possible way (like making Chef A grab the knife just as Chef B reaches for it). If a crash happens, it knows, "Okay, there's a bug here!"
The Spotlight (Context Extractor): This is the paper's biggest innovation.
- The Analogy: Imagine the program is a massive library. The bug is a specific sentence in a book. If you hand the AI the entire library, it gets overwhelmed and confused.
- The Fix: ConFixAgent uses a special map called a Static Happens-Before Graph. Think of this as a "Who-Touched-What-First" timeline. It looks at the chaos and says, "Okay, Chef A touched the pot, then Chef B touched the pan. These two are the troublemakers. Everyone else in the kitchen is just washing dishes and isn't involved."
- It throws away 90% of the code (the irrelevant dishes) and hands the AI only the specific "trouble zone." This stops the AI from getting distracted.
The Fixer (The LLM): With the "trouble zone" highlighted, the AI (a Large Language Model) reads the specific lines, understands the fight, and writes a patch (a new rule) to stop it. It might say, "Chef A must wait for Chef B to finish before grabbing the pot."

3. The "Magic" Behind the Scenes

The paper highlights two main tricks that make this work better than previous tools:

The "Happens-Before" Map: Instead of guessing, the tool builds a logical map of how events could happen. It filters out the noise. It's like a detective who ignores the crowd and focuses only on the two people who were arguing.
One-Step Thinking: Instead of asking the AI, "Where is the bug?" and then "How do I fix it?" (which confuses the AI), ConFixAgent asks, "Here is the messy scene; fix it." This keeps the AI focused on the solution rather than getting lost in the explanation.

4. The Results: A Winning Chef

The researchers tested ConFixAgent on a bunch of difficult "kitchens" (benchmark programs) that had broken in the past.

Old Tools: Could fix about 20-22 bugs. They often missed deadlocks (where chefs freeze because they are waiting for each other forever) or fixed the wrong thing.
ConFixAgent: Fixed 29 bugs, including the tricky deadlocks that other tools couldn't touch.
Quality: It didn't just fix the bug; it did so without adding unnecessary "locks" (rules) that would slow the kitchen down. It was precise.

Why This Matters

Before this, fixing these bugs required a human expert to act as a translator between the computer's chaos and the repair tool. ConFixAgent removes the human from the middle. It takes a broken program, finds the chaos, isolates the problem, and fixes it automatically.

In short: It's like giving your software a self-driving car that can not only see the potholes (bugs) but also know exactly which tire is flat, ignore the rest of the car, and patch the tire instantly, all while you sit back and watch.

1. Problem Statement

Concurrency bugs (e.g., data races, atomicity violations, deadlocks) are notoriously difficult to detect and fix due to the non-deterministic nature of thread execution. While Automated Program Repair (APR) techniques exist, current state-of-the-art tools face three critical limitations:

Dependency on Prior Information: Most tools assume bug-related information (detection, localization) is already available or rely on specific detection methods (static or dynamic) that often fail to pinpoint root causes accurately or generate false positives.
Limited Scope: Existing tools typically specialize in specific bug types (e.g., only data races or only deadlocks) rather than handling a universal range of concurrency issues.
LLM Limitations: While Large Language Models (LLMs) show promise in code repair, existing LLM-based APR approaches require manual intervention (developers must identify buggy code and annotate causes). Furthermore, feeding entire codebases to LLMs causes "attention dilution," where the model gets distracted by irrelevant code, reducing repair accuracy.

2. Methodology: ConFixAgent

The authors propose ConFixAgent, an end-to-end, LLM-driven agent capable of automatically detecting, localizing, and repairing various types of concurrency bugs in Java programs without manual input. The framework operates through an iterative loop:

A. Bug Detection

Tool: Uses Java PathFinder (JPF) as the bug detector.
Mechanism: JPF executes the program under various thread interleavings.
Oracle: A bug is identified if an assertion violation or uncaught runtime exception occurs during execution. This covers both non-deadlock bugs (data races, order violations, atomicity violations) and deadlocks (resource and communication deadlocks).

B. SHB-Based Context Extraction (Core Innovation)

To address the "attention dilution" problem in LLMs, ConFixAgent employs a novel Static Happens-Before Graph (SHBG) based context extractor.

Goal: Filter out irrelevant code to provide the LLM with only bug-relevant snippets while preserving concurrency semantics.
Process:
1. Construct SHBG: Builds a static representation of potential ordering constraints based on the program's source code (focusing on read/write events rather than just lock events to avoid over-filtering).
2. Identify Bug-Relevant Events: Uses the SHBG to find "conflicting events" (concurrent read/write or write/write on the same variable) that are not ordered by a happens-before relationship.
3. Mark Methods: Identifies methods containing these events.
4. Closure Computation: Performs a transitive closure on the call graph to include all methods that call the bug-relevant methods. This ensures the LLM sees the full context of the call chain (e.g., if put() calls down(), both are included).
5. Deadlock & Semantics Handling: Specifically detects potential deadlocks and includes "semantics-relevant methods" (e.g., thread creation/termination) to help the LLM understand thread interactions.
Result: The extracted code ( $P'$ ) is significantly smaller than the original ( $P$ ), filtering out >90% of tokens while retaining critical context.

C. LLM-Driven Localization and Repair

Strategy: The system adopts a One-Step approach (atomic localization and repair) rather than a Chain-of-Thought (two-step) approach. Experiments showed that separating localization and repair reduced accuracy due to context length issues.
Prompting: The LLM receives a structured prompt containing:
- The filtered source code ( $P'$ ).
- The bug report from JPF.
- Instructions to fix the bug without altering functionality or introducing new bugs.
Iterative Refinement: If the generated patch fails JPF checks or compilation, the error message is fed back to the LLM to refine the fix (up to 5 iterations).

3. Key Contributions

End-to-End Universal Fixer: ConFixAgent is the first tool to automate the entire workflow (detection, localization, repair) for diverse concurrency bugs (including deadlocks) without requiring manual bug information.
SHB-Based Context Extractor: A novel method using Static Happens-Before Graphs to filter code. It reduces input token count by over 90% and improves repair accuracy by 14% compared to using raw code.
Comprehensive Evaluation: The tool handles 17 distinct memory access patterns (covering data races, order violations, atomicity violations) and both types of deadlocks, a scope broader than previous tools like PFIX or HIPPODROME.

4. Experimental Results

The authors evaluated ConFixAgent on a benchmark suite of 43 programs (33 non-deadlock, 10 deadlock) from SIR, Pecan, and JaConTeBe.

Repair Success Rate:
- ConFixAgent: Successfully fixed 29 non-deadlock bugs and 4 deadlock bugs.
- PFIX (Dynamic Analysis): Fixed 22 non-deadlock bugs; 0 deadlocks.
- HIPPODROME (Static Analysis): Fixed 21 non-deadlock bugs; 0 deadlocks.
- SWE-agent (LLM Agent): Achieved only a 40% repair success rate (vs. ConFixAgent's 76%) on the same benchmarks.
Context Extraction Impact:
- Filtering irrelevant code increased repair accuracy from 62% (raw code) to 76% (filtered code) using GPT-4.
- The extractor achieved near-theoretical completeness in practice; no benchmark that was repairable with raw code failed after filtering.
Patch Quality:
- ConFixAgent introduced an average of 2 locks per fix.
- This is significantly better than HIPPODROME (8.42 locks), which tends to over-protect variables, and slightly higher than PFIX (1.5 locks), but ConFixAgent handles a wider variety of bug types including deadlocks.

5. Significance

Bridging the Gap: ConFixAgent demonstrates that LLMs can be effectively applied to the complex domain of concurrency bugs if provided with high-quality, semantically preserved context.
Practical Automation: It removes the heavy burden of manual bug localization from developers, offering a truly "end-to-end" solution that works on raw code.
Scalability: The context extraction algorithm is efficient ( $O(N^2)$ complexity relative to method count) and scales to large real-world programs (tested on 70k+ line projects).
Future Direction: The paper highlights that the quality of context provided to LLMs is the most critical factor for success in automated program repair, suggesting a new paradigm for future APR tools.