Group Mutual Exclusion Problem Research Articles

A Distributed Algorithm for Computing Groups in IoT Systems

The distributed publication and subscription for the Internet of Things is a model of communication between devices that is simple and powerful. In comparison with other variant problems of ME, the problem considered here is a group mutual exclusion problem. The specificity of an IoT system is that a process can be in more than one group at the same time which is not the case of the algorithms mentioned in the literature where a process request one group in advance for each request. In this paper, we define formally the notion of group. Furthermore, we propose a distributed algorithm for automatic group generation and we will show that this problem is maximal cliques’ problem. This leads us to a new kind of distributed Maximal cliques algorithm to compute the groups suitable for IoT systems. As an application, we propose an IoT-based intersection traffic light management system for vehicles.

Group Mutual Exclusion by Fetch-and-increment

The group mutual exclusion (GME) problem (also called the room synchronization problem) arises in various practical applications that require concurrent data sharing. Group mutual exclusion aims to achieve exclusive access to a shared resource (a shared room) while facilitating concurrency among non-conflicting requests. The problem is that threads with distinct interests are not allowed to access the shared resource concurrently, but multiple threads with same interest can. In Blelloch et al. (2003), the authors presented a simple solution to the room synchronization problem using fetch8add ( F 8 A ) and test-and-set ( T 8 S ) atomic operations. This algorithm has O ( m ) remote memory references (RMRs) in the cache coherent (CC) model, where m is the number of forums. In Bhatt and Huang (2010), an open problem was posed: “ Is it possible to design a GME algorithm with constant RMR for the CC model using fetch8add instructions? ” This question is partially answered in this article by presenting a group mutual exclusion algorithm using fetch-and-increment instructions. The algorithm is simple and scalable.

Internet of agents framework for connected vehicles: A case study on distributed traffic control system

This study focuses on the distributed traffic control system by inspiration of advanced connected vehicle technology. In this regard, we introduce an Internet of Agents (IoA) framework for connected vehicles where agents make their own decisions to improve the effectiveness of the system by connectivity and automatic negotiation with other agents. Specifically, each of the connected vehicles can be regarded as an agent which is able to communicate and collaborate with others based on Vehicle-to-Vehicle (V2V) communication technologies. A case study on distributed traffic control system without traffic signal is presented in this paper. In particular, we consider traffic control at intersection problem as a group mutual exclusion problem where only connected vehicles in non-conflict relationship are able to enter the core of intersection simultaneously. Therefore, we extend the Ricart–Agrawala based-logical clock algorithm to deal with this problem. Various parameters (e.g., number of message exchange, average waiting time, total number of vehicle passing) have been measured to evaluate our approach. The simulated results show that our approach outperforms compared with existing traffic systems and previous works.

Group mutual exclusion in linear time and space

We present two algorithms for the Group Mutual Exclusion (GME) Problem that satisfy the properties of Mutual Exclusion, Starvation Freedom, Bounded Exit, Concurrent Entry and First Come First Served. Both our algorithms use only simple read and write instructions, have O(N) Shared Space complexity and O(N) Remote Memory Reference (RMR) complexity in the Cache Coherency (CC) model. Our first algorithm is developed by generalizing the well-known Lamport's Bakery Algorithm for the classical mutual exclusion problem, while preserving its simplicity and elegance. However, it uses unbounded shared registers. Our second algorithm uses only bounded registers and is developed by generalizing Taubenfeld's Black and White Bakery Algorithm to solve the classical mutual exclusion problem using only bounded shared registers. We show that contrary to common perception our algorithms are the first to achieve these properties with this combination of complexities.

A Token-Based Solution to Group Local Mutual Exclusion Problem In Mobile Ad Hoc Networks

The article presents a generalization of the group mutual exclusion (GME) problem, called group local mutual exclusion (GLME), henceforth. In GLME, the activities of neighboring nodes need to be synchronized; however, no such synchronization is required between non-neighbors. The neighborhood is defined based on the location of the shared resources. A token-based solution to the GLME problem has also been proposed. The solution satisfies the correctness criteria for group mutual exclusion, i.e., safety, starvation freedom, and concurrent occupancy. The illustration includes simulation extensive results to estimate message overhead, latency, concurrency, and session switch complexity. The simulation results prove that the proposed algorithm demonstrates better performance when compared with the closest work in the literature. The token loss problem has also been handled. To the best of our knowledge, the algorithm presented in the paper is the first token-based algorithm to solve the GLME problem in MANETs.

A QoS Aware Self Adaptive General Scheme to Solve GME Problem

The Group mutual exclusion problem (GME) is a resource allocation problem which allows concurrency along with mutual exclusion. The concept of GME can be applied to various fields having varying quality of service (QoS) requirements. The present paper presents a self adaptive general scheme to solve GME problem using token-based approach. The striking feature of the scheme is that it considers QoS requirements, checks the QoS requirements time to time and adapts its parameters if there are deviations from the expected behavior. The dynamic analysis of the scheme has also been presented in the present exposition.

A Hybrid Algorithm to Solve Group Mutual Exclusion Problem in Message passing Distributed Systems

In the present paper, we propose a hierarchical algorithm to solve the group mutual exclusion (GME) problem in clusterbased systems. We consider a two-level hierarchy in which the nodes are divided in to clusters and a node in each cluster is designated as coordinator which is essentially the cluster head. The number of global messages per critical section entry in our algorithm depends upon the number of clusters in the system unlike most of the existing GME algorithms where it depends upon the total number of nodes in the system. Performance of the algorithm directly depends on the coherent behavior of nodes inside clusters. The results have been substantiated with extensive simulation. A fault tolerant extension of the algorithm has also been proposed in the present exposition.

A Weight-Throwing Clustering Group Mutual Exclusion Algorithm for Mobile Ad Hoc Networks

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

An Improved Quorum-Based Algorithm for Extended GME Problem in Distributed Systems

The extended GME (group mutual exclusion) problem is a natural extension of the GME problem. In extended GME problem, processes are allowed to request more than one resource at a time, in order that the processes that can proceed by having access to any one of the requested resource can be allowed to do so. Manabe-Park suggested a quorum based solution for the extended GME problem. However, the worst case message complexity of the Manabe-Park algorithm is 9q, where q is the quorum size. Further, the synchronization delay of Manabe-Park algorithm is 4T, where T is the maximum message propagation delay. In the present paper, we propose a quorum based solution for the extended GME problem. The worst case message complexity of our algorithm is 7q and synchronization delay is 3T. Moreover, in the best case, the synchronization delay and message complexity come down to 2T and 3q respectively.

A Token-Based Distributed Group Mutual Exclusion Algorithm with Quorums

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.

A Quorum-Based Group Mutual Exclusion Algorithm for a Distributed System with Dynamic Group Set

The group mutual exclusion problem extends the traditional mutual exclusion problem by associating a type (or a group) 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. We present a distributed algorithm for solving the group mutual exclusion problem based on the notion of surrogate-quorum. 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) and a low (amortized) bit-message complexity of O(bqr), where q is the maximum size of a quorum, b is the maximum number of processes from which a node can receive critical section requests, and r is the maximum size of a request while maintaining both synchronization delay and waiting time at two message hops. As opposed to some existing quorum-based algorithms, our algorithm can adapt without performance penalties to dynamic changes in the set of groups. Our simulation results indicate that our algorithm outperforms the existing quorum-based algorithms for group mutual exclusion by as much as 45 percent in some cases. We also discuss how our algorithm can be extended to satisfy certain desirable properties such as concurrent entry and unnecessary blocking freedom.

A Token-Based Fair Algorithm for Group Mutual Exclusion in Distributed Systems

The group mutual exclusion (GME) problem is a generalization of the mutual exclusion problem. In group mutual exclusion, a process requests a session before entering its critical section (CS). Processes requesting the same session are allowed to be in their CS simultaneously, however, processes requesting different sessions must execute their CS in mutually exclusive way. The paper presents a token-based distributed algorithm for the GME problem in asynchronous message passing systems. The algorithm uses the concept of dynamic request sets. The algorithm does not use any message to be exchanged in the best case and uses n+1 messages in the worst case, where n is the number of processes in the system. The maximum concurrency of the algorithm is n and synchronization delay under heavy load (worst case) is 2T, where T is the maximum message propagation delay. The algorithm uses first come first serve approach in selecting the next session type and satisfies the concurrent occupancy property. The static performance analysis and correctness proof is also included in the present exposition.

A priority-based distributed group mutual exclusion algorithm when group access is non-uniform

In the group mutual exclusion problem, each critical section has a type or a group associated with it. Processes requesting critical sections belonging to the same group (that is, of the same type) may execute their critical sections concurrently. However, processes requesting critical sections belonging to different groups (that is, of different types) must execute their critical sections in a mutually exclusive manner. Most algorithms for solving the group mutual exclusion problem that have been proposed so far in the literature treat all groups equally. This is quite acceptable if a process, at the time of making a request for critical section, selects a group for the critical section uniformly. However, if some groups are more likely to be selected than others, then better performance can be achieved by treating different groups in a different manner. In this paper, we propose an efficient algorithm for solving the group mutual exclusion problem when group selection probabilities are non-uniformly distributed. Our algorithm has a message complexity of 2 n - 1 per request for critical section, where n is the number of processes in the system. It has low synchronization delay of one message hop and low waiting time of two message hops. 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-size complexity of our algorithm is O ( 1 ) . Our experimental results indicate that our algorithm outperforms the existing algorithms, whose complexity measures are comparable to that of ours, by as much as 50% in some cases.

A HIGHLY CONCURRENT GROUP MUTUAL l-EXCLUSION 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.

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.)

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.

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 local-spin group mutual exclusion algorithm

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.