Granularity of locks and degrees of consistency in a shared data base
Readings in database systems (2nd ed.)
Proceedings of the fourteenth annual ACM symposium on Principles of distributed computing
Efficient support for complex numbers in Java
JAVA '99 Proceedings of the ACM 1999 conference on Java Grande
Concurrent Programming in Java. Second Edition: Design Principles and Patterns
Concurrent Programming in Java. Second Edition: Design Principles and Patterns
Ownership types for safe programming: preventing data races and deadlocks
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Software transactional memory for dynamic-sized data structures
Proceedings of the twenty-second annual symposium on Principles of distributed computing
Symbolic pointer analysis revisited
Proceedings of the ACM SIGPLAN 2004 conference on Programming language design and implementation
Composable memory transactions
Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming
Autolocker: synchronization inference for atomic sections
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The Atomos transactional programming language
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Enforcing isolation and ordering in STM
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Component-Based Lock Allocation
PACT '07 Proceedings of the 16th International Conference on Parallel Architecture and Compilation Techniques
Transactional boosting: a methodology for highly-concurrent transactional objects
Proceedings of the 13th ACM SIGPLAN Symposium on Principles and practice of parallel programming
Inferring locks for atomic sections
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
Proceedings of the twentieth annual symposium on Parallelism in algorithms and architectures
Dynamic optimization for efficient strong atomicity
Proceedings of the 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications
Maximum benefit from a minimal HTM
Proceedings of the 14th international conference on Architectural support for programming languages and operating systems
Scaling Java points-to analysis using SPARK
CC'03 Proceedings of the 12th international conference on Compiler construction
DISC'06 Proceedings of the 20th international conference on Distributed Computing
Automatic atomic region identification in shared memory SPMD programs
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Function flow: making synchronization easier in task parallelism
Proceedings of the 2012 International Workshop on Programming Models and Applications for Multicores and Manycores
Axis: automatically fixing atomicity violations through solving control constraints
Proceedings of the 34th International Conference on Software Engineering
Hi-index | 0.00 |
To achieve high-performance on multicore systems, sharedmemory parallel languages must efficiently implement atomic operations. The commonly used and studied paradigms for atomicity are fine-grained locking, which is both difficult to program and error-prone; optimistic software transactions, which require substantial overhead to detect and recover from atomicity violations; and compiler-generation of locks from programmer-specified atomic sections, which leads to serialization whenever imprecise pointer analysis suggests the mere possibility of a conflicting operation. This paper presents a new strategy for compiler-generated locking that uses data structure knowledge to facilitate more precise alias and lock generation analyses and reduce unnecessary serialization. Implementing and evaluating these ideas in the Java language shows that the new strategy achieves eight-thread speedups of 0.83 to 5.9 for the five STAMP benchmarks studied, outperforming software transactions on all but one benchmark, and nearly matching programmer-specified fine-grained locks on all but one benchmark. The results also indicate that compiler knowledge of data structures improves the effectiveness of compiler analysis, boosting eight-thread performance by up to 300%. Further, the new analysis allows for software support of strong atomicity with less than 1% overhead for two benchmarks and less than 20% for three others.The strategy also nearly matches the performance of programmer-specified fine-grained locks for the SPECjbb2000 benchmark, which has traditionally not been amenable to static analyses.