A mutual exclusion algorithm with optimally bounded bypasses

Mutual exclusion is one of the most commonly used techniques to handle contention in concurrent systems. Traditionally, mutual exclusion algorithms have been designed under the assumption that a process does not fail while acquiring/releasing a lock or while executing its critical section. However, failures do occur in real life, potentially leaving the lock in an inconsistent state. This gives rise to the problem of recoverable mutual exclusion (RME) , which involves designing a mutual exclusion (ME) algorithm that can tolerate failures while maintaining required safety and liveness properties. In this work, we present a framework that transforms any algorithm that solves the RME problem into an algorithm that can also simultaneously adapt to (i) the number of processes concurrently competing for the lock, as well as (ii) the number of unresolved failures in the system, while maintaining the correctness properties and performance characteristics of the underlying RME algorithm. Additionally, the algorithm constructed as a result of this transformation adds certain desirable properties such as bounded recovery and fairness. One of the important performance measures of any ME algorithm, including an RME algorithm, is the number of remote memory references (RMRs) made by a process—to acquire and release a lock, as well as to recover the lock structure after a failure. Let R(n) denote the RMR complexity of a critical section request in the underlying RME algorithm, where n denotes the number of processes in the system. Then, our framework yields an RME algorithm for which the RMR complexity of a critical section request is given by \(\mathcal {O}(\min \lbrace \ddot{c},\sqrt {F+1},\ R(n) \rbrace)\) , where \(\ddot{c}\) denotes the point contention of the request and F denotes the failure-density of the request. We further extend our framework by presenting a novel memory reclamation algorithm to bound the space complexity of the RME algorithm. Our memory reclamation algorithm maintains the correctness, performance, and fairness properties of our transformation. Our approach is general enough that it may also be used to bound the space complexity of other RME algorithms. In addition to read and write instructions, our algorithm uses compare-and-swap ( CAS ) and fetch-and-store ( FAS ) hardware instructions, both of which are commonly available in most modern processors.

In this paper, we propose a GUI-based learning system for the problem of mutual exclusion in multithreaded programming (MTP) such as race conditions, deadlock and starvation. Threads are group of cooperating program executions with shared memory. A thread in execution is switched one after another, and thread executions are in concurrent. Because mutual exclusion is necessary for avoiding race conditions, understanding the problem of mutual exclusion and its solution is important for students. Deadlock and starvation are bugs of mutual exclusion algorithm such that threads are blocked forever, and threads cannot make progress, respectively. Finding such bugs is difficult because we must check every execution scheduling of threads. To this end, we have been developing a system for learning correct mutual exclusion algorithm in MTP. Our system is designed for university students studying computer science. Proposed system uses a model checking system to detect such bugs by analysis of multithreaded programs written in the MIPS R2000 assembly language. We describe the outline how learners use our system to understand the problem of mutual exclusion in MTP.

A mutual exclusion (ME) algorithm consists of a trying protocol (TP)and exit protocol (EP)that surround a critical section (CS)and satisfy the following properties: mutual exclusion : at most one process is allowed to use the CS at a given time; lockout freedom : any process that enters the TP eventually enters the CS; and bounded exit : a process can complete the EP in a bounded number of its own steps. A First-Come-First-Served (FCFS) ME algorithm [1] additionally requires processes to enter the CS in roughly the order in which they start the TP. Once a process has started executing the TP of a ME algorithm, it has committed itself to entering the CS, since the correctness of the algorithm may depend on every process properly completing its TP and EP.

Mutual exclusion is one of the fundamental problems in mobile ad hoc networks (MANETs). The solutions to the mutual exclusion problem ensure exclusive access to a shared resource(s). In MANETs, one of the variants of mutual exclusion problem is local mutual exclusion (LME) problem. In LME problem, the non-neighboring nodes may enter CS simultaneously. Whereas, the group local mutual exclusion (GLME) problem in MANETs is the generalization of LME problem, where, unlike LME problem, the processes requesting same group (resource) may be in a critical section (CS) simultaneously. In the presented exposition, an extension of GLME problem, named h-group local mutual exclusion (h-GLME), has been proposed. The h-GLME problem, where the number of active groups can be h (h ≥ 1) and the processes requesting any of h groups may be in their respective CS simultaneously. It is applicable to MANETs. To the best of our knowledge, h-GLME is the first wireless extension of the GLME problem.

First-Come-First-Served (FCFS) mutual exclusion (ME) is the problem of ensuring that processes attempting to concurrently access a shared resource do so one by one, in a fair order. In this paper, we close the complexity gap between FCFS ME and ME in the asynchronous shared memory model where processes communicate using atomic reads and writes only, and do not fail. Our main result is the first known FCFS ME algorithm that makes O(log N) remote memory references (RMRs) per passage and uses only atomic reads and writes. Our algorithm is also adaptive to point contention. More precisely, the number of RMRs a process makes per passage in our algorithm is Θ(min(k, log N)), where k is the point contention. Our algorithm matches known RMR complexity lower bounds for the class of ME algorithms that use reads and writes only, and beats the RMR complexity of prior algorithms in this class that have the FCFS property.

The asynchronous group mutual exclusion (GME) problem [5] is a generalization of the (ordinary) mutual exclusion problem. Each process requests a forum. When a process is in the critical section (CS), we say its forum is held. The GME problem (i) allows at most one forum to be held at any time and, (ii) when a forum is held, encourages any number of processes requesting that forum to participate in that forum, that is, to be in the CS simultaneously. An extension of this problem, called the group mutual l-exclusion with multiple forum requests (GMLE-M) problem [8], allows each process to request multiple forums and up to l forums to be held simultaneously. In this paper, we give a simple GMLE-M algorithm that facilitates a highly concurrent participation of processes in forums. The algorithm uses a new technique, called automatic joining, that enables processes to enter the CS directly when their forums are being held. This technique can be used in other extensions of the GME problem also, to increase concurrency.

Hypercube have been commercially available in the past few years to their high degree of connectivity, symmetry, and low degree of diameter. In this paper, we analyse the performance in number of messages on d-dimensional hypercube, for two groups of distributed algorithms for mutual exclusion, a permission-based mutual exclusion group, and a token-based mutual exclusion group.In the permission-based mutual exclusion algorithm, a node enters in the critical section only after receiving permission from all others nodes, this algorithm requires d2 d messages.In the token-based mutual exclusion algorithm, a node is allowed to access its critical section if and only if it holds the token. In this algorithm, there is a node, called root, which knows the last node to get the token among the current requesting nodes. When a node wants to enter critical section, it sends request message to the root, which in turn informs the last node that new node will get the token next, and updates its last node. As result, the requesting nodes form a distributed queue, each of which records only the element next to it, this algorithm requires 2d messages in the worst case.

Clustering in WSN proves to be phenomenal in maximizing network life. This paper comes up with a new clustering scheme with a mutual exclusion feature. A number of clustering protocols are employed in WSN, but none of the protocol has ensured or focused on mutual exclusion of a cluster head role over range of communication. The objective of this paper is to propose a new distributive clustering protocol which will also work like mutual exclusion algorithms. This mutual exclusive distributive protocol forms the cluster of sensors, and selects a cluster head which possesses the mutual exclusion property. Keywords: Distributive clustering, mutual exclusion, WSN clustering.

The authors present a dynamic token-based mutual exclusion algorithm for distributed systems. In the algorithm, a site invoking mutual exclusion sends token request messages to a set of sites possibly holding the token as opposed to all the sites as in the algorithm proposed by I. Suzuki and T. Kasami (1985). A request set is used to record the identifiers of such a set of sites in the system. The algorithm is dynamic because the request set is dynamically changed as the algorithm is executed. As the size of the request set is reduced, the number of the messages exchanged per critical section (CS) execution is reduced. Compared with Suzuki and Kasami's algorithm, the proposed algorithm can reduce the number of the messages exchanged by 40% when the traffic is light. Finally, the authors discuss relationship between the token-based and non-token-based mutual exclusion algorithms. This relationship motivated the authors to design such a dynamic token-based algorithm. >

We present tradeoffs between RMR complexity and memory word size for recoverable mutual exclusion (RME) algorithms using arbitrary synchronization primitives. Assuming that each memory location stores w bits, we show that n-process mutual exclusion has an RMR complexity of at least Ω (min{logw n, log n/log log n}) on the DSM and the CC model. For w = (log n)Ω(1), our lower bound asymptotically matches an upper bound by Katzan and Morrison [19], whose RME mutual exclusion algorithm employs w-bit fetch-and-add operations. Our lower bound is the first one that does not restrict the type of atomic operations that can be executed on a memory location.

A Simulation Study on Distributed Mutual Exclusion

This paper presents a new solution to the group mutual exclusion problem recently posed by Joung. In this problem, processes repeatedly request access to various "sessions." It is required that distinct processes are not in different sessions concurrently, that multiple processes may be in the same session concurrently, and that each process that tries to enter a session is eventually able to do so. This problem is a generalization of the mutual exclusion and readers-writers problems. Our algorithm and its correctness proof are substantially simpler than Joung's. This simplicity is achieved by building upon known solutions to the more specific mutual exclusion problem. Our algorithm also has various advantages over Joung's, depending on the choice of mutual exclusion algorithm used. These advantages include admitting a process to its session in constant time in the absence of contention, spinning locally in Cache Coherent (CC) and Nonuniform Memory Access (NUMA) systems, and improvements in the complexity measures proposed by Joung.

While symmetric mutual exclusion algorithms are easy to implement, message complexity per critical section (CS) access to such approaches in a distributed system is typically high. There exist works that handle this issue but to a limited extent. In this paper, we propose a new symmetric algorithm for mutual exclusion. The proposed approach is essentially a prioritized version of the well-known Ricart–Agrawala algorithm for mutual exclusion in distributed systems. The solution proposed uses one or more priority levels, such that different participating processes are placed at different priority levels depending on the initial priority of the processes. The proposed algorithm maintains safety, liveness, and fairness properties toward implementation in a distributed system.

The paper deals with a generic solution of the Mutual Exclusion Problem using semaphores only. We use in the solution weakly fair binary semaphores and (not necessarily fair) semaphores with initial value k. All semaphores are simple in that the P and V operations on them are paired in the natural way avoiding split semaphores. No auxiliary shared variables are used. We define a general form of the mutual exclusion problem. We claim: (1) All mutual exclusion problems can be solved using only simple semaphores. (2) All mutual exclusion problems can be solved fairly (with bounded waiting) using simple semaphores (weakly fair binary and initially–k; semaphores). We give some bounds on how many semaphores are needed for standard problems. The solutions given may be inefficient: a mutual exclusion problem which can be solved in linear time and space with shared variables may require exponentially many semaphores.

A mobile ad hoc network can be defined as a network that is spontaneously deployed and is independent of any static network. The network consists of mobiles nodes with wireless interfaces and has arbitrary dynamic topology. The network suffers from frequent link formation and disruption due to the mobility of the nodes. A clustering method is used for obtaining a hierarchical organization for the ad hoc network. In this paper we present a clustering token-based algorithm for group mutual exclusion in ad hoc mobile networks. The proposed algorithm is adapted from the RL algorithm in [1] and utilizes the concept of weight throwing in [27] to solve the group mutual exclusion problem in mobile ad hoc network. The proposed algorithm is sensitive to link forming and link forming. The algorithm ensures the mutual exclusion, the bounded delay and the concurrent entering properties