Concurrency control and recovery in database systems
Concurrency control and recovery in database systems
Concurrency control performance modeling: alternatives and implications
ACM Transactions on Database Systems (TODS)
Stability of binary exponential backoff
Journal of the ACM (JACM)
A model for concurrency in nested transactions systems
Journal of the ACM (JACM)
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The SPLASH-2 programs: characterization and methodological considerations
ISCA '95 Proceedings of the 22nd annual international symposium on Computer architecture
Proceedings of the fourteenth annual ACM symposium on Principles of distributed computing
The design, implementation, and evaluation of Jade
ACM Transactions on Programming Languages and Systems (TOPLAS)
Operating System Concepts
CONCUR '99 Proceedings of the 10th International Conference on Concurrency Theory
CIL: Intermediate Language and Tools for Analysis and Transformation of C Programs
CC '02 Proceedings of the 11th International Conference on Compiler Construction
Safejava: a unified type system for safe programming
Safejava: a unified type system for safe programming
Unbounded Transactional Memory
HPCA '05 Proceedings of the 11th International Symposium on High-Performance Computer Architecture
Virtualizing Transactional Memory
Proceedings of the 32nd annual international symposium on Computer Architecture
Autolocker: synchronization inference for atomic sections
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
McRT-STM: a high performance software transactional memory system for a multi-core runtime
Proceedings of the eleventh ACM SIGPLAN symposium on Principles and practice of parallel programming
Memory models for open-nested transactions
Proceedings of the 2006 workshop on Memory system performance and correctness
Atomicity via source-to-source translation
Proceedings of the 2006 workshop on Memory system performance and correctness
Conditional must not aliasing for static race detection
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Open nesting in software transactional memory
Proceedings of the 12th ACM SIGPLAN symposium on Principles and practice of parallel programming
Concurrent programming without locks
ACM Transactions on Computer Systems (TOCS)
Parallel Programmability and the Chapel Language
International Journal of High Performance Computing Applications
The transactional memory / garbage collection analogy
Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications
SharC: checking data sharing strategies for multithreaded c
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
Inferring locks for atomic sections
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
Is transactional programming actually easier?
Proceedings of the 15th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming
Dynamically checking ownership policies in concurrent c/c++ programs
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Transactional memory should be an implementation technique, not a programming interface
HotPar'09 Proceedings of the First USENIX conference on Hot topics in parallelism
Hi-index | 0.00 |
In this paper we introduce a new method for pessimistically implementing composable, nestable atomic statements. Our mechanism, called shelters, is inspired by the synchronization strategy used in the Jade programming language. Unlike previous lock-based pessimistic approaches, our mechanism does not require a whole-program analysis that computes a global lock order. Further, this mechanism frees us to implement several optimizations, impossible with automatically inserted locks, that are necessary for scaling on recent multi-core systems. Additionally we show how our basic mechanism can be extended to support both open- and closed-nesting of atomic statements, something that, to our knowledge, has not yet been implemented fully-pessimistically in this context. Unlike optimistic, transactional-memory-based approaches, programmers using our mechanism do not have to write compensating actions for open-nesting, or worry about the possibly awkward semantics and performance impact of aborted transactions. Similar to systems using locks, our implementation requires programmers to annotate the types of objects with the shelters that protect them, and indicate the sections of code to be executed atomically with atomic statements. A static analysis then determines from which shelters protection is needed for the atomic statements to run atomically. We have implemented shelter-based atomic statements for C, and applied our implementation to 12 benchmarks totaling over 200k lines of code including the STAMP benchmark suite, and the sqlite database system. Our implementation's performance is competitive with explicit locking, Autolocker, and a mature software transactional memory implementation.