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)