Transactional memory: architectural support for lock-free data structures
ISCA '93 Proceedings of the 20th annual international symposium on computer architecture
Proceedings of the fourteenth annual ACM symposium on Principles of distributed computing
The notions of consistency and predicate locks in a database system
Communications of the ACM
Introduction To Automata Theory, Languages, And Computation
Introduction To Automata Theory, Languages, And Computation
Soot - a Java bytecode optimization framework
CASCON '99 Proceedings of the 1999 conference of the Centre for Advanced Studies on Collaborative research
Language support for lightweight transactions
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
TLDI '05 Proceedings of the 2005 ACM SIGPLAN international workshop on Types in languages design and implementation
Unbounded Transactional Memory
HPCA '05 Proceedings of the 11th International Symposium on High-Performance Computer Architecture
Composable memory transactions
Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming
Virtualizing Transactional Memory
Proceedings of the 32nd annual international symposium on Computer Architecture
Advanced contention management for dynamic software transactional memory
Proceedings of the twenty-fourth annual ACM symposium on Principles of distributed computing
Associating synchronization constraints with data in an object-oriented language
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Autolocker: synchronization inference for atomic sections
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Runtime Analysis of Atomicity for Multithreaded Programs
IEEE Transactions on Software Engineering
Proceedings of the eleventh ACM SIGPLAN symposium on Principles and practice of parallel programming
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Component-Based Lock Allocation
PACT '07 Proceedings of the 16th International Conference on Parallel Architecture and Compilation Techniques
Automatic Parallelization and Optimization of Programs by Proof Rewriting
SAS '09 Proceedings of the 16th International Symposium on Static Analysis
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
Automatic fine-grain locking using shape properties
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Concurrent data representation synthesis
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Efficient bottom-up heap analysis for symbolic path-based data access summaries
Proceedings of the Tenth International Symposium on Code Generation and Optimization
Reasoning about lock placements
ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
Lock inference in the presence of large libraries
ECOOP'12 Proceedings of the 26th European conference on Object-Oriented Programming
Hi-index | 0.00 |
Atomicity provides strong guarantees against errors caused by unanticipated thread interactions, but is difficult for programmers to implement with low-level concurrency primitives. With the introduction of multicore processors, the problems are compounded. Atomic sections are a high level language feature that programmers can use to designate the blocks of code that need to be free from unanticipated thread interactions, letting the language implementation handle the low-level details such as deadlock. From a language designer's point of view, the challenge is to implement atomic sections without compromising performance. We propose an implementation of atomic sections that inserts locks transparently into object-oriented programs. The main advantages of our approach are: (1) We infer path expressions (that at run-time resolve to actual objects) for many more accesses in the atomic section than previous work could infer. (2) We use multi-granularity locking for guarding iterative traversals. (3) We ensure freedom from deadlock by rolling back the lock acquisition phase. (4) We release locks as early as possible. In summary, our approach uses a finer-grained locking discipline than previous lock inference techniques.