A Language Framework for Multi-Object Coordination
ECOOP '93 Proceedings of the 7th European Conference on Object-Oriented Programming
Finding stale-value errors in concurrent programs: Research Articles
Concurrency and Computation: Practice & Experience
Associating synchronization constraints with data in an object-oriented language
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of twenty-first ACM SIGOPS symposium on Operating systems principles
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
Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering - Volume 1
Accentuating the positive: atomicity inference and enforcement using correct executions
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
A data-centric approach to synchronization
ACM Transactions on Programming Languages and Systems (TOPLAS)
Detecting Concurrency Bugs from the Perspectives of Synchronization Intentions
IEEE Transactions on Parallel and Distributed Systems
Marathon: detecting atomic-set serializability violations with conflict graphs
RV'11 Proceedings of the Second international conference on Runtime verification
Scoped synchronization constraints for large scale actor systems
COORDINATION'12 Proceedings of the 14th international conference on Coordination Models and Languages
Hi-index | 0.00 |
Atomic sets are a synchronization mechanism in which the programmer specifies the groups of data that must be accessed as a unit. The compiler can check this specification for consistency, detect deadlocks, and automatically add the primitives to prevent interleaved access. Atomic sets relieve the programmer from the burden of recognizing and pruning execution paths which lead to interleaved access, thereby reducing the potential for data races. However, manually converting programs from lock-based synchronization to atomic sets requires reasoning about the program's concurrency structure, which can be a challenge even for small programs. Our analysis eliminates the challenge by automating the reasoning. Our implementation of the analysis allowed us to derive the atomic sets for large code bases such as the Java collections framework in a matter of minutes. The analysis is based on execution traces; assuming all traces reflect intended behavior, our analysis enables safe concurrency by preventing unobserved interleavings which may harbor latent Heisenbugs.