Busy-wait techniques are heavily used for mutual exclusion and barrier synchronization in shared-memory parallel programs. Unfortunately, typical implementations of busy-waiting tend to produce large amounts of memory and interconnect contention, introducing performance bottlenecks that become markedly more pronounced as applications scale. We argue that this problem is not fundamental, and that one can in fact construct busy-wait synchronization algorithms that induce no memory or interconnect contention. The key to these algorithms is for every processor to spin on separate locally-accessible ag variables, and for some other processor to terminate the spin with a single remote write operation at an appropriate time. Flag variables may be locally-accessible as a result of coherent caching, or by virtue of allocation in the local portion of physically distributed shared memory. We present a new scalable algorithm for spin locks that generates O(1) remote references per lock acquisition, independent of the number of processors attempting to acquire the lock. Our algorithm provides reasonable latency in the absence of contention, requires only a constant amount of space per lock, and requires no hardware support other than

Language-supported synchronization is a source of serious performance problems in many Java programs. Even singlethreaded applications may spend up to half their time performing useless synchronization due to the thread-safe nature of the Java libraries. We solve this performance problem with a new algorithm that allows lock and unlock operations to be performed with only a few machine instructions in the most common cases. Our locks only require a partial word per object, and were implemented without increasing object size. We present measurements from our implementation in the JDK 1.1.2 for AIX, demonstrating speedups of up to a factor of 5 in micro-benchmarks and up to a factor of 1.7 in real programs. 1 Introduction Monitors [5] are a language-level construct for providing mutually exclusive access to shared data structures in a multithreaded environment. However, the overhead required by the necessary locking has generally restricted their use to relatively "heavy-weight" object...

The theory developed in Part I is used to state the mutual exclusion problem and several additional fairness and failure-tolerance requirements. Four "distributed " N-process solutions are given, ranging from a solution requiring only one communication bit per process that permits individual starvation, to one requiring about N ! communication bits per process that satisfies every reasonable fairness and failure-tolerance requirement that we can conceive of. Contents 1 Introduction 3 2 The Problem 4 2.1 Basic Requirements . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Fairness Requirements . . . . . . . . . . . . . . . . . . . . . . 6 2.3 Premature Termination . . . . . . . . . . . . . . . . . . . . . 8 2.4 Failure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 3 The Solutions 14 3.1 The Mutual Exclusion Protocol . . . . . . . . . . . . . . . . . 15 3.2 The One-Bit Solution . . . . . . . . . . . . . . . . . . . . . . 17 3.3 A Digression . . . . . . . . . . . ...

We present a 'fine-grained' solution to the mutual exclusion problem. A program is finegrained if it uses only single-reader, single-writer boolean variables and if each of its atomic operations has at most one occurrence of at most one shared variable. In contrast to other fine-grained solutions that have appeared in the literature, processes in our solution do not busy-wait, but wait on one another only by executing await statements. Such statements can be implemented in practice either by means of context switching or by means of 'local' spinning. We show that our algorithm is correct even if shared variables are accessed nonatomically. Keywords: Busy-waiting, mutual exclusion, nonatomic operations, shared data, synchronization primitives.

We present an algorithm for the mutual exclusion problem that satisfies the "first come first served" property and requires only five shared bits per participant. The algorithm works in a model of concurrency that does not assume atomic operations. August 26, 1991 i 1. Introduction Mutual exclusion is a basic and classic synchronisation problem. Informally it can be formulated as follows. We have a collection of N processes each having the structure illustrated in Figure 1.1. repeat NCS Trying Protocol CS Exit Protocol forever Figure 1.1: Mutual exclusion problem Each process iterates repeatedly through a non-critical section (NCS) and a critical section (CS). The problem is to design a Trying Protocol and and Exit Protocol which surround the critical section and synchronise access to it in the following sense: Mutual Exclusion: No two processes should ever be inside their critical sections at the same time. Deadlock Freedom: A set of processes wishing to enter the critical sec...

An X11 based shared memory system, permitting the implementation of a distributed water network monitoring and control software suite, is described in this paper. The application source code is in FORTRAN and accesses shared memory via a C library module requiring no other support packages. X11 based distributed mutual exclusion algorithms, based on the unconventional use of Lamport's bakery algorithm, are evaluated. The system is compared with other methods of providing distributed shared memory.

We show how the synchronous programming language Esterel can be extended by a new statement to implement mutual exclusive code sections. We also show how the thereby extended Esterel language can be translated back to standard Esterel and we prove the correctness of this transformation. Additionally, we show that the translation fits well into different verification approaches. 1 Introduction Synchronous languages like Esterel [1,3] allow to describe multithreaded systems where the threads run in a synchronous manner. The synchronization of threads is for free since it is achieved directly by the semantics of the language: Most of the statements of synchronous languages do not consume time. Instead, consumption of time must be explicitely enforced by special statements, as e.g. the pause statement of Esterel. As it is only possible to consume a multiple of a logical unit of time, all threads of a system run synchronously to each other 1 . There exists techniques to translate a multi...

In real-world design and verification of concurrent systems with many identical processes, the number of processes is never a factor in the system correctness. This paper embodies such an engineering reasoning to propose an almost automatic method to safely verify safety properties of such systems. The central idea is to construct a finite collective quotient structure (CQS) which collapses state-space representations for all system implementations with all numbers of processes. The problem is presented as safety bound problem which ask if the number of processes satisfying a certain property exceeds a given bound. Our method can be applied to systems with dynamic linear lists of unknown number of processes. Processes can be deleted from or inserted at any position of the linear list during transitions. We have used our method to develop CQS constructing algorithms for two classes of concurrent systems : (1) untimed systems with a global waiting queue and (2) dense-time systems with on...

The problem of asynchronous processes reading shared data while the data are being modified by another process is considered. This problem differs from the standard readers/writers problem in that concurrent reading while writing is allowed. The model used here strongly limits the use and size of the shared variables. If multiple copies of the shared data are allowed, then simple, efficient solutions are found. In general, solutions which are more time efficient because they avoid waiting are seen to require more copies of the shared data. The number of copies used by all algorithms is shown to be the best possible. The main solution demonstrates that any system of processes which uses large distributed variables can be strongly simulated by a system which uses only binary distributed variables.

family of four mutual exclusion algorithms is t l presented. Its members vary from a simple three-bi inear wait mutual exclusion to the four-bit first-come e a first-served algorithm immune to various faults. Th lgorithms are based on a scheme similar to the e w Morris's solution of the mutual exclusion with thre eak semaphores. The presented algorithms compare a favorably with equivalent published mutual exclusion lgorithms in their program's size and the number of required communication bits.