The Weak Mutual Exclusion problem

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.

In distributed systems,cooperating process essh are both local and remoter sources. Chance is very high that multiple processes makesimultaneous requests to the same resource. If the resourcerequires mutually exclusive access (critical section - CS), then some regulation is needed to access it for ensuring synchronizedaccess of the resources thatonly one process could use the resource at a given time. This is the distributed mutual exclusion problem. The problem of coordinating the execution of critical sections by eachprocessissolved by providing mutually exclusive access to the CS. Mutual exclusion ensures that concurrent processes make a serialized access to shared resources.Quorum-based algorithms offer the advantage of protocol symmetry, spreading effort and responsibility uniformly across the distributed systems. In thispaper, we have proposed a permission baseddistributedmutual exclusion algorithmwhichis an improvement of Maekawa’s algorithm. The number of messages required by the improvisedalgorithmis in the range 3Mto 5Mper critical section invocation whereMis the number of intersection nodes1 in the system. A reduction in number of message by restricting the communication of anynodewith the intersection nodes of the quorums, withoutany modification of the basic structure of the algorithm.

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.

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.

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.

A Simulation Study on Distributed Mutual Exclusion

A mutual exclusion algorithm with optimally bounded bypasses

The group mutual exclusion problem is a generalization of mutual exclusion problem such that a set of processes in the same group can enter critical section simultaneously. In this paper, we propose a distributed algorithm for the group mutual exclusion problem in asynchronous message passing distributed systems. Our algorithm is based on tokens, and a process that obtains a token can enter critical section. For reducing message complexity, it uses coterie as a communication structure when a process sends a request messages. Informally, coterie is a set of quorums, each of which is a subset of the process set, and any two quorums share at least one process. The message complexity of our algorithm is O(|Q|) in the worst case, where |Q| is a quorum size that the algorithm adopts. Performance of the proposed algorithm is presented by analysis and discrete event simulation. Especially, the proposed algorithm achieves high concurrency, which is a performance measure for the number of processes that can be in critical section simultaneously.

In Cloud Computing, Service Level Agreement (SLA) is a contract that defines a level and a type of QoS between a cloud provider and a client. Since applications in a Cloud share resources, we propose two tree-based distributed mutual exclusion algorithms that support the SLA concept. The first one is a modified version of the priority-based Kanrar-Chaki algorithm while the second one is a novel algorithm, based on Raymond algorithm, where a deadline is associated with every request. In both cases, our aim is to improve Critical Section execution rate and to reduce the number of SLA violations, which, for the first algorithm represents the number of priority inversions (i.e. a higher priority request is satisfied after a lower one) and for the second one, the number of requests whose deadline is not respected. Performance evaluation results show that our solutions significantly reduce SLA violations avoiding message overhead.

Energy consumption is a significant factor in wireless networks with battery-powered nodes and transceivers as a dominant energy consumer .Also mutual exclusion is a fundamental problem in distributed systems.“Mutual exclusion” allows only one process at a time to access the shared resource and the others have to be locked and wait for their turns.. Retaining mutual exclusion, is proposed as a solution to guarantee the correctness of read/written information from/in the shared resource or critical sections (CS).Wireless Network is an unstable network formed dynamically by a connection of wireless mobile nodes without the use of an existing network substructure. Since energy consumption during communication is a major depletion parameter the number of communication must be reduced as much as possible to achieve extended battery life. Since battery technology does not grow as rapidly as CPU or memory does so there is a strong need for the presence of protocols which are as energy efficient as effective.In this paper we present a new fully distributed token–based mutual-exclusion algorithm for clustered Mobile ad-hoc network with message count reduction purpose which eventuates to power optimization. Therefore we use Raymond's algorithm (which is well-known in stepping down message complexity) within the clusters and perpetual Mobility of token (that is so efficient in high load network such as Manet's) between the clusters.

The growth of complex software, communication interfaces and the presence of low-cost processors are key factors for designing distributed applications. Distributed computation allows processes to run concurrently, share resources and work independent of one another. Resource sharing is one of the main advantages of distributed computing. Distributed computations that involve sharing of resources require that only one process is allowed to enter critical section (CS) at a time. Therefore, the mutual exclusion issue is to make sure that no more than one process is allowed to access shared resource at a time. Existing literature consists of different algorithms with varied performance levels to achieve mutual exclusion. These algorithms have been classified as token-based and permission-based. In the paper, we present a quorum-based mutual exclusion algorithm under permission-based category. Our algorithm is message efficient and suitable for mobile ad hoc networks (MANETs). We represent the model of the proposed algorithm along with its assumptions and discuss an application of MANET in which quorum-based mutual exclusion algorithm would be applied.

In a distributed system mutual exclusion is often used to maintain consistency when restricted operations are performed. Mechanisms guaranteeing mutual exclusions should be both resilient and efficient. Resiliency implies high resource availability in the face of failures, while efficiency implies low overhead incurred by performing restricted operations. In this paper, we propose and study a general paradigm, called multilevel voting, which provides a general framework to assist in the design of resilient and efficient mutual exclusion mechanisms. The proposed method uses multiple level quorum consensus. Unlike another method based on the use of multiple quorum consensus, the proposed model only contains one type of integrity constraints. This has the benefit of being conceptually simple and easy to reason about. The strong resemblance with the traditional quorum consensus makes it easy for the proposed paradigm to embed any technique based on traditional quorum schemes. We show that the proposed model represents the exact class of coteries. This means that not only does it have all the power of coteries, but also all schemes under the model are correct. Thus, should the need arise, we can interchange two schemes freely without using any extra mechanisms to ensure correctness. We study a number of issues that have impact on performance such as the degree of a multilevel scheme and the order of a coterie. We explain how the model can be extended also to model the schemes for the synchronization of read and write of replicated data. We provide algorithms for the design of multilevel schemes in the context of mutual exclusion and that of read and write of replicated data.

Distributed algorithms for multiple entries to a critical section with priority

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.

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.