We present an algorithm for distributed mutual exclusion in a computer network of N nodes that communicate by messages rather than shared memory. The algorithm uses a spanning tree of the computer network, and the number of messages exchanged per critical section depends on the topology of this tree. However, typically the number of messages exchanged is O(log N) under light demand, and reduces to approximately four messages under saturated demand. Each node holds information only about its immediate neighbors in the spanning tree rather than information about all nodes, and failed nodes can recover necessary information from their neighbors. The algorithm does not require sequence numbers as it operates correctly despite message overtaking.

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 report presents a token-based K-mutual exclusion algorithm. The algorithm uses K tokens and a dynamic forest structure for each token. This structure is used to forward token requests. The algorithm is designed to minimize the number of messages and also the delay in entering the critical section, at low as well as high loads.

INTRODUCTION. Over the last decade distributed computing systems have attracted a great deal of attention. This is due, in part, to the technological advances in the design of sophisticated software and communication interfaces, the availability of low-cost processors and the rapid decline in hardware costs. The motivations for building distributed computing systems are many. Resource sharing, parallel processing, system availability and communication are four major reasons. By distributing a computation among various sites, processes are allowed to run concurrently and to share resources, but still work independently of each other. Many distributed computations involving the sharing of resources among various processes require that a resource be allocated to a single process at a time. Therefore, mutual exclusion is a fundamental problem in any distributed computing system. This problem must be solved to synchronize the access to shared resources in order to maintain their consist

Abstract not found

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.

AbstractÐThis paper presents a fair decentralized mutual exclusion algorithm for distributed systems in which processes communicate by asynchronous message passing. The algorithm requires betweenN 1 and 2…N 1 † messages per critical section access, where N is the number of processes in the system. The exact message complexity can be expressed as a deterministic function of concurrency in the computation. The algorithm does not introduce any other overheads over Lamport's and Ricart-Agrawala's algorithms, which require 3…N 1 † and 2…N 1 † messages, respectively, per critical section access and are the only other decentralized algorithms that allow mutual exclusion access in the order of the timestamps of requests. Index TermsÐAlgorithm, concurrency, distributed system, fairness, mutual exclusion, synchronization. 1

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

Abstract. We propose an architecture that consists of a ring of clusters for distributed mutual exclusion algorithms. Each node on the ring represents a cluster of nodes and implements various distributed mutual exclusion algorithms on behalf of any member in the cluster it represents. We show the implementation of Ricart-Agrawala and a Tokenbased algorithm on this architecture. The message complexities for both algorithms are reduced substantially with this architecture as well as obtaining better response times due to parallel processing in the clusters 1

Eliminating interference between concurrently executing activities through mutual exclusion is one of the most fundamental problems in computer systems. The problem of mutual exclusion in a distributed system is especially interesting owing to the lack of global knowledge in the presence of variable communication delays. In this paper, a new token-based distributed mutual exclusion algorithm is proposed. The algorithm incurs approximately three messages at high loads, irrespective of the number of nodes N in the system. At low loads, it requires approximately N messages. The paper also addresses failure recovery issues, such as token loss. 1 Introduction It is not uncommon multiple activities to require access to a single shared resource in a system. In order to avoid interference among these activities, access to the shared resource needs to be controlled. In operating systems, access to a section of code called the critical section (CS) is typically controlled using mutual exclus...