Papers

---

• Survey/Review

  • When Memory Corruption Met Concurrency: Vulnerabilities in Concurrent Programs (Access 2023)
  • Understanding Concurrency Vulnerabilities in Linux Lernel (2022)
  • Understanding Real-World Concurrency Bugs in Go (ASPLOS 2019)
  • A systematic survey on automated concurrency bug detection, exposing, avoidance, and fixing techniques (SQJ 2018)
  • Surveying concurrency bug detectors based on types of detected bugs (2017)
  • A survey of race bug detection techniques for multithreaded programmes (2014)
  • Learning from Mistates: A Comprehensive Study on Real World Concurrency Bug Characteristics (ASPLOS 2008)
  • Understanding, Detecting and Exposing Concurrency Bugs (2003)
  • Notes on concurrency bugs
  • Slides: Dynamic Data Race Prediction
  • Slides: CS636: Testing Concurrent Programs - CSE-IITK - IIT Kanpur

• Thesis

  • Finding and Tolerating Concurrency Bugs (by Jie Yu)
  • A Pragmatic Verification Approach for Concurrent Programs (by Truc Lam Nguyen)
  • Efficient On-the-Fly Data Race Detection in Multithreaded C++ Programs (2017)

• Maximal Causality Reduction

  • Speeding Up Maximal Causality Reduction with Static Dependency Analysis (ECOOP 2017)
  • Maximal Causality Reduction for TSO and PSO (OOPSLA 2016)
  • Stateless Model Checking Concurrent Programs with Maximal Causality Reduction (PLDI 2015)
  • Maximal Sound Predictive Race Detection with Control Flow Abstraction (PLDI 2014)

• Stateless Model Checking

  • GenMC: A Model Checker for Weak Memory Models (CAV 2021) -[Slide], [Tool: GenMC]
  • Parallel graph-based stateless model checking (ATVA 2020)
  • Effective lock handling in stateless model checking (OOPSLA 2019)
  • Optimal stateless model checking under the release-acquire semantics (OOPSLA 2018)
  • Effective Stateless Model Checking for C/C++ Concurrency (POPL 2017) -[Tool: RCMC]
  • Stateless Model Checking with Data-Race Preemption Points (OOPSLA 2016)
  • Maximally stateless model checking for concurrent bugs under relaxed memory models (ICSE 2016)
  • Stateless model checking for TSO and PSO (2016) -[Tool: Nidhugg]
  • Stateless model checking for POWER (CAV 2016)
  • SATCheck: SAT-directed stateless model checking for SC and TSO (2015)
  • Fair stateless model checking (PLDI 2008)
  • Stateless model checking of event-driven applications (OOPSLA 2015)
  • CDSchecker: checking concurrent data structures written with C/C++ atomics (OOPSLA 2013) -[Tool: CDSchecker]
  • Model Checking for Programming Languages using VeriSoft (POPL 1997) -[Slide]

• Static Analysis

  • HIPPODROME: Data Race Repair using Static Analysis Summaries (TOSEM 2023)
  • Peahen: Fast and Precise Static Deadlock Detection via Context Reduction (FSE 2022)
  • Automatically Detecting and Fixing Concurrency Bugs in Go Software Systems (ASPLOS 2021)
  • PASAN: Detecting Peripheral Access Concurrency Bugs within Bare-Metal Embedded Applications (Usenix Sec 2021)
  • Thread-Modular Analysis of Release-Acquire Concurrency (SAS 2021)
  • When Threads Meet Events: Efficient and Precise Static Race Detection with Origins (PLDI 2021) -[Tool: coderrect]
  • Canary: Practical Static Detection of Inter-Thread Value-Flow Bugs (PLDI 2021)
  • OpenRace: An Open Source Framework for Statically Detecting Data Races (SC 2021) -[Tool: OpenRace]
  • LLOV: A Fast Static Data-Race Checker for OpenMP Programs (TACO 2020) -[Slide], [Tool: LLOV]
  • Detection of Concurrency Errors in Multithreaded Applications Based on Static Source Code Analysis (Access 2021)
  • OMPRacer: A Scalable and Precise Static RaceDetector for OpenMP Programs (SC 2020) -[Tool: OMPRacer]
  • Understanding Memory and Thread Safety Practices and Issues in Real-World Rust Programs (PLDI 2020)
  • SmartTrack: Efficient Predictive Race Detection (PLDI 2020)
  • A True Positives Theorem for a Static Race Detector Extended Version (POPL 2019)
  • Effective Static Analysis of Concurrency Use-After-Free Bugs in Linux Device Drivers (Usenix Sec 2019)
  • Towards incremental static race detection in OpenMP programs (Correctness 2018) -[Slide]
  • RacerD: Compositional Static Race Detection (OOPSLA 2018)
  • Using Polyhedral Analysis to Verify OpenMP Applications are Data Race Free (Correctness 2018)
  • Static race detection for device drivers: the Goblint approach (ASE 2016) -[Tool]
  • Polyhedral Optimizations of Explicitly Parallel Programs (PACT 2015)
  • Locksmith: Practical Static Race Detection for C. (TOPLAS 2011)
  • RELAY: Static Race Detection on Millions of Lines of Code (FSE 2007) -[Tool]

• Dynamic Analysis/Predictive Analysis

  • [Tolerate Control-Flow Changes for Sound Data Race Prediction (ICSE 2023)]
  • Deadlock Prediction via Generalized Dependency (ISSTA 2022)
  • Optimal Prediction of Synchronization-Preserving Races (POPL 2021)
  • Snowboard: Finding Kernel Concurrency Bugs through Systematic Inter-thread Communication Analysis (SOSP 2021)
  • Detecting Concurrency Vulnerabilities Based on Partial Orders of Memory and Thread Events (ESEC/FSE 2021)
  • Sound and Efficient Concurrency Bug Prediction (ESEC/FSE 2021)
  • KARD: Lightweight Data Race Detection with Per-Thread Memory Protection (ASPLOS 2021)
  • ExpRace: Exploiting Kernel Races through Raising Interrupts (Usenix Sec 2021)
  • Fast, sound, and effectively complete dynamic race prediction (POPL 2020)
  • The Complexity of Dynamic Data Race Prediction (LICS 2020)
  • Atomicity Checking in Linear Time using Vector Clocks (ASPLOS 2020)
  • Dynamic Analysis Method for Concurrency Bugs in Multi-process/Multi-thread Environments (IJPP 2020)
  • Low-overhead deadlock prediction (ICSE 2020)
  • Detecting Concurrency Memory Corruption Vulnerabilities (ESEC/FSE 2019)
  • UFO: Predictive Concurrency Use-After-Free Detection (ICSE 2018)
  • ConPredictor: Concurrency Defect Prediction in Real-World Applications (TSE 2018)
  • High-coverage, unbounded sound predictive race detection (ACM SIGPLAN Notices 2018)
  • What Happens-After the First Race? Enhancing the Predictive Power of Happens-Before Based Dynamic Race Detection (OOPSLA 2018)
  • Dynamic Race Prediction in Linear Time (PLDI 2017)
  • A dynamic predictive race detector for C/C++ programs (2017)
  • Dynamic Race Detection for C++11 (2017)
  • An Efficient Algorithm for On-the-Fly Data Race Detection Using an Epoch-Based Technique (2015)
  • Efficient Data Race Detection for C/C++ Programs Using Dynamic Granularity (2014)
  • Finding Complex Concurrency Bugs in Large Multi-Threaded Applications (EuroSys 2011)
  • ThreadSanitizer – data race detection in practice (2009)

• Fuzzing

  • Context-Sensitive and Directional Concurrency Fuzzing for Data-Race Detection (NDSS 2022)
  • Fuzzing Channel-Based Concurrency Runtimes using Types and Effects (OOPSLA 2020)
  • Muzz: Thread-aware Grey-box Fuzzing for Effective Bug Hunting in Multithreaded Programs (Usenix Sec 2020)
  • Krace: Data Race Fuzzing for Kernel File Systems (S&P 2020)
  • Finding race conditions in Kernels: from fuzzing to symbolic exection (2020)
  • ConFuzz—A Concurrency Fuzzer (2019)
  • Razzer: Finding Kernel Race Bugs through Fuzzing (S&P 2019)
  • A Heuristic Framework to Detect Concurrency Vulnerabilities (ACSAC 2018)
  • OWL: Understanding and Detecting Concurrency Attacks (DSN 2018)

• Dynamic Testing/Systematic Testing

  • Waffle: Exposing Memory Ordering Bugs Efficiently with Active Delay Injection (EuroSys 2023)
  • Efficiently Detecting Concurrency Bugs in Persistent Memory Programs (ASPLOS 2022)
  • Controlled Concurrency Testing via Periodical Scheduling (ICSE 2022)
  • C4: the C compiler concurrency checker (ISSTA 2021)
  • Nekara: Generalized Concurrency Testing (ASE 2021) -[Artifact]，[Tool]，[Slides]， [Video]
  • Snowboard: Finding Kernel Concurrency Bugs through Systematic Inter-thread Communication Analysis (SOSP 2021)
  • C11Tester: A Race Detector for C/C++ Atomics (ASPLOS 2021)
  • Language-agnostic systematic concurrency testing (2021)
  • Learning-Based Controlled Concurrency Testing (OOPSLA 2020)
  • Symbolic Partial-Order Execution for Testing Multi-Threaded Programs (CAV 2020)
  • Timeless Timing Attacks: Exploiting Concurrency to Leak Secrets over Remote Connections (Usenix Sec 2020)
  • Exploiting Kernel Races through Taming Thread Interleaving (BlackHat USA 2020)
  • Sparse record and replay with controlled scheduling (PLDI 2019)
  • Efficient Transaction-Based Deterministic Replay for Multi-threaded Programs (ASE 2019)
  • Efficient Scalable Thread-Safety-Violation Detection (SOSP 2019)
  • Adaptive Randomized Scheduling for Concurrency Bug Detection (ICECCS 2019) (JAVA)
  • Partial Order Aware Concurrency Sampling (CAV 2018)
  • Promoting Secondary Orders of Event Pairs in Randomized Scheduling using a Randomized Stride (ASE 2017)
  • Efficient Detection of Thread Safety Violations via Coverage-Guided Generation of Concurrent Tests (ICSE 2017) (JAVA)
  • ProRace: Practical Data Race Detection for Production Use (ASPLOS 2017) -[Tool: ProRace]
  • Radius Aware Probabilistic Testing of Deadlocks with Guarantees (ASE 2016)
  • SKI: Exposing Kernel Concurrency Bugs through Systematic Schedule Exploration (OSDI 2014)
  • Concurrency Testing Using Schedule Bounding: an Empirical Study (SCTBench) (PPoPP 2014)
  • Efficient Concurrency-Bug Detection Across Inputs (OOPSLA 2013)
  • Multicore Acceleration of Priority-Based Schedulers for Concurrency Bug Detection (PLDI 2012) -[Slides]
  • A Randomized Scheduler with Probabilistic Guarantees of Finding Bugs (ASPLOS 2010)
  • CalFuzzer: An Extensible Active Testing Framework for Concurrent Programs (CAV 2009)
  • Finding and Reproducing Heisenbugs in Concurrent Programs (OSDI 2008) -[Slides]
  • ConMem: Detecting Severe Concurrency Bugs through an Effect-Oriented Approach
  • Effective Testing for Concurrency Bugs (Thesis)
  • Concurrency: Testing isn’t good enough
  • Maple: a coverage-driven testing tool for multithreaded programs (OOPSLA 2012)
  • Stable Deterministic Multithreading through Schedule Memoization (OSDI 2010)
  • Race Directed Random Testing of Concurrent Programs (PLDI 2008)

• Other Verification Techniques

  • Dynamic verification of c/c++ 11 concurrency over multi copy atomics (2021)
  • Bounded Verification of Multi-threaded Programs via Lazy Sequentialization (TOPLAS 2021)
  • Compositional Non-Interference for Fine-Grained Concurrent Programs (S&P 2021)
  • Context-Bounded Verification of Liveness Properties for Multithreaded Shared-Memory Programs (POPL 2021)
  • On Algebraic Abstractions for Concurrent Separation Logics (POPL 2021)
  • Satisfiability Modulo Ordering Consistency Theory for Multi-threaded Program Verification (PLDI 2021)
  • Verifying Concurrent Search Structure Templates (PLDI 2020)
  • Armada: Low-Effort Verification of High-Performance Concurrent Programs (PLDI 2020)
  • The Anchor Verifier for Blocking and Non-blocking Concurrent Software (OOPSLA 2020)
  • Towards Generating Thread-Safe Classes Automatically (ASE 2020)
  • Parallel Refinement for Multi-Threaded Program Verification (ICSE 2019)
  • Finding rare concurrent programming bugs: An automatic, symbolic, randomized, and parallelizable approach (ICTAC2018)
  • A Runtime Verification Tool for Detecting Concurrency Bugs in FreeRTOS Embedded Software (ISPDC 2018)
  • Parallel Bug-finding in Concurrent Programs via Reduced Interleaving Instances (ASE 2017)
  • Inductive Data FLow Graph (POPL 2013)
  • Inspect: A Runtime Model Checker For Mulithreaded C Programs (2008)

• Energy Accounting

  • Calm Energy Accounting for Multithreaded Java Applications (ESEC/FSE 2020)

• Reproducing/Dubugging

  • Sparse record and replay with controlled scheduling (PLDI 2019)
  • AggrePlay: efficient record and replay of multi-threaded programs (ESEC/FSE 2019)
  • D4: Fast Concurrency Debugging with Parallel Differential Analysis (PLDI 2018)
  • DESCRY: Reproducing System-Level Concurrency Failures (ESEC/FSE 2017)
  • CONCURRIT: A Domain Specific Language for Reproducing Concurrency Bugs (PLDI 2013) -[Source]
  • Using_SCHED_DEADLINE

• Theory

  • A Concurrent Program Logic with a Future and History (OOPSLA 2022)
  • Concurrent Size (OOPSLA 2022)

• Empirical Study/Benchmarking

  • An Empirical Study on Concurrency Bugs in Interrupt-driven Embedded Software
  • Gobench: A benchmark suite of real-world go concurrency bugs (CGO 2021)
  • Actor Concurrency Bugs: A Comprehensive Study on Symptoms, Root Causes, API Usages, and Differences (OOPSLA 2021)
  • Concurrency testing using controlled schedulers: An empirical study (TOPC 2016) -[Source]
  • RADBench: A Concurrency Bug Benchmark Suite (USENIX HotPar 2011)
  • Bugbench: Benchmarks for Evaluating Bug Detection Tools -[Source1],[Source2]
  • A Case for an Interleaving Constrained Shared-Memory Multi-Processor -[Source]
  • The PARSEC benchmark suite: characterization and architectural implications (2008) -[Source]
  • Experience with a Concurrency Bugs Benchmark (2008) (JAVA)