A Study of Token Based Algorithms for Distributed Mutual Exclusion

Abhishek Swaroop* Awadhesh Kumar Singh

Department of Computer Science & Engg Department of Computer Engineering
G. P. M. College of Engineering National Institute of Technology
New Delhi 110036 India Kurukshetra 136119 India
[email protected] [email protected]

Abstract
The selection of a ‘good’ mutual exclusion algorithm, for the design of distributed systems, is of great importance. A number of mutual exclusion
algorithms, with different techniques and varying performance characteristics, are available in the literature. These algorithms can be broadly
classified into token based algorithms and non-token based algorithms. A number of survey papers for non-token based mutual exclusion algorithms
exist. Although, some of them include discussion on token based mutual exclusion algorithms too, however, none of them include any discussion on
the newer variants of classic mutual exclusion, like k-mutual exclusion and group mutual exclusion. The paper presents an exhaustive survey of the
token based mutual exclusion algorithms. The variants of mutual exclusion problem, namely k-mutual exclusion and group mutual exclusion, have
also been covered.
Keywords: Distributed mutual exclusion; Token; Algorithm; k-mutual exclusion; Group mutual exclusion

1. Introduction Usually, a shared resource is required to be

A distributed system consists of geographically accessed by only one process at a time. Such resource
dispersed independent computers, connected via a must be accessed inside a critical section (CS) in a
message passing network, collaborating on an way that at any particular time only one of the
application. Due to lack of common memory and contending processes is allowed to be inside of its
global clock, handling such system is harder than any critical section. This is called mutual exclusion. The
other system. The major advantage of distributed mutual exclusion is very crucial for the design of
systems is resource sharing. However, special care distributed systems. For example, in case of a
has to be taken, while allocating shared resources to replicated database maintaining consistency of the
processes, in order to ensure the correct functioning data is a major concern. Thus, if a node wants to
of the system. The history of resource allocation perform updates, it must ensure that no other node is
problem can be traced back to 1965 when Dijkstra involved in updating the database. Any mutual
[11] introduced the mutual exclusion problem. Since exclusion algorithm should satisfy following
then a number of variants of the resource allocation requirements.
problem have also emerged, like drinking (A) Mutual exclusion – at any point of time no two
philosopher [22], k-exclusion [26], group mutual conflicting processes must be in their critical
exclusion [56], and group k-mutual exclusion [27], to section simultaneously.
name a few. (B) Freedom from Starvation – a process should not
* Corresponding author, Mailing address 360/7A, Gali
be forced to wait indefinitely to execute CS
No. 6 Bhola Nath Nagar, Shahadra, Delhi – 110032, India
Tel: - 91- 11- 22300003 while other processes are repeatedly executing
Email: - [email protected]
CS.
(C) Deadlock Freedom – two or more processes algorithms are Gifford [7], Kumar [1], Thomas [53],
should not endlessly wait for messages that will Barbara et al. [6], Jajodia-Multcher [49]. A coterie
never arrive. [15] C , on a non empty set of nodes U , is a collection
(D) Fairness – enforces that the requests must be of non empty subsets, called quorums, of U
executed in the order these are made. satisfying following conditions.
(i) Minimality condition:
The mutual exclusion algorithms can be broadly S,T ∈ C ⇒ S ⊄ T ,T ⊄ S
classified into two categories.
(ii) intersection property: S ∩T ≠ Φ
(A) Shared memory based algorithms
∀S , T ∈ C
(B) Message passing based algorithms
A node wishing to enter CS must obtain permission
The distributed shared memory is an
from all members of some quorum in the assigned
abstraction used for sharing data between computers
coterie. Some examples of coterie based algorithms
that do not share physical memory. The mutual
are Garcia-Molina [15], Maekawa [31], Singhal [37],
exclusion algorithms, which use the shared memory
Agrawal-Abbadi [3].
approach, are namely, Anderson-Kim [17], Attiya-
In token based algorithms, a privilege message
Bortnikov [14], Lamport [29], Burns [18], Lynch-
called token is shared among various processes
Shavit [40], Styer [10], Lycklama-Hadzicolos [9] .
sharing a resource. Only the process possessing the
These algorithms access and update some common
token can enter CS. A process wishing to enter CS
variables for solving mutual exclusion problem.
and not possessing token sends its request to a set of
In message passing system, processes can
processes and waits for the token. The focus of
communicate with each other only by exchanging
present paper is the token based algorithms for
messages over a communication network. The
distributed mutual exclusion. Algorithms for k-
message passing algorithms can be further classified
mutual exclusion and group mutual exclusion have
into two categories.
also been discussed. The rest of the paper is
(A) Non-Token Based Algorithms
organized as follows. In section 2 we discuss
(B) Token Based Algorithms
performance metrics relevant for mutual exclusion
In non-token based algorithms, a process
algorithms in message passing systems. Section 3
wishing to enter CS sends its request to some or all
contains discussion of token based algorithms for
other processes in the system and waits for their
mutual exclusion. Section 4 and 5 cover k-mutual
permission. The concept of logical clocks [28] is used
exclusion and group mutual exclusion respectively.
for prioritizing requests. The non-token based
Section 6 presents concluding remarks.
algorithms can be put in to two categories voting
based algorithms and coterie based algorithms. In
2. Performance metrics
voting based algorithms, a node can enter its CS only
The following performance metrics are generally
if it has obtained permission from a number of nodes
used for measuring performance of message passing
whose total number of votes is at least majority of the
based mutual exclusion algorithms.
total votes. Some examples of voting based
(i) Response time - is the time interval a request based algorithms for mutual exclusion can be
waits for its CS execution to be over after its request classified in to following categories.
messages have been sent out. (i) Broad cast based algorithms
(ii) Synchronization delay - is the time required after (ii) Logical structure based algorithms
a site leaves CS and before the next site enters the CS (iii)Centralized token based algorithms
(iii) System throughput - is the rate at which the 3.1 Broadcast Based Algorithms
system executes requests for the CS. If In broadcast based algorithms, a site requesting to
synchronization delay is D and average CS execution enter CS sends a request message to the sites in its
time is E , then the system throughput will be request set in parallel and waits for the privilege
message. Upon receiving the privilege message, the
1
site can enter CS. In the following subsections, we
(D + E)
will discuss some broadcast based algorithms for
(iv) Message complexity - is the average number of distributed mutual exclusion.
messages exchanged by a process per CS entry.
(v) Message size - is the average number of bits 3.1.1 Suzuki-Kasmi algorithm
required to encode a message required by the Suzuki-Kasmi [16] proposed a mutual exclusion
algorithm. algorithm in which a request message is sent to all
other sites by the requesting site. The requesting site
3. Token based Algorithms for Mutual Exclusion waits for the privilege message before entering CS.
In token based algorithms, a privilege message Each site i maintains an array RN of size N , which
(token) is shared among all the processes in the stores the latest sequence number of requests made
system. A process can enter CS, only if it is in by every site, known to the site. The privilege
possession of the privilege message. A process message maintains a queue for storing pending
wishing to enter CS sends its request to a set of requests and an array LN of size N , for storing
processes called its request set [55] and waits for the sequence number of last request served for each site.
token. The token based algorithms generally use
When a site i finishes its CS, all sites j , for which
sequence numbers to distinguish between old
RN i [ j ] = LN [ j ] + 1 , are appended to the token
requests and current request made by the same
process. Token based algorithms produce less queue. The site at the head of the queue is removed

message traffic in comparison to non-token based from the queue and the privilege message is sent to

algorithms. Because of the existence of a unique that site. If the token queue is empty the site i holds

token in the system, token based algorithms are the token, until the arrival of request messages.

deadlock free. But their resiliency to failure is poor, The algorithm requires at most N

because if the process having token fails or token is messages. The synchronization delay is one way trip

lost in transit, a complex process of token communication time (T). This is an improvement

regeneration and recovery has to be started. Token over Ricart-Agarwala’s algorithm[13],which has
message complexity of 2( N − 1) and the
synchronization delay equal to two way trip requesting site waits for token up to a specified time,
communication time(2T). The draw back of the after that failure recovery algorithm is initiated. A
Suzuki-Kasmi’s algorithm is that in it sequence two phase recovery scheme has been suggested to
numbers are not bounded. To remove this drawback a recover from situations, in which the information
modified algorithm was presented by Suzuuki-Kasmi. stored at sites or token may be lost, due to some
However, in modified algorithm the number of catastrophic failure. The algorithm is able in handling

messages increases to L * N + ( N − 1) for L mutual a variety of network failures and ensures mutual
exclusion as long as there is one operational site in
exclusion invocation by a single node or
the network.
N + ( N − 1) / L messages per invocation.

Nishio et al. [50] proposed a fault tolerant

3.1.2 Heuristic approach
extension of Suzuki-Kasmi’s algorithm [16]. The
The major drawback of Suzuki-Kasmi’s algorithm
algorithm differs from Suzuki-Kasmi’s algorithm in
[16] is that a site wishing to enter CS and not
the way next site j is selected, when a site i exits possessing token has to send the request message to
from CS. The token is sent to a site j ( j ≠ i ) such that all other sites in the system. In Suzuki-Kasmi’s

the value of ( j − i ) mod N is minimum, among those algorithm request set of every site is static and its
cardinality is always N − 1 .
sites having pending requests. Nishio et al.’s
M. Singhal [36] used heuristic approach in
algorithm does not require a queue to store pending
his algorithm and showed that the number of
requests. The relationship between array of sequence
messages required per CS invocation can be reduced
numbers at site and array of sequence numbers at
by dynamically changing the request set. The
token is used to determine whether a site is having
algorithm makes use of the state information of the
pending request or not.
sites in changing the request set. A site may be in any
The additional data structures maintained by
one of the following states.
the algorithm are site − age[N ] stored at each site
R – Requesting. N– Not
and token-age stored in the token. When a site i
Requesting
suspects token loss, it executes the algorithm
E – Executing. H – Holding.
regenerate, which determines candidate value
Sequence numbers are used to differentiate between
propose _ agei for the token age and sends a token-
current and old requests. Each site maintains state
missing message to all sites j (≠ i ) . Site j checks if vector ( SV ) and sequence number vector ( SN ). The

propose − agei > site − age[ j ] , site − age[ j ] is token maintains two vectors TSV and TSN , which are
used for storing state information of the sites and
updated and ACK message is sent to i otherwise,
sequence number of the last served request for each
NACK message is sent to i . The site proposing
site respectively. The token and the request messages
highest age regenerates the token, on receiving
are used to disseminate state information among the
positive response from all other sites.
sites.
A time out mechanism is used to detect the
communication link failures or site failures. A
 Initially site 1 holds the token and algorithm depends upon the arbitration rule used in
SV1[1] = H . Site S i 1 ≤ i ≤ n thinks that sites selecting the next site to which token has to be sent.
The space requirement of singhal’s algorithm is also
S n , S n−1 ,S i +1 are not requesting the token and sites
quiet large, because array containing state
S i−1, ...S1 are requesting the token and one of these information has to be stored at each site. The token
has the token. When a site wants to enter CS, it use also contains an array to store information about the
some heuristic to guess a set of sites which are likely state of the sites.
to have the token and sends its request message only Chang et al. [55] presented another token
to those sites. The heuristic used in the algorithm is based algorithm, in which the request set of a site
“All the sites for which state vector entries are R ,are changes dynamically. The algorithm does not use
added in the request set”. When a site exits from CS, state information, therefore, the arrays for storing
it updates its state vectors and token vectors. For this state information are not required. In this algorithm
purpose the state vectors at site are compared with token maintains a FIFO queue storing waiting
the token state vector to determine, which vector has requests. Each site maintains an array of sequence
more current information about the state of sites. The numbers and a request set R . The requesting site
outdated information is replaced with more current sends request message to only those sites which are
information. An arbitration rule is used to determine, in its request set R . Initially all other sites are added
which of the many requesting sites should get the in request set of a site, except the site X , which is
token next. The fairness of the algorithm depends randomly chosen to hold the token and for which
upon the arbitration rule. Following two arbitration request set is empty. When a site exits from CS, it
rules were suggested in the paper. checks if new requests have arrived and add these
(i) Grant the token to a requesting site with lowest requests to the token queue. The site then removes
sequence no. the site at the head of the token queue and sends the
(ii) Grant the token to the requesting site nearest to token to that site. When a site gets a token, its request
the current site.. set is emptied and all sites, which are in token queue,
The simulation study shows that, under light are added to its request set. Simulation studies
load the algorithms performs better than Suzuki- performed, shows that only 0.6 N messages/CS are
kasmi algorithm as far as number of messages per CS required under light load, however under heavy load
is concerned. However under heavy load the algorithm shows same performance as Suzuki-
performance of both the algorithms is comparable. kasmi’s algorithm.
Under light load the mean delay in granting CS will
be equal to one round trip time ( 2T ). Under heavy 3.1.3 Other Algorithms
load after every T + E units of time a site will get the Mizuno et al. [32] used a data structure, called
token and execute its CS. quorum agreements [5] similar to coterie, to present a
Singhal’s algorithm uses less number of variant of Suzuki – Kasmi’s algorithm[16]. Let QA =
messages as compared to Suzuki-Kasmi algorithm
(Q, Q −1 ) be the quorum agreement used by the
under light load conditions, but the fairness of the
algorithm. Each node i has a request set Ri ( Ri ∈ Q) token is used to allow entry in CS. Each processor
dynamically updates the latest known location of the
and an acquired set Ai ( Ai ∈ Q −1 ) and an array of
token. A requesting process only sends out a request
sequence numbers RN i . The token carries an array of message to chase token along the latest known
sequence numbers of the last served request of each location of the token. A request message dynamically
site and a queue of pending requests. Initial request changes its path based on the local information of the

messages are issued by i to the nodes in Ri only. intermediate nodes. The message complexity of the

When a node j receives privilege message it sends algorithm is O(N ) .

acquired message to all nodes in its acquired set Ai . Saxena et al. [42] proposed a token based
algorithm for arbitrary network topologies using
The privilege message contains a copy of array LN
broadcast based approach. A site can be in any one of
which contains the sequence numbers of last served
the following states R – Requesting, N – Not
requests of each node. When k receives an acquired
Requesting, E – Executing, H – Holding. In this
message from j and RN [ K ]  LN [ K ] , it sends back
algorithm the token serves the requests of the sites
a request message to node j . Otherwise node k which fall on the route to its destination. Although
waits until it receives new requests. The number of the algorithm does not satisfy request in strictly FCFS
messages used by node i for one CS entry are order, however under heavy load conditions this

between (( Ri − 1) + ( Ai − 1) + 1) and enroot servicing reduces the message complexity as

well as delay considerably. Another technique used in
( Ri − 1) + 2 * ( Ai − 1) + 1) . Hence the number of
this algorithm is, using special messages know as tlps
messages required, depends upon the quorum (token location propagators). When a token leaves for
agreements. If good quorum agreements are chosen a requesting site this information is spread in the
algorithm performs nicely. Heavy load network using tlps. Under light load this technique is
synchronization delay of the algorithm is T , while quiet effective in reducing the message complexity.
light load synchronization delay is 3T due to extra However, it is very difficult to collect and
level of indirection in finding the token. However the maintain the information about the network topology
performance of the algorithm is highly dependent on of a distributed system. Now a days in distributed
the selection of the quorum agreements. systems the addition and deletion of sites is quiet
Yan et al. [59] emphasized the importance of network frequent. Besides that due to mobile users the
topology on the design and performance of mutual topology of the system may also change frequently
exclusion algorithms and suggested that a mutual because of the change of location by a user.
exclusion algorithm should have a strong adaptability Therefore the applications of the algorithms, which
to different network topologies and when a message use information about network topology, are quiet
has passed by N − 1 intermediate nodes, the message limited.
complexity should be considered N instead of 1.
Yan et al.’s [59] algorithm makes use of dynamic 3.2 Logical Structure Based Algorithms
state information and network topology. A unique
The logical structure based algorithms impose a the site, but have not received the privilege yet. When
logical structure (such as tree) on the sites of the a site itself wishes to enter in CS, self is placed in the
system. The request of a site wishing to enter CS queue of that site.
follows a path between requesting site and the site The algorithm does not require sequence
holding token. The token also follows the path from numbers. The upper bound for the number of
the site holding the token to the requesting site. The messages /CS is 2 * D , where D is the diameter
logical structure based algorithms have an average (longest path length) of the tree. The worst topology
lower message cost as compared to broad cast based is a straight line with a diameter of N − 1 and
algorithms, presents better scalability, and uses message complexity of 2( N − 1) . The best topology
simple data structures. However logical structure
is a radiating star with message complexity of
based algorithms are very sensitive to site failure,
O(log k −1 n) , where k is the valence of each non-
because these can not tolerate with a single failure in
leaf node. Two modifications, based on piggyback
the token request path.
strategy and greedy strategy, were also suggested,
which reduce the number of messages required .
3.2.1 Raymond’s static Tree based Algorithm
Raymond’s algorithm[25] assumes that the sites in
3.2.2 Naimi et al.’s Dynamic tree based algorithm
the system being arranged in an unrooted tree
The structure of logical tree used in Raymond’s
structure. In it all the messages are sent along the
algorithm was static and only the direction of edges
undirected edges of this tree. There is a privilege
could be changed. This makes the algorithm highly
message and the site having privilege message is
dependent on the topology of the tree. Naimi, Trehel
allowed to enter its CS. Each site maintains a variable
and Arnold [35] proposed an algorithm based on a
holder, which indicates the location of the privilege
dynamic rooted tree. In this algorithm every process
message relative to the node.
maintains two pointers father and next. The father
When a non-privileged site wishes to enter
indicates the process to which the request for CS
CS it sends a request to its holder site. If the holder
access should be forwarded and the next indicates the
site is also unprivileged, it forwards request to its
node to which access permission should be
holder. Thus a series of request messages travels
forwarded. This algorithm uses two distributed data
along the path between requesting site and the
structures.
privileged site. When privilege message is no longer
(i) Queue- The head of the queue possesses the token
required by the site, it sends it to one of its
and tail of the queue is the last process that has
neighboring sites, which has requested the privilege.
requested CS. Each process knows the next process in
The holder is modified accordingly and privilege
the queue, if its next exists.
message is forwarded along the path. When site
(ii) Logical rooted tree- which gives the path to go to
wishing to enter CS receives privilege, it sets holder
the tail of the queue.
= self and enters CS. A request queue (FIFO) is
When a process wishes to enter its CS, it
maintained at each site, which holds the names of
sends its request to its father. From father to father a
those neighbors that have sent a request message to
request is transmitted to the root, which has father =
nil. This root is also the tail of the queue. The That site considers S i as its new successor. If none of
requesting process transmits its request to father and
the predecessors answers, S i broadcasts a search-
regards itself as the new root. Therefore, there may
prev message to all sites. All sites having smaller
be several rooted trees when messages are in transit.
positions in the queue answers and S i chooses its
However, when all the messages are arrived these are
grouped to form a single rooted tree. When the closest predecessor and connect itself to that site by

request of a process arrives at the tail and if the tail is sending a message. If S i does not receive any answer
waiting for the token, the requesting process is linked in a specified time it regenerate the token and
to the tail. If the tail has the token and is in its CS, the initialize its position to zero in the queue. However, if
requesting process is linked to the tail. Otherwise the S i has not received commit message, an election
token is transferred to the requesting process. When a
algorithm has to be executed and only the elected site
process leaves the CS, it gives the token to the next
is allowed to continue the recovery process.
process in the queue. If no such next exists, the
Only one commit message /CS request is
process will hold the token. The algorithm does not
added in case of no failure, hence the message
use logical clocks or sequence numbers to serialize
complexity remains O(log n) . In case of failure the
the concurrent events, all the variables are bounded
algorithm requires less number of messages and less
and only O(log n) messages/ CS requests are used.
time in comparison to Naimi-Trehel’s fault tolerant
Julien Sopena et al. [21] proposed a fault
algorithm [33]. The algorithm can tolerate at most
tolerant extension for the Naimi-Trehel’s
N − 1 site failures. The Next queue is rebuilt from the
algorithm[35]. The algorithm tries to reconstruct the
previous queue; therefore original ordering of
next queue by gathering intact portions of previous
requests is preserved up to an extent.
next queue, which existed just before the failure. To
Bertier et al. [30] proposed a hierarchal
maintain information about predecessors, whenever
token based mutual exclusion algorithm based on
S i updates its next variable, it sends a commit Naimi-Trehal algorithm [35], which takes into

message to the requester S i . The commit message account the latency gap between local and remote

contains following information. machines. To reduce the number of inter cluster

messages following three techniques were proposed.
(i) The k Predecessors of S i (k can be configured).
(i) Per Cluster Proxy- In each cluster, there exists a
(ii) S i ' s Position in the queue ( S i ' s closest
dedicated process called proxy, which stores the last
predecessor’s position + 1) request to remote clusters. When node i requests for
After receiving a commit message S i periodically the token, which it assumes to belong to a remote
checks the liveness of its closest predecessor. Once a cluster, sends its request to the proxy. If another node
failure is detected by S i and S i has received the j , in the same cluster has recently requested for the

commit message, it sends a message to its token and proxy is aware of it, it redirects i' s request

predecessors from closest to farthest. S i Stops when towards j , thus avoiding messages to remote clusters.
it receives an answer from one of its predecessor site.
(ii) Aggregation – In it when a request has to be sent not require separate election or recovery protocol to
to the probable token holder, belonging to a remote recover lost token, instead token recovery is
cluster; the request is not sent but stored in a queue. It integrated in the protocol itself. The concept of
is stored in a queue in the last node which will enter logical time is used to detect and recover from token
the critical section with in the cluster, which is called loss. The algorithm can handle message loss, site
“Local Root”. failures and network partitioning.
(iii) Token Preemption -In token preemption a high Self-Stabilization is the most fundamental
priority is given to requests originating from the local concept of automatic recovery from transient faults in
cluster to exploit locality. A threshold is defined, in distributed systems. Jun Kiniwa [19] presented a self
order to avoid starvation. Whenever the number of stabilizing token passing algorithm in which a token
local requests is below this threshold; the request path is passed via a dynamic BFS tree rooted at a
is modified, in order to serve local requests first. requesting process. No queues are used in this
The variant of Naimi-Trehel’s algorithm [35] using algorithm and every variable is bounded. The
above mentioned techniques were presented by stabilization time of the algorithm is 1+ 5 * D rounds,
Bertier et. al. and it was observed that the above where D is the diameter of the network. k Covering
mentioned techniques are quiet useful in reducing the
time of the algorithm is k * n round, where n is the
inter cluster messages.
number of processors in the system.

3.3 Centralized Token Based Algorithms

3.2.3 Other Algorithms
Centralized algorithms are those, in which there is a
In Agrawal-Abbadi’s [4] algorithm each site
central coordinator node. Every requesting node
maintains a pointer owner which points towards
requires the permission of the central coordinator to
possible owner of the token. When a site S wants the
execute its CS. Number of messages required in
token, it sends request to its owner, if owner has the
centralized algorithms is very low as compared to
token and not in CS it sends the token to S and if it
other techniques. However, in centralized algorithms
does not have the token, it forwards the request to its
central coordinator is generally overloaded and
owner. If the requesting site does not receive the
becomes the performance bottleneck. There is a
token within a specified time, its request is aborted.
single point of failure in these algorithms; if central
The fault tolerant version of the above
coordinator fails, whole system will fail. Another
algorithm uses the concept of logical time. Each site
disadvantage of central algorithms is that two
S maintains the following information. owners - A sequential messages (release and privilege) are
pointer to site which is possible owner of token. required to pass the lock from one process to another.
ownertime s - is the logical time, when S last sent the The developers of centralized token based
algorithms, tried to combine the advantages of
token to owners , token _ state s - captures the state of
centralized algorithms and token-based algorithms.
shared resource associated with the token, when it
In Felten- Rabinovich’s centralized token
was last owned by the sites S . The algorithm does
based algorithm [12], a node is assigned as master
node, while other nodes are clients. The master node n m and waits for the token. Under light load
maintains an active token queue and a passive token condition since no other node competes for the token,
queue. A client wishing to enter CS sends the request
n m will immediately sends a grant message to the
message to the master. The request is stored in the
requesting node. Hence the response time is 2T + E
passive token queue. A client node can enter its CS
and synchronization delay is T . Under heavy load
upon receiving the token-grant message. The token-
condition n m assigns a sequence number seq, to the
grant message also contains the active token queue.
The node receiving token, removes its id from the node and forwards its request to node n , whose

head of the queue and rest of the queue is stored in a sequence number is seq-1. The forward message

local queue after-me. On exiting from CS, if the carries information about the next requesting node,

node’s after-me queue is non empty, the node sends thus forming a distributed waiting queue. When a

token-grant message, directly to the first node in the node exits from CS it checks whether a forward

after-me queue. message has arrived or not. If no forward message

If the length of active token queue is less has arrived, the node returns the token to n m by
than a predefined length (warning length), the master sending a release message otherwise the token is sent
sends a forward-token message containing a list of to the next node in the distributed queue. The heavy
nodes in the passive token queue, to the node at the load synchronization delay of the algorithm is T .
tail of the active token queue. Then the master node Wu-Shu argued that in centralized algorithms, only
moves nodes from its passive token queue into its the coordinator node has to do some extra work,
active token queue. The master node labels a batch however in decentralized algorithms; every node is
number on each forward-token and token-grant swamped with extra work and communication traffic.
messages, so that previous requests may be
distinguished from the current requests. The batch 4. k- Mutual Exclusion
number is passed along with the token and each client Raymond [26] introduced k-mutual exclusion
remembers the highest batch number it has seen. The problem, as a variant of mutual exclusion problem, in
light load synchronization delay of the algorithm is which at most k processes (1<k≤ n) can enter critical
2T and number of messages/CS under light load is 3. section at a time. For example there may be k copies
The heavy load synchronization delay of the of licenses of software, therefore it can be used by
algorithm is T . If the batch size of b > warning only k users at a time. Raymond also presented a non-
length is assumed, then 2b+2 messages are required token based algorithm for k-mutual exclusion based
for whole batch, Hence the number of messages/CS on Ricart-Agarwala’s algorithm [13], which requires
request is 2 + 2 / b . 2(n − 1) messages per CS invocation.
Wu-Shu [40] presented another centralized Srimani-Reddy [44] presented an extension
token based algorithm in which a node is specified as of Suzuki-kasmi’s algorithm for k-mutual exclusion
coordinator ( n m ). Initially token is held by n m . Any problem. In this algorithm k tokens are circulated.
node that wants to enter its CS sends its request to Because of existence of k tokens in the system up to k
processes may be inside their critical section
simultaneously. If a node owns a token, it may enter next site in the token queue. If value of the
critical section directly, otherwise it sends request semaphore is zero then no change is made to the
message to all other N − 1 nodes and waits for a semaphore and the site receiving token holds the
token. The upper bound for the message complexity token. When a site S i exits from its critical section, it
of this algorithm is N + K − 1 per CS entry.
sends a release message to the site that was K th in the
M.Naimi [34] proposed a directed graph
token queue when S i had removed itself from the
based algorithm for k-mutual exclusion problem.
Initially a logical spanning tree is defined from an queue. If the good site on the token queue is before

arbitrary network and k tokens are given to the root. the K th site, the release message is sent to the good
A waiting queue is maintained at each node. A node site. The value of semaphore is incremented by 1,
requesting CS sends a request to its predecessor and with every release message.
put itself in the waiting queue. The requesting node In this algorithm, a cycle is defined to begin,
then becomes the root and waits for the token. On when the good site picks a new good site, sends out
exiting from CS, the node sends the token to the first update messages. A cycle ends when a new good site
node in its waiting queue. On receiving request from finally receives the token and executes its own CS.
its neighbor Y , if a free token is available at X , it is Let m be the number of token requests in the token
directly sent to the Y , otherwise the node X puts, queue at the beginning of the cycle then n / m + 2
Node Y in its waiting queue and transmits Y’s messages per CS request are required. Under light
request to its predecessors except Y . The node Y
load ( m is close to 1) message complexity is O(n) .
then becomes predecessor of node X and the
Under heavy load (m is close to n) the performance
directed graph is transformed in to another directed
of the algorithm is good and only 3 messages are
graph. The number of message required is between 0
required in the extreme case, when all sites are
to 2 * (n − 1) messages per critical section entry.
requesting to enter CS.
K. Makki et al. [23] used a general Wang-Lang [52] presented a token-based
semaphore and token queue with token in their algorithm for k-mutual exclusion problem based on
algorithm. One site is chosen as ‘good site’. The good Raymond’s tree based approach. The nodes are
site places all token requests, which it receives in its assumed to be arranged in a tree structure, whose
local queue. When good site eventually receives the shape remains static. However the direction of an
token, it executes its CS and then appends its local edge can be changed and multiple edges with mixed
queue in to the token queue. A new good site is directions may exist between nodes. Each node has a
chosen and an update message about new good site token direction bag (tdb) to store those neighbors,
selection is sent to all those sites, which are not in which are on the outgoing paths leading to the nodes,
token queue now. A general semaphore, which is part holding the tokens. A node j can appear several
of the token, indicates the number of critical sections
times in a tdb, if there are several tokens reachable
that are available. Each site that receives the token
from j . Each node maintains a local variable token-
checks the value of this semaphore, if it is non-zero,
count, which indicates the number of free tokens at
the value is decremented by 1 and token is passed to
the node and a queue, which stores the requests from The Group Mutual Exclusion(GME) problem
its neighbors. A root node is chosen randomly to hold introduced by Joung [56], deals with two
K tokens. The directions of edges are selected in a contradictory issues in distributed systems, namely
way so that from each node there exists k paths mutual exclusion and concurrency. Joung modeled
leading to the root. When a node i wants to enter CS GME problem as “Congenial Talking Philosopher
and does not hold any token, it sends a request (i) Problem” [57]. In this problem, there is a set of n
message to each distinct node in tdbi and deletes one philosophers. A philosopher spends his time, either in
occurrence of each distinct node in tdbi. If tdbi is thinking alone or in talking in a group. There is only
empty ( i has already sent messages on behalf of its one meeting room, therefore, only one group can be
neighbors), in that case i simply waits. When node i held at a time. A philosopher interested in a group,
receives token and is waiting to enter CS, it could can succeed to enter the meeting room, only if the
send the token to a neighbor whose request is ahead meeting room is empty, or some philosopher
in the queue. It can also use greedy strategy by interested in the same group is already in the meeting
putting its requests always at the front of the queue. If room. Joung gave the example of a CD juke box
the queue is empty i retains token and increments containing large data objects. When a process needs a

token–count by 1. The performance of the algorithm data object, the data object is loaded to a cache buffer

is highly dependent on topology. The algorithms from the CD juke box. The cache buffer is large

requires at most 2 KD messages for a node to enter enough to store only one data object at a time. The

CS, where D is the diameter of the tree. Processes interested in currently loaded data object,

Bulgannawar-Vaidya [47] used dynamic are allowed to read concurrently, while a process

forest structure for each token to forwarded token requiring different data object has to wait, till the

requests. Each node maintains a pointer array with requested object is loaded to the cache buffer. The

one entry for each token. These pointers define k mutual exclusion and readers-writer problem are

forests corresponding to k tokens. Each node special cases of Group mutual Exclusion problem.

maintains a FIFO queue. Token also contains a queue For mutual exclusion, one forum can be allocated to

containing identifiers of the nodes to which token each process, so that only one process can be in the

must be forwarded in FIFO order. For performance critical section at a time. For readers-writers problem,

comparison simulation experiments were performed a common read forum can be used by all processes,

with 3 other algorithms, namely Raymond’s, Makki’s while a unique write forum can be assigned to each

and Srimani’s algorithms. The simulation results individual process.

shows that proposed algorithm achieves lower delay The solutions to GME problem in shared

in entering as well as lower number of messages. memory model have been proposed by Hadziclos

However average message size is 1.5 to 2 times [54],Kean-Moir [45],P. Jayanti et al. [43] ,S.Petrovic

larger than other algorithms. [51]. In message passing system, non-token based
algorithms for GME problem have been presented by

5. Group Mutual Exclusion Manabe et al. [58], M.Toyomura [38], Wu-Joung

[24], Attrey-Mittal [46]. Till date very few token
based algorithms for group mutual exclusion problem changes from ONR to OR. When process p , leader of
exist. Some of these algorithms are discussed in the session X receives the token in OR state, it closes
following subsections. the session and changes token state from OR to CR.
When a process, say r receives the token in CR state,
5.1 Cantarell et al.’s algorithm for unidirectional r can be in critical section. In that case, r holds the
rings token and releases the token on exiting from the
Cantarell et al. [48] presented a token based critical section. When process p (leader of session
algorithm for GME problem in unidirectional ring X ) again receives the token in CR state, it closes
networks. The existence of two layers, application session X and changes the state of the token from
layer and GME layer, is assumed in the system. The CR to ONL, meaning that session Y is now open.
application layer sends request-session message to The new leader may not be the first process which
request a session and a release-session message on changed the value of Token.N from ⊥ to Y . The
completion of session. The GME layer grants the main advantage of the above mentioned algorithm is
application layer to access session by sending a that it does not require process id and maintains no
grant-session message to the application layer. data structure for implementing any queue. The size
The algorithm uses a token to open and of the message is bounded. The worst case message
close the session only. The token contains the ids of
complexity is O(n 2 ) per resource request and zero
current session and next session respectively. The
messages in the best case. This algorithm is
first process entering a session X is called the leader
starvation free. However, in this algorithm the
of the current session and it advertises other
sessions are not opened in a FCFS manner. Because
processes that session X is open. The token may be
while session X is open two processes p and q
in any one of the following states.
requested for session Y and Z respectively. It is
1. Closed with No leader (CNL) - Token ( ⊥ , ⊥ )
possible that although process p made the request
2. Open with no request (ONR) - Token ( X , ⊥ )
before process q, session Z can be initialized before
3. Open with request (OR) -Token ( X , Y ) (
session Y.
X ≠ ⊥ , Y ≠ ⊥ and X ≠ Y )
4. Closed with request (CR) - Token ( ⊥ , Y )
(Y ≠ ⊥ )
5.2 Mittal-Mohan’s algorithm for non uniform
5. Open with no Leader (ONL) - Token ( X , X )
group access
( X ≠⊥ )
Mittal-Mohan [41] presented a token based algorithm
When a process p requesting to enter the for GME problem, for applications in which a small
critical section for session X , receives the token from no of groups are requested more frequently than
its predecessor, it becomes the leader and sends token others. For example in a CD-juke box of 1000 CD’s,
( X , ⊥ ) to tell that session X is open (state= ONR). 5-10 CD’s may be in high demand (say >50% time),
Each process requesting session X may enter the or in multiple readers single writer problem, read
critical section concurrently. When a process say q , requests are more common than write requests. The
requests for a session Y ( Y ≠ X ) the state of token algorithm is based on Suzuki-Kasmi’s [16] algorithm.
 In this algorithm two type of tokens, primary particular type. The age of pending requests is
token and secondary tokens are used. At a time there increased with each new session opened. Group age
can be only one primary token, while there may be is calculated by summing the ages of all requests in
multiple secondary tokens. Each token is associated the group of that type. The group, having maximum
with a type or group, and can be used to enter request group age is selected to be opened next. Age factor is
of that type only. A process-holding primary token is used to remove starvation and summation of ages is
allowed to issue secondary tokens to others. The done to ensure that groups having higher number of
primary token stores the number of secondary tokens requests get priority. A process on receiving the

issued. Each process maintains an array request i . primary token, can not use it immediately because
some secondary tokens may be in use. Therefore, it
The request i [ j ] contains the sequence number of
waits until; it has received all the required release
latest request of process P j , along with its type, messages from the processes holding secondary

which process Pi knows. A primary as well as tokens.

The message complexity of above algorithm
secondary token contains a vector fulfilled ,
is (2n − 1) messages per CS invocation.
fulfilled [ j ] stores the number of requests of P j ,
Synchronization delay of the algorithms is T and
which have been fulfilled so far. If the process Pi is
waiting time is 2T . The maximum concurrency of
holding a token and request i [ j ]  tokeni . fulfilled [ j ] , algorithm is n , that means all processes can be in

P j has pending requests. their CS simultaneously, if their request type is same.

Further request and release messages have a constant
If the process wishing to enter CS holds the
size, while the size of token is O(n) .
token of the same type, it enters CS. Otherwise it
sends request to all processes. A process holding a
5.3 other algorithms
secondary token, when learns about conflicting
David Lin [8] announced a token based algorithm for
pending requests, it sends release message to all
group mutual exclusion, which provides an upper
other processes, after coming out of its CS. The
bound to the number of messages and to the message
process holding primary token, on receiving new
size. The algorithm is compared with Wu and
request of the same type, issues a secondary token.
Joung’s algorithm [24] and Cantarell et al.’s
However, if the request type conflicts with that of
algorithm [48] on the basis of message complexity,
token, the request is stored in the token queue. The
message complexity in absence of requests, message
process holding the primary token after coming out of
size, forum switch complexity and time complexity.
its CS, selects one type for which pending requests
Vidyasankar [27] proposed a natural
are there and passes primary token to one of the
generalization of Group mutual exclusion problem
processes having pending request of that particular
called group k- mutual exclusion allowing up to k
type. For selecting the type of request to be served
forums to be held simultaneously. J.R.Jiang [20]
next, two criteria’s are used, first the age of the
proposed a token based algorithm for the group k-
request and second the number of requests of that
mutual exclusion algorithm problem in distributed
systems. The proposed algorithm does not use node Transactions on Computer Systems 5 (3)
identifiers for node identification. The delay of the (1987) 284 – 299.
[3] D. Agrawal, A. El Abbadi, The generalized
algorithm is O(n 2 ) and forum switch complexity is
tree quorum protocol: An efficient approach
O(n) .
for managing replicated data, ACM
Transactions on Database Systems 17 (4)
6. Conclusion (1992) 689 – 717.
The distributed mutual exclusion has always been [4] D. Agrawal, A. El Abbadi, A token based fault
inviting research attention since its inception. The tolerant distributed mutual exclusion
token based algorithms are quiet useful and important algorithm, Journal of Parallel and Distributed
among the algorithms for solving distributed mutual Computing 24 (1995) 164 – 176.
exclusion problem. The algorithms discussed in the [5] D. Barbara, H. Garcia-Molina, Mutual
paper shows varying performance characteristics with exclusion in partitioned distributed systems,
respect to different performance parameters. The Distributed Computing (1) (1986) 119 – 132.
system designer, while choosing a particular [6] D. Barbara, H. Garcia-Molina, A. Spauster,
algorithm, has to take care about the performance Increasing availability under mutual exclusion
characteristics of the algorithm, requirement of the constraints with dynamic vote reassignments,
application and implementation aspect. ACM Transactions on Computer Systems 4
In order to limit length of the presentation, (13) (1986) 197 – 213 .
we could not include the complete list of token based [7] D.K. Gifford, Weighted voting for replicated
mutual exclusion algorithms. However, we could data, Proceedings of 7th Symposium on
accommodate all significant contributions to the said Operating Systems, ACM (1979) 150 –162.
area. For the sake of brevity, we discussed the [8] D. Lin, T.S. Moh and M. Moh, Brief
algorithm concepts rather than the detailed announcement: improved asynchronous group
algorithms. The token based group mutual exclusion mutual exclusion in token passing networks, In
and k-mutual exclusion algorithms have also been the Proceedings of PODC’05 (2005) 275 –275.
covered, although , they are small in number. [9] E. Lycklama, V. Hadzilacos, A first–come-
first-served mutual exclusion algorithm with
References small communication variables, ACM
Transactions on Programming Languages and
[1] A. Kumar, Hierarchical quorum consensus: a Systems 13(4) (1991) 558 –576.
new algorithm for managing replicated data,
[10]E. Styer, Improving fast mutual exclusion, In
IEEE Transactions on Computers 40 (9)
the Proceedings of 11th annual ACM
(1991) 996 – 1004.
Symposium on Principles of Distributed
[2] B.A. Sanders, The information structure of
Computing (1992) 159 – 168.
distributed mutual exclusion algorithms, ACM
[11] E.W. Dijkastra, Co-operating sequential
processes, in F.Geniys (Ed.), Programming
 Languages, Academic press, New York (1965) IASTED conference on Parallel and
43 –112. Distributed Computing and Systems (2003).
[12] E.W. Felton, M. Rabinovich, A centralized [21] J. Sopena, L. Arantes, M. Bertier, P. Sens, A
token based algorithm for distributed mutual Fault tolerant token based mutual exclusion
exclusion, Technical report 92-02-02, algorithm using a dynamic tree, LNCS 3648
department of computer science, university of (2005) 654 – 663.
Washington, February 1992. [22] K.M. Chandy, J. Mishra, The drinking
[13] G. Ricart, A.K. Agarwala, An optimal philosopher problem, ACM Transactions on
algorithm for mutual exclusion in computer Programming Languages and Systems, 6 (4)
networks, Communications of the ACM 24 (1) (1984) 632 – 646.
(1981) 9 – 17. [23] K. Makki, P. Banta, K. Been, N .Pissinou,
[14]H. Attiya, V. Bortnikov, Adaptive and E.K. Park, A token based distributed k mutual
efficient mutual exclusion, In the Proceedings exclusion algorithm, In IEEE Proceedings of
of the 19th annual ACM Symposium on the Symposium on Parallel and Distributed
Principles of Distributed Computing (2000) Processing (1992) 408 – 411.
91 – 100. [24]K.P. Wu, Y.J. Joung, Asynchronous group
[15] H. Garcia-Molina, D. Barbara, How to assign mutual exclusion in ring networks, In
th
votes in a distributed system, Journal of the Proceedings of 13 International Parallel
Associated Computing Machinery 32 (4) Processing Symposium (IPPS ’99) 539 – 543.
(1985) 841– 860. [25] K. Raymond, A tree based algorithm for
[16] I. Suzuki, T. Kasmi, A distributed mutual distributed mutual exclusion, ACM
exclusion algorithm, ACM Transactions on Transactions on Computer Systems 7 (1)
Computer Systems l3 (4) (1985) 344 – 349. (1989) 61 – 77.
[17]J. Anderson, Y.J. Kim, An improved lower [26] K. Raymond, A distributed algorithm for
bound for the time complexity of mutual multiple entries to a critical section,
exclusion, In the Proceedings of the 20th Information Processing Letters 30 (1989) 189
annual ACM Symposium on Principles of – 193.
Distributed Computing (2001) 90 –99,2001. [27] K. Vidyasankar, A simple group mutual l
[18] J. Burns, Mutual exclusion with linear waiting exclusion algorithm, Information Processing
using binary shared variables, In ACM Letters 85 (2003) 79 –85.
SIGACT News (1978) 42 – 47. [28] L. Lamport, Time, clocks, and the ordering of
[19] J. Kiniwa, Request based token passing for self events in a distributed systems,
stabilizing mutual exclusion, International Communications of the ACM 21 (7) (1978)
Conference on Parallel and Distributed 558 – 565.
Computing Systems (2003). [29] L. Lamport , A fast mutual exclusion
[20] J.R. Jiang, Group k mutual exclusion for algorithm, ACM Transactions on Computer
distributed systems, In the Proceedings of Systems, 5 (1) (1987) 1 – 11.
[30] M. Bertier, L. Arantes, P. Sens, Hierarchical [38]M. Toyomura, S. Kamei, H. Kakugawa, A
token based mutual exclusion algorithms, quorum–based distributed algorithm for group
IEEE International Symposium on Cluster mutual exclusion,” In the Proceedings of 4th
Computing and the Grid (2004) 539 – 546. International Conference on Parallel and
[31]M. Maekawa, A √n algorithm for mutual Distributed Computing (2003).
exclusion in decentralized systems, ACM [39] M.Y. Wu, W. Shu, An efficient distributed
Transactions on Computer Systems 3 (2) token based mutual exclusion algorithm with
(1985) 145 – 159. central coordinator, Journal of Parallel and
[32]M. Mizuno, M.L. Neilson, R. Rao, A token Distributed Computing 62 (2002) 1602 –1613.
based distributed mutual exclusion algorithm [40]N. Lynch, N. Shavit , Timing based mutual
based on quorum agreements, In Proceedings exclusion, In Proceedings of the 13th IEEE
of the 11th International Conference on Real Time Systems Symposium (1992) 2 –
Distributed Computing Systems (1991) 361 – 11.
368. [41] N. Mittal, P.K. Mohan, An efficient distributed
[33]M. Naimi, M. Trehel, How to detect a failure Group mutual exclusion algorithm for non-
uniform group access, In the Proceedings of
and regenerate the token in the log(n)
the International Conference on Parallel and
distributed algorithm for mutual exclusion,
Distributed Computing Systems (2005).
Lecture Notes in Computer Science LNCS 312
[42] P.C. Saxena, S. Gupta, A token based delay
(1987) 155 – 165.
optimal algorithm for mutual exclusion in
[34] M. Naimi, Distributed algorithm for k-entries
distributed systems, Computer Standards &
to critical section based on the directed graphs,
Interfaces 21 (1999) 33 – 50.
ACM SIGOPS Operating System Review
[43]P. Jayanti, S. Petrovic, K. Tan, Fair group
27(4) (1993) 65 – 75.
mutual exclusion, In the Proceedings of 22nd
[35] M. Naimi, M.Trehel, A. Arnold, A Log (N)
PODC (2003) 275 – 284, 2003.
distributed mutual exclusion algorithm based
[44] P.K. Srimani, R.L. Reddy, Another distributed
on path reversal, Journal of Parallel and
algorithm for multiple entries to critical
Distributed Computing 34 (1996) 1 – 13.
section, Information processing letters 30
[36] M. Singhal, A heuristically–aided Algorithm
(1992) 189 – 193.
for mutual exclusion in distributed systems,
[45] P. Kean, M. Moir, A simple local spin group
IEEE Transactions on Computers 38 (5)
mutual exclusion algorithm, In: Proceedings of
(1989) 651 – 662.
the 18th annual ACM Symposium on
[37] M. Singhal, A class of deadlock free Maekawa
Principles of Distributed Computing (1999) 23
type algorithm for mutual exclusion in
– 32.
distributed systems, Distributed Computing 4
(1991) 131 – 138. [46]R. Attreya, N. Mittal, A dynamic group
mutual exclusion algorithm using surrogate
quorums, In the Proceedings of the 25th IEEE
 Conference on Distributed Computing [55]Y.I. Chang, M. Singhal, M.T. Liu, A dynamic
Systems(ICSDCS’05) (2005). token based distributed mutual exclusion
[47] S. Bulgannawar, N.H. Vaidya, A distributed k algorithm, In Proceedings of 10th annual
mutual exclusion algorithm, International International Phoenix Conference on
Conference on Distributed Computing Computers and Communications (1991) 240 –
Systems (1995) 153 – 160. 246.
[48] S. Cantarell, A.K. Dutta, F. Pilit, V. Villain, [56] Y.J. Joung, Asynchronous group mutual
Token based group mutual exclusion for exclusion, Distributed Computing 13 (4)
asynchronous rings, in the Proceedings of the (2000) 189-206.
IEEE International Conference on Distributed [57] Y.J. Joung, The Congenial taking philosopher
Computing Systems (ICDCS’01) (2001) 691 – problem in computer networks, Distributed
694. Computing (15) (2000) 155 – 175.
[49] S. Jajodia, D. Mutcher, Dynamic voting [58]Y. Manabe, J. Park, A quorum based extended
algorithms for maintaining the consistency of a group mutual exclusion algorithm without
replicated data, ACM Transactions on unnecessary blocking, In Proceedings of 10th
Database Systems 15 (2) (1990) 230 – 280. International Conference on Parallel and
[50] S. Nishio , K.F. Li, and E.G. Manning, A Distributed Systems (ICPADS’04) (2004)
resilient mutual exclusion algorithm for 341– 348.
computer networks, IEEE Transaction on [59] Y.Yan, X. Zhang, H.Yang, A fast token
Parallel and Distributed Systems 1 (3) (1990) chasing mutual exclusion algorithm in
344 –355. arbitrary network topologies, Journal of
[51] S. Petrovic, Space efficient FCFS group Parallel and Distributed Computing 35 (1996)
mutual exclusion, Information Processing 156 – 172.
Letters 95 (2005) 343 –350.
[52] S. Wang, S. D. Lang, A tree based distributed
algorithm for the k entry critical section
problem, In IEEE International Conference on
Distributed Computing Systems (1995) 153 –
160.
[53] T.H. Thomas, A majority consensus approach
to concurrency control, ACM Transactions on
Database Systems 4 (2) (1979) 180 – 209.
[54]V. Hadzilacos, A note on group mutual
exclusion, In Proceedings of the 20th ACM
Symposium on Principles of Distributed
Computing (2001) 100 – 106.