A simple, basic and general model for describing both the (input-output) behavior and the implementation of distributed systems is presented. An important feature of the model is the separation of the machinery used to describe the implementation and the behavior. This feature makes the model potentially useful for design specification of systems and of subsystems.

Devices]: Modes of Computation -parallelism General Terms: Algorithms, Performance, Reliability, Theory Additional Key Words and Phrases: Asynchronous system, distributed computing,' FIFO, lower bound, queue, resource allocation, shared memory, space complexity This work was supported in part by the Office of Naval Research under contract N00014-82-K0154; by the U.S. Army Research Office under contract DAAG29-79-C-0155; and by the National Science Foundation under grants MCS77-02474, MCS77-15628, MCS78-01689, MCS-8116678, and DCR-8405478. N. A. Lynch's work was supported by NSF grant CCR-8611442, DARPA N00014-83K -0125, and ONR N00014-85-K-0168.

Concurrent Time-stamp Systems (ctss) allow processes to temporally order concurrent events in an asynchronous shared memory system, a powerful tool for concurrency control, serving as the basis for solutions to coordination problems such as mutual exclusion, `-exclusion, randomized consensus, and multi-writer multi-reader atomic registers. Solutions to these problems all use an "unbounded number" based concurrent time-stamp system (uctss), a construction which is as simple to use as it is to understand. A bounded "black-box" replacement of uctss would imply equally simple bounded solutions to most of these extensively researched problems. Unfortunately, while all know applications use uctss, all existing solution algorithms are only proven to implement the Dolev-Shavit ctss axioms, which have been widely criticized as "hard-to-use." While it is easy to show that a uctss implements the ctss axioms, there is no proof that a system meeting the ctss axioms implements uctss. Thus, the pro...

Mutual exclusion and concurrency are two fundamental and essentially opposite features in distributed systems. However, in some applications such as Computer Supported Cooperative Work (CSCW) we have found it necessary to impose mutual exclusion on dierent groups of processes in accessing a resource, while allowing processes of the same group to share the resource. To our knowledge, no such design issue has been previously raised in the literature. In this paper we address this issue by presenting a new problem, called Congenial Talking Philosophers, to model group mutual exclusion. We also propose several criteria to evaluate solutions of the problem and to measure their performance. Finally, we provide an ecient and highly concurrent distributed algorithm for the problem in a sharedmemory model where processes communicate by reading from and writing to shared variables. The distributed algorithm meets the proposed criteria, and has performance similar to some naive but...

this paper, the problem is generalized to a distributed system resource allocation problem which is local in two senses. First, although the system and number of users can be very large, there is a limit to the overlap in resource demands of different users. The second condition can be thought of as a property of the geography of the network - the resources are (or can be) located in the network in such a way that connunication between a user and any of its required resources is fast. Both types of locality conditions are satisfied by the Dining Philosophers problem. Under these two conditions, one would hope that waiting chains could be avoided, so that the worst-case time to grant a user's requests is independent of the total size of the network and the total number of users

This paper investigates the effects of the failure of shared objects on distributed systems. First the notion of a faulty shared object is introduced. Then upper and lower bounds on the space complexity of implementing reliable shared objects are provided.

We introduce concurrent time-stamping, a paradigm that allows processes to temporally order concurrent events in an asynchronous shared-memory system. Concurrent time-stamp systems are powerful tools for concurrency control, serving as the basis for solutions to coordination problems such as mutual exclusion, l-exclusion, randomized consensus, and multiwriter multireader atomic registers. Unfortunately, all previously known methods for implementing concurrent timestamp systems have been theoretically unsatisfying since they require unbounded-size time-stamps -- in other words, unbounded-size memory. This work presents the first bounded implementation of a concurrent time-stamp system, providing a modular unbounded-to-bounded transformation of the simple unbounded solutions to problems such as those mentioned above. It allows solutions to two formerly open problems, the boundedprobabilistic -consensus problem of Abrahamson and the fifo-l-exclusion problem of Fischer, Lynch, Burns and...

The group mutual exclusion problem extends the traditional mutual exclusion problem by associating a type with each critical section. In this problem, processes requesting critical sections of the same type can execute their critical sections concurrently. However, processes requesting critical sections of different types must execute their critical sections in a mutually exclusive manner. In this paper, we provide a distributed algorithm for solving the group mutual exclusion problem based on the notion of surrogatequorum. Intuitively, our algorithm uses the quorum that has been successfully locked by a request as a surrogate to service other compatible requests for the same type of critical section. Unlike the existing quorum-based algorithms for group mutual exclusion, our algorithm achieves a low message complexity of O(q), where q is the maximum size of a quorum, while maintaining both synchronization delay and waiting time at two message hops. Moreover, like the existing quorum-based algorithms, our algorithm has high maximum concurrency of n, where n is the number of processes in the system. The existing quorum-based algorithms assume that the number of groups is static and does not change during runtime. However, our algorithm can adapt without performance penalties to dynamic changes in the number of groups. Simulation results indicate that our algorithm outperforms the existing quorum-based algorithms for group mutual exclusion by as much as 50 % in some cases. 1.

Our work presents a self-stabilizing solution to the l-exclusion problem. This problem is a well-known generalization of the mutual-exclusion problem in which up to l, but never more than l, processes are allowed simultaneously in their critical sections. Selfstabilization means that even when transient failures occur and some processes crash, the system finally resumes its regular and correct behavior. The model of communication assumed here is that of shared memory, in which processes use single-writer multiple-reader regular registers.

In the group mutual exclusion problem, each critical section has a type or a group associated with it. Processes requesting critical sections of the same type may execute their critical sections concurrently. However, processes requesting critical sections of different types must execute their critical sections in a mutually exclusive manner. Most algorithms for group mutual exclusion that have been proposed so far implicitly assume that all groups are equally likely to be requested. In this paper, we propose an efficient algorithm for solving the problem when a relatively small number of groups are requested more frequently than others. Our algorithm has a message complexity of 2n − 1 per request for critical section, where n is the number of processes in the system. It has low synchronization delay of t and low waiting time of 2t, where t denotes the maximum message delay. The maximum concurrency of our algorithm is n, which implies that if all processes have requested critical sections of the same type, then all of them may execute their critical sections concurrently. Finally, the amortized message overhead of our algorithm is O(1). Our experimental results indicate that our algorithm outperforms the existing algorithms by as much as 50 % in some cases. KEY WORDS message-passing system, resource management, group mutual exclusion, token-based algorithm, non-uniform group access 1