Eraser: a dynamic data race detector for multithreaded programs
ACM Transactions on Computer Systems (TOCS)
Reduction: a method of proving properties of parallel programs
Communications of the ACM
A type and effect system for atomicity
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
Accurate and efficient runtime detection of atomicity errors in concurrent programs
Proceedings of the eleventh ACM SIGPLAN symposium on Principles and practice of parallel programming
LOCKSMITH: context-sensitive correlation analysis for race detection
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Goldilocks: a race and transaction-aware java runtime
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Atomizer: A dynamic atomicity checker for multithreaded programs
Science of Computer Programming
Dynamic detection of atomic-set-serializability violations
Proceedings of the 30th international conference on Software engineering
Velodrome: a sound and complete dynamic atomicity checker for multithreaded programs
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
Preventing Memory Error Exploits with WIT
SP '08 Proceedings of the 2008 IEEE Symposium on Security and Privacy
ISOLATOR: dynamically ensuring isolation in comcurrent programs
Proceedings of the 14th international conference on Architectural support for programming languages and operating systems
HAVE: Detecting Atomicity Violations via Integrated Dynamic and Static Analysis
FASE '09 Proceedings of the 12th International Conference on Fundamental Approaches to Software Engineering: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
Lightweight annotations for controlling sharing in concurrent data structures
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
FastTrack: efficient and precise dynamic race detection
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
Fast byte-granularity software fault isolation
Proceedings of the ACM SIGOPS 22nd symposium on Operating systems principles
Debugging in the (very) large: ten years of implementation and experience
Proceedings of the ACM SIGOPS 22nd symposium on Operating systems principles
Dependent types for low-level programming
ESOP'07 Proceedings of the 16th European conference on Programming
Finding and reproducing Heisenbugs in concurrent programs
OSDI'08 Proceedings of the 8th USENIX conference on Operating systems design and implementation
Composable specifications for structured shared-memory communication
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Composable, nestable, pessimistic atomic statements
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Deterministic parallelism via liquid effects
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Marathon: detecting atomic-set serializability violations with conflict graphs
RV'11 Proceedings of the Second international conference on Runtime verification
RedCard: redundant check elimination for dynamic race detectors
ECOOP'13 Proceedings of the 27th European conference on Object-Oriented Programming
Hi-index | 0.00 |
Concurrent programming errors arise when threads share data incorrectly. Programmers often avoid these errors by using synchronization to enforce a simple ownership policy: data is either owned exclusively by a thread that can read or write the data, or it is read owned by a set of threads that can read but not write the data. Unfortunately, incorrect synchronization often fails to enforce these policies and memory errors in languages like C and C++ can violate these policies even when synchronization is correct. In this paper, we present a dynamic analysis for checking ownership policies in concurrent C and C++ programs despite memory errors. The analysis can be used to find errors in commodity multi-threaded programs and to prevent attacks that exploit these errors. We require programmers to write ownership assertions that describe the sharing policies used by different parts of the program. These policies may change over time, as may the policies' means of enforcement, whether it be locks, barriers, thread joins, etc. Our compiler inserts checks in the program that signal an error if these policies are violated at runtime. We evaluated our tool on several benchmark programs. The run-time overhead was reasonable: between 0 and 49% with an average of 26%. We also found the tool easy to use: the total number of ownership assertions is small, and the asserted specification and implementation can be debugged together by running the instrumented program and addressing the errors that arise. Our approach enjoys a pleasing modular soundness property: if a thread executes a sequence of statements on variables it owns, the statements are serializable within a valid execution, and thus their effects can be reasoned about in isolation from other threads in the program.