Mutual Exclusion Problem Research Articles

Space-efficient FCFS group mutual exclusion

In the group mutual exclusion problem [Y. Joung, Asynchronous group mutual exclusion, Distrib. Comput. 13 (2000) 189], which generalizes mutual exclusion [E. Dijkstra, Solution of a problem in concurrent programming control, Comm. ACM 8 (9) (1965) 569], a process chooses a session when it requests entry into the Critical Section. A group mutual exclusion algorithm must ensure that the mutual exclusion property holds: if two processes are in the Critical Section at the same time, then they request the same session. In addition to mutual exclusion, lockout freedom, bounded exit, and concurrent entering are basic properties that are desirable in any group mutual exclusion algorithm. Hadzilacos in [Proc. 20th Annual Symp. on Principles of Distributed Computing, 2001, pp. 100–106] first introduced a fairness condition, called first-come-first-served (FCFS), for group mutual exclusion. The only known FCFS group mutual exclusion algorithm is due to Hadzilacos [Proc. 20th Annual Symp. on Principles of Distributed Computing, 2001, pp. 100–106], and requires Θ ( N 2 ) bounded shared registers, where N is the number of processes. We present a FCFS group mutual exclusion algorithm that uses only Θ ( N ) bounded shared registers. (The existence of such an algorithm was posed as an open problem by Hadzilacos.)

Unifying stabilization and termination in message-passing systems

The paper dispels the myth that it is impossible for a message-passing program to be both terminating and stabilizing. We consider a rather general notion of termination: a terminating program eventually stops its execution after the environment ceases lo provide input. We identify termination-symmetry to be a necessary condition for a problem to admit a sollution with such properties. Our results do confirm that a number of well-known problems (e.g., consensus, leader election) do not allow a terminating and stabilizing solution. On the flip side, they show that other problems such as mutual exclusion and reliable-transmission allow such solutions. We present a message-passing solution to the mutual exclusion problem that is both stabilizing and terminating. We also desctibe an approach of adding termination to a stabilizing program. To illustrate this approach, we add termination to a stabilizing solution for the reliable transmission problem.

Mutual exclusion in asynchronous systems with failure detectors

This paper considers the fault-tolerant mutual exclusion problem in a message-passing asynchronous system and determines the weakest failure detector to solve the problem, given a majority of correct processes. This failure detector, which we call the trusting failure detector, and which we denote by T , is strictly weaker than the perfect failure detector P but strictly stronger than the eventually perfect failure detector ⋄ P . The paper shows that a majority of correct processes is necessary to solve the problem with T . Moreover, T is also the weakest failure detector to solve the fault-tolerant group mutual exclusion problem, given a majority of correct processes.

Group Mutual Exclusion in Token Rings

The group mutual exclusion (GME) problem was introduced by Joung. The GME solution allows n processes to share m mutually exclusive resources. We present several algorithms to solve the GME problem in token rings. The space requirement and the size of messages of all algorithms are bounded. So, the proposed algorithms solve the problem suggested by Joung, which is to obtain a solution using messages of bounded size. The time and space complexities of the first and second algorithms depend on n and m respectively. The first algorithm is more efficient when n <<m, whereas the second one when m <<n. The cost of the third algorithm is min(n, m). So, it is suitable for any type of network. However, the third solution is obtained with a message size of log(min(n, m)) extra bits. The third algorithm has an additional desirable property. It serves the requests in a first in first out manner. The fourth algorithm improves the bandwidth usage by avoiding the token circulation when no new requests are made for a different session. This property of the fourth algorithm can be incorporated into the other three algorithms.

Transversal merge operation: a nondominated coterie construction method for distributed mutual exclusion

A coterie is a set of subsets (called quorums) of the processes in a distributed system such that any two quorums intersect with each other and is mainly used to solve the mutual exclusion problem in a quorum-based algorithm. The choice of a coterie sensitively affects the performance of the algorithm and it is known that nondominated (ND) coteries achieve good performance in terms of criteria such as availability and load. On the other hand, grid coteries have some other attractive features: 1) a quorum size is small, which implies a low message complexity, and 2) a quorum is constructible on the fly, which benefits a low space complexity. However, they are not ND coteries unfortunately. To construct ND coteries having the favorite features of grid coteries, we introduce the transversal merge operation that transforms a dominated coterie into an ND coterie and apply it to grid coteries. We call the constructed ND coteries ND grid coteries. These ND grid coteries have availability higher than the original ones, inheriting the above desirable features from them. To demonstrate this fact, we then investigate their quorum size, load, and availability, and propose a dynamic quorum construction algorithm for an ND grid coterie.

On the nondomination of cohorts coteries

We show that subsets of Cohorts coteries proposed in [J.-R. Jiang et al., (1997)] are nondominated (ND) k-coteries, which are candidates to achieve the highest availability when utilized to solve the distributed k-mutual exclusion problem and the distributed h-out of-k mutual exclusion problem.

Speedup of Vidyasankar's algorithm for the group k-exclusion problem

Vidyasankar introduced a combined problem of k-exclusion and group mutual exclusion, called the group k-exclusion problem, which occurs in a situation where philosophers with the same interest can attend a forum in a meeting room, and up to k meeting rooms are available. We propose an improvement to Vidyasankar's algorithm. Waiting times in the trying region in the original algorithm and in our algorithm are bounded by n( n− k) c+O( n 3( n− k)) l and ( n− k) c+O( n( n− k) 2) l, respectively, where n is the number of processes, l is an upper bound on the time between successive two atomic steps, and c is an upper bound on the time that any philosopher spends in a forum.

Self-Stabilizing Mutual Exclusion Under Arbitrary Scheduler

A self-stabilizing algorithm, regardless of the initial system state, converges in finite time to a set of states that satisfy a legitimacy predicate. The mutual exclusion problem is fundamental in distributed computing, since it allows processors competing to access a shared resource to be able to synchronize and get exclusive access to the resource (i.e. execute their critical section). It is well known that providing self-stabilization in general uniform networks (e.g. anonymous rings of arbitrary size) can only be probabilistic. However, all existing uniform probabilistic self-stabilizing mutual exclusion algorithms designed to work under an unfair distributed scheduler (that may choose processors to execute their code in an arbitrary manner) suffer from the following common drawback: once stabilized, there exists no upper bound on time between two successive executions of the critical section at a given processor. In this paper, we present the first self-stabilizing algorithm that guarantees such a bound (O(n 3 ), where n is the network size) while working using an unfair distributed scheduler. Our algorithm works in an anonymous unidirectional ring of any size and has a polynomial expected stabilization time. Received 24 May 2002; revised 17 October 2003

Distributed mutual exclusion algorithms in mobile ad hoc networks

The problem of mutual exclusion has been extensively studied in distributed systems. The proposed solutions can be mainly classified in consensus based and token based protocols. Some of the proposed solutions consider the physical topology of the networks and try to provide optimal message exchange and minimal synchronisation delays. Others, impose a logical structure on the network like a ring or a tree. Recently, the mutual exclusion problem received an interest for mobile ad hoc networks. These networks are known as a challenging domain. To our knowledge, few algorithms have been proposed in the literature and all of them are token based approach. In this paper, we review the distributed mutual exclusion algorithms developed for mobile environments and principally for ad hoc networks and discuss some issues.

(h, k)-Arbiters for h-out-of-k mutual exclusion problem

h-Out-of-k mutual exclusion is a generalization of the 1-mutual exclusion problem, where there are k units of shared resources and each process requests h (1 ≤ h ≤ k) units at the same time. Though...

Some myths about famous mutual exclusion algorithms

Dekker's algorithm[9] is the historically first software solution to mutual exclusion problem for 2-process case. The first software solution for n -process case was subsequently proposed by Dijkstra[8]. These two algorithms have become de facto examples of mutual exclusion algorithms, for their historical importance. Since the publication of Dijkstra's algorithm, there have been many solutions proposed in the literature [24, 1, 2]. In that, Peterson's algorithm [21] is one among the very popular algorithms. Peterson's algorithm has been extensively analyzed for its elegance and compactness. This paper attempts to dispel the myths about some of the properties of these three remarkable algorithms, by a systematic analysis.

A self‐stabilizing token‐based k‐out‐of‐ℓ exclusion algorithm

AbstractIn this paper, we present the first self‐stabilizing solution to the k‐out‐of‐ℓ exclusion problem on a ring. The k‐out‐of‐ℓ exclusion problem is a generalization of the well‐known mutual exclusion problem—there are ℓ units of the shared resources, any process can request k $(1 \leq k \leq \ell)$ units of the shared resources, and no resource unit can be allocated to more than one process at one time. The space requirement of the proposed algorithm is independent of ℓ for all processors except a special processor, called Root. The stabilization time is only 5n, where n is the size of the ring. Copyright © 2003 John Wiley &amp; Sons, Ltd.

Scalable Room Synchronizations

This paper presents a scalable solution to the group mutual exclusion problem, with applications to linearizable stacks and queues, and related problems. Our solution allows entry and exit from the mutually exclusive regions in $O(t_r + \tau)$ time, where $t_r$ is the maximum time spent in a critical region by a user, and $\tau$ is the maximum time taken by any instruction, including a fetch-and-add instruction. This bound holds regardless of the number of users. We describe how stacks and queues can be implemented using two regions, one for pushing (enqueueing) and one for popping (dequeueing). These implementations are particularly simple, are linearizable, and support access in time proportional to a fetch-and-add operation. In addition, we present experimental results comparing room synchronizations with the Keane–Moir algorithm for group mutual exclusion.

A simple scheme to construct k‐arbiters with uniform quorum sizes

k‐Arbiter is a useful concept for solving the distributed h‐out of‐k mutual exclusion problem. The distributed h‐out of‐k mutual exclusion algorithms based on k‐arbiter have the benefits of high fault‐tolerance and low message cost. However, according to the definition of k‐arbiter, it is required to have a non‐empty intersection among any (k+1) quorums in a k‐arbiter. Consequently, constructing k‐arbiters is difficult. In this paper, we propose a simple scheme to construct k‐arbiters for any integer k. The constructed k‐arbiters, named binomial(q, k)‐arbiters, are uniform: each quorum in a k‐arbiter has the same size and each node contains the same number of quorums. Also, the constructed k‐arbiters perform better than other known k‐arbiters do on quorum size and availability.

Distributed algorithms over communicating membrane systems

This paper presents fundamental distributed algorithms over membrane systems with antiport carriers. We describe distributed algorithms for collecting and dispersing information, leader election in these systems, and the mutual exclusion problem. Finally, we consider membrane systems producing correct results despite some failures at some of the components or the communication links. We show that membrane systems with antiport carriers provide an appropriate model for distributed computing, particularly for message-passing algorithms interpreted here as membrane transport in both directions, namely when two chemicals behave as input and output messages and pass the membranes in both directions using antiport carriers.

A survey of permission-based distributed mutual exclusion algorithms

The problem of mutual exclusion in distributed systems has attracted considerable attention over the last two decades. The mutual exclusion problem requires that, at a time, only one of the contending processes be allowed to enter its critical section (CS). A number of solutions have been provided to the mutual exclusion problem in distributed systems. Different algorithms have used different techniques to achieve mutual exclusion and have different performances. Depending on the technique used, these algorithms have been classified as token-based and permission-based algorithms. In this paper, we present a survey of various permission-based distributed mutual exclusion (PBDME) algorithms and their comparative performance.

On distributed dynamic channel allocation in mobile cellular networks

Distributed dynamic channel allocation (DDCA) is a fundamental resource management problem in mobile cellular networks. It has a flavor of distributed mutual exclusion but is not exactly a mutual exclusion problem. We establish the exact relationship between the two problems. Specifically, we introduce the problem of relaxed mutual exclusion to model one important aspect of the DDCA problem. We develop a general algorithm that guarantees relaxed mutual exclusion for a single resource and prove necessary and sufficient conditions for the information structure. Considering distributed dynamic channel allocation as a special case of relaxed mutual exclusion, we apply and extend the algorithm to further address the issues that arise in distributed channel allocation such as deadlock resolution, dealing with multiple channels, design of efficient information structures, and channel selection strategies. Based on these results, we propose an example distributed channel allocation scheme using one of the information structures proposed. Analysis and simulation results are provided and show that the results of this research can be used to design more efficient distributed channel allocation algorithms.

Space and Time Efficient Self-Stabilizing ℓ-Exclusion in Tree Networks

We propose an efficient self-stabilizing ℓ-exclusion algorithm in rooted tree networks running under an unfair distributed daemon. The ℓ-exclusion problem is a generalization of the mutual exclusion problem—ℓ (ℓ⩾1) processors, instead of 1, are permitted to use a shared resource. The algorithm is semi-uniform and its space requirement is (ℓ+3)Δr states (or ⌈log((ℓ+3)Δr)⌉ bits) for the root r, 4(Δp−1) states (or ⌈2 log(Δp−1)⌉ bits) for an internal processor p, and 3 states (or 2 bits) for a leaf processor, where Δp is the degree of processor p. This is the first ℓ-exclusion algorithm on trees with the property that the space requirement is independent of the size of the network for any processor, and is independent of ℓ for all processors except the root. The stabilization time of the algorithm is only O(ℓ+h) rounds, where h is the height of the tree.

Analysis of Some Lockout Avoidance Algorithms for the k-Exclusion Problem

We analyze two algorithms for the k-exclusion problem on the asynchronous multi-writer/reader shared memory model and show their correctness. The first algorithm is a natural extension of the n-process algorithm by Peterson for the mutual exclusion algorithm to the k-exclusion problem, and the second algorithm is a combination of the first algorithm and the tournament algorithm by Peterson and Fischer for the mutual exclusion problem. These two algorithms satisfy k-exclusion, and can tolerate up to k-1 process failures of the stopping type. The running times by the first algorithm and by the second algorithm are bounded by (n-k)c+O(n(n-k)2)l and (n/k)kc+O((n/k)k+1k)l, respectively, even if there exist at most k-1 process failures of the stopping type, where n is the number of processes, l is an upper bound on the time between successive two atomic steps for any faultless process, and c is an upper bound on the time that any user spends in the critical region.

A Run-time System for SCOOP.

Over a period of a decade Bertrand Meyer has promoted SCOOP ‐ a concurrency mechanism designed especially for Eiffel ‐ but no implementation has been made widely available. In this paper we describe our initial implementation of SCOOP using the GNU Eiffel compiler. We focus on the run-time system, showing how SCOOP’s synchronization mechanisms depend on the solution of a dynamic mutual exclusion problem; we give a solution using a thread and lock manager. We present a number of benchmarks, and discuss which features remain to be completed.