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 these combination of complexities.Comment: A total of 21 pages including 5 figures and 3 appendices. The bounded shared registers algorithm in the old version has a subtle error (that has no easy fix) necessitating replacement. A correct, but fundamentally different, bounded shared registers algorithm, which has the same properties claimed in the old version is presented in this new version. Also, this version has an additional autho

Brief Announcement: Fast and Scalable Group Mutual Exclusion

The group mutual exclusion (GME) problem is a generalization of the classical mutual exclusion problem in which every critical section is associated with a type or session. Critical sections belonging to the same session can execute concurrently, whereas critical sections belonging to different sessions must be executed serially. The well-known read-write mutual exclusion problem is a special case of the group mutual exclusion problem. In a shared memory system, locks based on traditional mutual exclusion or its variants are commonly used to manage contention among processes. In concurrent algorithms based on fine-grained synchronization, a single lock is used to protect access to a small number of shared objects (e.g., a lock for every tree node) so as to minimize contention window. Evidently, a large number of shared objects in the system would translate into a large number of locks. Also, when fine-grained synchronization is used, most lock accesses are expected to be uncontended in practice. Most existing algorithms for the solving the GME problem have high space-complexity per lock. Further, all algorithms except for one have high step-complexity in the uncontented case. This makes them unsuitable for use in concurrent algorithms based on fine-grained synchronization. In this work, we present a novel GME algorithm for an asynchronous shared-memory system that has O(1) space-complexity per GME lock when the system contains a large number of GME locks as well as O(1) step-complexity when the system contains no conflicting requests

Group Mutual Exclusion - Role Processes

This paper presents an extension to group mutual exclusion (GME) where processes join a group with a role (shared, exclusive) in each stage. The properties that must guarantee a solution to GME are: mutual exclusion, bounded delay, progress and concurrency. For this new situation, a new property role mutual exclusion is introduced. A solution is proposed in a network with no share memory whose members commu- nicate by messages. The proposed algorithm is composed of two players: groups and processes, where groups are passive players and processes are active players. For the coordination access to the resource, each group has been assigned a quorum.Presentado en el XI Workshop Procesamiento Distribuido y Paralelo (WPDP)Red de Universidades con Carreras en Informática (RedUNCI

Group Mutual Exclusion Based on Priorities

We propose a distributed solution for the group mutual exclusion problem based on priorities, in a network with no share memory whose members only communicate by messages. The proposed algorithm is composed by two players: groups and processes, groups are passive players while processes are active players. For the coordination access to the resource, each group has assigned a quorum. The groups have associated a base priority in each stage, meanwhile the processes have the same level priority. An important feature is that processes have associated a time to participate in the group in each stage. The message complexity obtain, in the best case, where the group does not yield the permission, is 3l + 3(q - 1) messages, where l denotes the processes linked and q denotes the quorum size. The maximum concurrency of the algorithm is n, which implies that all processes have linked to the same group.Facultad de Informátic

Constant RMR Group Mutual Exclusion for Arbitrarily Many Processes and Sessions

Group mutual exclusion (GME), introduced by Joung in 1998, is a natural synchronization problem that generalizes the classical mutual exclusion and readers and writers problems. In GME a process requests a session before entering its critical section; processes are allowed to be in their critical sections simultaneously provided they have requested the same session. We present a GME algorithm that (1) is the first to achieve a constant Remote Memory Reference (RMR) complexity for both cache coherent and distributed shared memory machines; and (2) is the first that can be accessed by arbitrarily many dynamically allocated processes and with arbitrarily many session names. Neither of the existing GME algorithms satisfies either of these two important properties. In addition, our algorithm has constant space complexity per process and satisfies the two strong fairness properties, first-come-first-served and first-in-first-enabled. Our algorithm uses an atomic instruction set supported by most modern processor architectures, namely: read, write, fetch-and-store and compare-and-swap

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 �rst 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 �rst to achieve these properties with this combination of complexities.ECU Open Access Publishing Support Fun

Group Mutual Exclusion in Linear Time and Space

The Group Mutual Exclusion (GME) problem, introduced by Joung, is a natural extension of the classical Mutual Exclusion problem. In the classical Mutual Exclusion problem, two or more processes are not simultaneously allowed to be in their CRITICAL SECTION, a piece of code where a common resource is accessed. In the GME problem, it is necessary to impose mutual exclusion on different groups in processes in accessing a resource, while allowing processes of the same group to share the resource. The Group Mutual Exclusion problem arises in several applications and is the focus of this thesis. We present an algorithm for the GME problem that satisfies the properties of Mutual Exclusion, Starvation Freedom, Bounded Exit, Concurrent Entry and First-Come-First Served. Our algorithm has [theta] (N) shared space complexity and [omicron] (N)RMR (Remote Memory Reference) complexity. Our algorithm is developed by generalizing the well-known Lamport's Bakery Algorithm for the classical mutual exclusion problem, while preserving its simplicity and elegance. Just like Lamport's Bakery Algorithm, our algorithm has the disadvantage that the token numbers can grow in an unbunded manner. When all shared variables are required to be of bounded size, Hadzilacos presented an algorithm, whose shared space complexity is [theta] (N²) and whose RMR complexity is claimed to be [omicron] (N). Hadzilacos posed as an open problem, the development of a linear time and space algorithm that uses only bounded shared variables and only simple read and write instructions. As a solution to the open problem, Jayanti et al. presented a space efficient adaptation of the above algorithm that uses only [theta] (N) shared space and inherited the claim that the RMR complexity is [omicron] (N) We show that both of these algorithms are of RMR complexity [omega] (N²) and thus demonstrate that both claims are erroneous. So, the open problem posed by Hadzilacos is still open.Open Access FundingM.S