Wait-free parallel algorithms for the union-find problem
STOC '91 Proceedings of the twenty-third annual ACM symposium on Theory of computing
The synergy between non-blocking synchronization and operating system structure
OSDI '96 Proceedings of the second USENIX symposium on Operating systems design and implementation
Simple, fast, and practical non-blocking and blocking concurrent queue algorithms
PODC '96 Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing
Thread scheduling for multiprogrammed multiprocessors
Proceedings of the tenth annual ACM symposium on Parallel algorithms and architectures
Thin locks: featherweight synchronization for Java
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Compositional pointer and escape analysis for Java programs
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
An efficient meta-lock for implementing ubiquitous synchronization
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
ACM Transactions on Computer Systems (TOCS)
Java Language Specification, Second Edition: The Java Series
Java Language Specification, Second Edition: The Java Series
OpenJIT: An Open-Ended, Reflective JIT Compiler Framework for Java
ECOOP '00 Proceedings of the 14th European Conference on Object-Oriented Programming
The Optimistic Readers Transformation
ECOOP '01 Proceedings of the 15th European Conference on Object-Oriented Programming
Pragmatic Nonblocking Synchronization for Real-Time Systems
Proceedings of the General Track: 2002 USENIX Annual Technical Conference
Even Better DCAS-Based Concurrent Deques
DISC '00 Proceedings of the 14th International Conference on Distributed Computing
IBM Systems Journal
Engineering a customizable intermediate representation
Proceedings of the 2003 workshop on Interpreters, virtual machines and emulators
Engineering a common intermediate representation for the Ovm framework
Science of Computer Programming - Special issue on advances in interpreters, virtual machines and emulators (IVME'03)
Hi-index | 0.00 |
Atomic instructions atomically access and update one or more memory locations. Because they do not incur the overhead of lock acquisition or suspend the executing thread during contention, they may allow higher levels of concurrency on multiprocessors than lock-based synchronization. Wait-free data structures are an important application of atomic instructions, and extend these performance benefits to higher level abstractions such as queues. In type-unsafe languages such as C, atomic instructions can be expressed in terms of operations on memory addresses. However, type-safe languages such as Java do not allow manipulation of arbitrary memory locations. Adding support for atomic instructions to Java is an interesting but important challenge.In this paper we consider several ways to support atomic instructions in Java. Each technique has advantages and disadvantages. We propose idiom recognition as the technique we feel has the best combination of expressiveness and simplicity. We describe techniques for recognizing instances of atomic operation idioms in the compiler of a Java Virtual Machine, and converting such instances into code utilizing atomic machine instructions. In addition, we describe a runtime technique which ensures that the semantics of multithreaded Java [11] are preserved when atomic instructions and blocking synchronization are used in the same program. Finally, we present benchmark results showing that for concurrent queues, a wait-free algorithm implemented using atomic compare-and-swap instructions yields better scalability on a large multiprocessor than a queue implemented with lock-based synchronization.