A Dynamic Token-Based

Distributed Mutual Exclusion Algorithm

Ye-In Chang, Mukesh Singhal, and Ming T. Liu
Dept. of Computer and Information Science
The Ohio State University
Columbus, OH 43210-1277, USA

Abstract into two classes: token-based and non-token-based. In

token-based algorithms [2,4, 9, 10, 13, 15, 171, only the
This paper presents a dynamic token-based mutual ex- site holding the token can execute the CS and makes the
clusion algorithm for distributed systems. In the algo- final decision on the next site to enter the CS. In non-
rithm, a site invoking mutual exclusion sends token re- token-based algorithms [ l , 3, 5, 6, 7, 8, 1 1 , 14, 161,
quest messages to a set of sites possibly holding the a requesting site can execute the CS only after it has
token as opposed to all the sites as in Suzuki et al.'s al- received permission from each member of a subset of
gorithm [17j. A requesr ser is used to record the identi- sites in the system, and every site receiving a CS request
fiers of such a set of sites in the system. The algorithm is message participates in making the final decision.
dynamic because the request set is dynamically changed Suzuki et al.'s algorithm [17] is one of the well-
as the algorithm is executed. As the size of the request known token-based algorithms. In this algorithm, a site
set is reduced, the number of the messages exchanged invokmg mutual exclusion sends a Request message to
per CS execution is reduced. Compared with Suzuki et every other site if it does not hold the token. However, it
al.'s algorithm, the proposed algorithm can reduce the is not necessary for a requesting site to send a Request
number of the messages exchanged by 40% when the message to every other site in order to search for the
traffic is light. Finally, we discuss an interesting rela- token. A requesting site can get the token when those
tionship between the token-based and non-token-based sites whch are possibly holding the token receive such
mutual exclusion algorithms. It is this relationship that Request messages.
has motivated us to design such a dynamic token-based In this paper, we present a dynamic token-based mu-
algorithm. tual exclusion algorithm for distributed systems. In this
algorithm, a request ser is used to record the identi-
fiers of those sites which are possibly holding the token.
1 Introduction Therefore, a site invoking mutual exclusion sends Re-
quest messages only to the sites whose identifiers are
A distnbuted system consists of a collection of geo- in its request set, instead of sending Request messages
graphically dispersed autonomous sites connected by a to all other sites in the system. The algorithm is dy-
communication network. The sites have no shared mem- namic because the request set is dynamically changed
ory and communicate with one another by passing mes- as the algorithm is executed. As the size of the request
sages. Message propagation time delay is finite but un- set is reduced, the number of the messages exchanged
predictable. In this paper, we assume that the commu- per CS execution is reduced. Compared with Suzuki et
nication subsystem is reliable and sites do not crash. al.'s algorithm, the proposed algorithm can reduce the
To achieve mutual exclusion, concurrent access to number of the messages exchanged by 40% when the
a shared resource or the Critical Section (CS) must be traffic is light. Finally, we discuss an interesting rela-
synchronized such that at any time only one process can tionship between the token-based and non-token-based
access the CS. Over the past decade, many algorithms mutual exclusion algorithms. It is this relationshp that
to achieve mutual exclusion in distributed systems have has motivated us to design such a dynamic token-based
been proposed. Those algorithms can be classified algorithm.
'Research reported herein was supported by US.Army CECOM.
The rest of the paper is organized as follows. In the
Ft. Monmouth. NJ, under contract No. DPLAB07-88-K-ii003. The next section, we present the algorithm. In Section 3 . we
views. opinions, and/or h d m g s contained in this paper are those of prove the correctness of the algorithm. In Section 3, we
the authors and should not be constmed as an official Department of study the performance of the algorithm. In Section 5.
the Army position, policy or decision.

240
CH2859-5/91/0000/0240$01.000 1991 IEEE
we discuss several extensions to the proposed algorithm. procedure Request-CS;
In Section 6, we discuss an interesting relationship be- besin
tween the token-based algorithms and non-token-based (* the request phase *)
algorithms, and describe how we “discovered” the dy- Requesting = true;
if (not HaveToken) then
namic token-based algorithm based on the observed re-
begin
lationship. Finally, Section 7 contains the concluding Seq[S] = Seq[Sl + 1;
remarks. for every Y E R do
send a RequestG Seq[S]) message to site Y;
wait until the Token(TQ, TSeq) is received;
2 Description of the Algorithm R = 4;
HaveToken = true;
In the algorithm, every site maintains the information end;
about the sites possibly holding the token. A site ex- Requesting = false;
ecutes a Request-CS procedure to invoke mutual ex- (* the execution phase *)
clusion and a Request Message Handler processes the Executing = true;
incoming Request messages. enter the CS;
ExecuMg = false;
(* the release phase *)
2.1 Data Structure and Initialization TSeq[S] = Seq[S];
At every site S , a request set Rs is used to record the for X = 1 to N do
identifiers of the sites possibly holding the token. To if ((not (X E TQ)) and (Seq[Xl = TSeqp] + 1))
then EQ(TQ, X);
detect an out-of-date request message, a Seqs array (with
for every Y in TQ do R = R U {Y};
N entries) at each site S and a TSeq array (with N entries) if (TQ # 4 ) then
in the Token message are required. Seqs[I] at site S , 1
begin
5 I 5 N, records the number of CS requests made by HaveToken = false;
site I as far as site S knows; TSeq[I] records the number Y = DQITQ);
of CS executions finished by site I. If TSeq[I] > Seqs[I] send a Token(TQ, TSeq) message to site Y;
at site S , the value of Seqs[Q is out-of-date; if Seqs [U > end;
TSeq[I] at site S (i.e., SeQ[rl = TSeq[Il + l), site I has end;
finished the (TSeq[I])’th CS execution, and is requesting
the (Seqs[I])’th (= Seq~[l])CS execution. Figure 1: Request-CS procedure
A FIFO (First-In-First-Out) queue TQ included in
the Token message contains waiting requests. There are
two operations on TQ: EQ(TQ, X) and DQ(TQ). An HaveTokens flag. If site S does not hold the to
EQ(TQ, X) procedure adds the identifier of site X to TQ, increases Its sequence number by 1 and includes t
and a DQ(TQ) function removes the first entry X from quence number in each Request message to every
TQ and returns entry X as the function value. Three whose identifier is in Rs. After site S receives the
boolean variables are used to denote the state of a site ken(TQ, TSeq) message, it resets Rs to empty and
S : Requestings, Executings, and HaveTokens. These enters the execution phase.
variables are true only if a site is requesting, executing, In the release phase, site S updates its
and holding the token, respectively. number in the TSeq array included in the Toke
Initially, every site S sets R s to contain the identi- to inform other sites that it has h s h e d the (Seqs[S])’th
fiers of all other sites in the system, Seqs[Q = 0, 1 5 I CS execution. Then, site S checks whether there is any
5 N, and Requestings = Executings = HaveTokens = new request, and adds these new requests to TQ. For
false. We arbitrarily choose a site X to hold the token, those sites whose identifiers are in TQ, they are the
and sets HaveTokenx = true and R,y = 4. sites possibly holding the token after site S sends out
the token. Therefore, every entry in TQ is recorded
2.2 The Algorithm Rs. If there is any waiting request Y in TQ, site S set
HaveTokens = false, and sends the token to site Y
Site S executes the Request-CS procedure, shown in In the Request Message Handler, shown
Figure 1 (where the underlined statements show how 2, site S takes different action depending on it
R is updated and used as the algorithm is executed), state. If this is an out-of-date request, i.e.,
to invoke mutual exclusion. In the request phase, Seqs[W, then site S ignores the request. Otherwise,
site S checks whether it holds the token by testing the if site S holds the token and is not executing the CS,

241
procedure Request-Handler;
begin (* for Request(X, XSeq) message *)
if (XSeq > S e q [ X j ) then Set S3
begin
SeqCX] = XSeq;
if ((HaveToken)and (not (Executing)) Token
and (Seq[W = TSeq[W + 1)) then Set SI
begin
HaveToken = false; Figure 3: The system
send a TokenflQ, TSeq) message to site X;
end
else if ((Requesting)and (not(X E R))) 2. A site holding the token will send the token to a request-
then send a Request(S, Seq[S]) message to site X: ing site in finite time.
If (not (X E R)) then R = R U {X};
end; To prove that condition 1 holds in the algorithm, we
end; use the following lemmas:
Lemma 1: Site X s request will arrive at site Y which
Figure 2: Request Message Handler holds the token before site X gets the token if('ti i, j , i
E R, or j 5 R, when site X invokes mutual e.dusion.
Proof: The condition ('ii, j) i 5 R, or j E R, implies
it sets HaveTokens = false and sends the token to site that the system can be considered as a union of three
X; ( 2 ) if site S is requesting the CS and has not sent a disjoint sets (denoted as S1, S2 and S3) as shown in
Request message to site X, it sends a Request message Figure 3: S 1 = {X}, S2 = {YI Y E R,y}, and S3 =
to site X. In both cases, site X can be the site holding {Zl X E Rz}. Note that when a site Y holds the token.
the token before site S enters the CS; therefore, site S RY = 4 (i.e., the identifier of site X cannot be in Ry).
adds the identifier of site X to R s .
Therefore. when site X's request arrives at site Y (Y E
S2), the token can be held at site Y (Y E S2) or has
been sent to site 2 (Z E S3) from site Y (Y 5 S 2 ) .
3 Correctness In the case that the token is still held at site Y (Y E
S2), site X's request will arrive at the site holding the
In this section, we show that the algorithm achieves mu-
token. In the case that the token has been sent to site 2
tual exclusion and is free from deadlock and starvation.
(Z E S3) from site Y (Y E S 2 ) , site Z must have sent a
Request message to site X (due to X E Rz). When site
3.1 Mutual Exclusion X receives site 2's request (Z E S3), site X detects that
the identifier of site Z is not in R.Y. Then, site X sends a
To show that the algorithm achieves mutual exclusion, Request message to site 2 and adds the identifier of site
we have to prove that at most one site holds the token. Z to R,y (i.e., the identifier of site 2 is removed from set
Initially, only one site holds the token, say site S. There S3 and added to set S 2 at this moment). Consequently,
are two situations where site S sends the token to another in both cases, site X's request will arrive at a site holding
requesting site: (1) after site S 6nishes execution of the the token.
CS and TQ # 9; (2) when site S is not executing and one Lemma 2: (V X , Y ) X E RY or Y E R,y is always
Request message is received. In either case, site S sends satisfied in the algorithm.
the token to only one site and resets the HaveToken flag Proof: Initially, a site Y holding the token has Ry =
to false before it sends out the token. Therefore, at most 0,and every other site X has R.y containing the identi-
one site holds the token. tiers of all other sites in the system: therefore. the condi-
tion is satisfied initially. As the algorithm is executed, a
3.2 Freedom from Deadlock site X can be in one of the following four states depend-
ing upon the changes to R,y : (1) site X is requesting the
A system of sites is said to be in deadlock when no site is CS, ( 3 ) site X holds the token and is executing the CS,
executing the CS and no requesting site can ever execute (3) site X has finished execution of the CS and has sent
the CS. To show that such a situation never occurs and the token to another requesting site Y, and (4) site X
a requesting site eventually gets the token, the following receives a request from the other site Y.
two conditions must hold: In the first case since site X is requesting the CS. the
identifier of site X is added to RY ((b Y) Y E R,yh At
1. A request will ruTive at a site holding the token. this point, X E Ry for all other sites Y. In the second

242
case when site X receives the token, site X sets R x =
$J: however, X E Ry is still true for all other sites Y. 22
- - k
Ln the third case when site X sends the token to another 20 -
requesting site Y, site X adds the identifier of site Y
to R,y. Therefore, for the requesting site Y which is
number o f 18 -
going to hold the token (and then set R Y = 4), Y E
messages 16 -
I4 -
0 Suzuki
R.Y, and for the other sites Z, X E RZ still holds. In + proposed

12 -
the fourth case when site X receives a request form site
Y, it adds the identifier of site Y to R x . Therefore, for
those requesting sites Y which send Request messages IO . , . , . I . , .,. I . I . , . , .
to site X, both X E Ry and Y E R,y are true, and for
the other sites Z, either X E RZ or Z E R x remains
true. Therefore, X E Ry or Y E R,y is always satisfied
in the algorithm. 3
From lemma I and lemma 2. a request will arrive Simulation experiments were carried out for a ho-
at a site holding the token; therefore, condition 1 holds. mogeneous system of 21 sites (i.e., N = 21) for various
Since all waiting requests (which can be detected from values of the traffic of CS requests (A). Message propa-
the condition Seqs[I] = TSeq[I] t 1 at site S) are added gation delay ( T )between the sites was taken as 1.0, and
to TQ, and the site holding the token will send the token CS execution time ( E )was taken as 0.0002. The values
to the first site in TQ, condition 2 is also satisfied by of the parameters chosen here are consistent with those
the algorithm. Consequently, the algorithm is free from in [12].
deadlock. Figure 4 shows the message traffic of the proposed
algorithm and Suzulu et al.’s algorithm [17] as a function
of the arrival rate. Ln light traffic (0 5 X 5 0.04). most
3.3 Freedom from Starvation of the time only one or no request for CS is present in
Starvation occurs when a few sites repeatedly execute the system; the algorithm needs less than 60% * N mes-
sages per CS execution. In heavy traffic, all the sites will
the CS while other sites wait indefinitely for their turns
always have a pending request for CS execution; there-
to do so.
fore, /RI = N - 1, and the algorithm needs N messages
Ln the algorithm, a FIFO (First-Ln-First-Out) queue
TQ is used to contain all waiting requests detected at the which is the same as in Suzuki et al.’s algorithm.
site holding the token. Moreover, the token is passed
around according to the order of requests in TQ. After a 5 Extensions
site Y whose request is in front of site X’s request in TQ
has finished execution of the CS, its subsequent request We now present an improved version of the dynamic
will be added to TQ after site X’s request. Therefore, token-based mutual exclusion algorithm in whch the
site X will get the token before any of the sites whose queue TQ included in the Token message IS removed and
requests are in front of site X ’ s request in TQ gets the a drfferent arbitration rule is used to determine the next
token twice (or more). Consequently, the algorithm is site to hold the token. Moreover, we discuss different
free from starvation. initialization of request sets in such a dynamic token-
based algorithm.

4 Performance 5.1 A Dynamic Token-Based Mutual Exclusion

Algorithm Without TU
In this section, we study the performance of the pro-
posed algorithm by simulation. The performance model The queue TQ is used to record those waiting requests
used in this paper is similar to the one used in [12]. and stores them in a certain order (to smplify the deter-
We assume that requests for CS execution arrive at a mination of the next site to hold the token). However,
site according to the Poisson distribution with parame- the use of TQ is redundant since those waiting requests
ter A. Message propagation delay between any two sites can be determined by the relationship between Seq and
is constant ( T ) .The time taken by a site to execute the TSeq, and the order about the next site to hold the token
CS is also constant ( E ) . A site processes the requests can be determined by several arbitration rules [ 151. A
for the CS one by one, and there is only one CS in the site I satisfying (Seqs[Il = TSeq[I] t 1) at site S , 1 5
system. I 5 N, implies that site I has a waiting request.

243
 "(***)"means the changes to the previous algorithm * ) from the Token message and a waiting request is de-
the request phase is the same as that in Figure 1 *) tected by comparing each entry in TSeq and Seq arrays.
In the release phase, if (Seqs[W = TSeq[X] + 1) at site
the release phase *) S , then site X has a waiting request. T h ~ salso implies
TSeq[S] = Seq[S]; that site X possibly holds the token after site S sends
for X = 1 to N do (***)
if (Seqm = TSeqCX] + 1) then (***) out the token; therefore, the identifier of site X is added
R = R U {XI: to Rs. Next, site S uses the round-robin arbitrary rule
~ , .(***)
% ~ ,
for X = (S + 1) to N, and then 1 to ( S - 1) do (***) to determine the next site to get the token. The Request
if (Seq[W = TSeq[W + 1) then (***) Message Handler is similar to the one in the algorithm
b e p (***) presented in Section 2 , except that the Token message
HaveToken = false; (***) does not include TQ information. This algorithm has
send a Token(TSeq) message to site Y (***) similar message traffic as the dynamic token-based al-
exit; (***) gorithm presented in Section 2.
end; (***) Ricart et al. [12] have proposed a token-based mu-
tual exclusion algorithm which also removes the queue
procedure Request-Handler; TQ from the Token message as opposed to Suzuki et al.'s
begm (* for Request(X, XSeq) message *) algorithm [17]. A round-robin arbitration rule is used
if (XSeq > Seq[xl) then in Ricart et al.'s algorithm. However, in Ricart et al.'s
&gin token-based algorithm, a site involung mutual exclusion
SeqM = XSeq;
sends Request messages to all other sites, instead of a
if ((HaveToken)and (not (Executing))
and (Seq[q = TSeq[X] + I)) then set of sites possibly holding the token as in our dynamic
token-based algorithm presented in Section 5 . That is,
begin
HaveToken = false; both Ricart et al.'s token-based algorithm and Suzuki
send a TokenflSeq) message to site X; (***) et al.'s algorithm have sruric request sets which contain
end the identifiers of all other sites in the system. On the
else if ((Requesting)and (not(X E R))) other hand, our two algorithms presented in Sections 2
then send a Request@, Seq[S]) message to site X; and 5 have dynamic request sets, thereby improving the
If (not (X E R)) then R = R U {XI; system performance.
end;
end;
5.2 Initialization of Request Sets
Figure 5 : A dynamic token-based mutual exclusion al-
gorithm without TQ In both of the proposed dynamic token-based mutual
exclusion algorithms, we initialize the request set at a
site to contain the identifiers of all other sites and then
One of the arbitrary rule is that a site can determine update the request set to ensure that the condition (Y X,
the next site to hold the token in a round-robin fash- Y) X E Ry or Y E R,y is always satisticd. As proved in
ion, i.e., site S sends the token to a site with the lowest Section 3, X E Ry or Y E R-y is the sufficient condition
identifier which is higher than that of site S (with wrap to ensure that a request will arrive at a site holdmg the
around). This scheme guarantees that a site does not token in a dynamic token-based algorithm. Therefore,
get the token more than once while other sites are wait- it is not necessary to initialize a request set to contain
ing for it. The other arbitration rule is that a site can the identifiers of all other sites in the system. Figure 6-
send the token to a site which has the smallest sequence (a) shows an example of initializing request sets which
number of all the requesting sites. This scheme favors satisfy the condition, assuming site 1 holds the token
the sites which have executed the CS less frequently and initially. Figure 6-(b) shows another example in which
discourages the sites which have executed the CS fre- R s = { 1,2, . . ., (S-I)} and site 1 holds the token initially.
quently. Note that the ordering of requests in TQ does In this way, if X < Y, R,y 1 Ry = { 1. 2 , . . ., (X-
not reflect the order in which the corresponding sites I)} (i.e., R,y C RY), which implies that X E Ry or Y
made the requests for the CS. Therefore, the removal E R,y. Therefore, many different ways of initializing
of TQ not only reduces the size of the Token message request sets that satisfy the condition ('V X, Y) X E Ry
whch in turn reduces processing and communication or Y E R,y can be applied to our dynamic token-based
overhead, but also provides the flexibility of detennin- algorithm. Singhal's heuristically-aided algorithm [ 151
ing the next site to hold the token. in which the system is initialized as Figure 6-(b) is a
In the algorithm, shown in Figure 5 , TQ is removed special case of the dynamic token-based algorithm.

244
 to ask for pemssion from site Y, and message traffic
is reduced. To achleve this purpose, a boolean array A
is used and dynarmcally updated at each site such that
it records the identifiers of a set of sites which are not
requesting the CS. (Note that the boolean m a y A used
in Carvalho et al.’s algonthm has the sirmlar function
as the request set R used m our dynamic token-based
algorithm.)
Moreover, the relationshp among Suzuki et al.’s al-
Figure 6: Initialization of request sets in a dynamic gonthm [ 171, the proposed dynamic token-based algo-
token-based algorithm nthm, and Smghal’s hemstically-aided algorithm [15]
is similar to the relationship among Ricart et al.’s non-
token-based algorithm [ 111, Carvalho et al.’s algorithm
6 Relationship Between Token-Based [l], and Singhal’s dynamic information structure algo-
and Non-Token-Based Algorithms nthm [16]. That IS, the proposed dynamic token-based
algonthm improves Suzuki et al.’s algorithm by applying
the implicit no-token strategy. In the proposed dynamic
In this section. we discuss an interesting relationship be-
tween the token-based algorithms and non-token-based token-based algonthm, d a site Y has not requested for
algorithms, and describe how we “discovered” the dy- the token since site X executed the CS last time, it im-
namic token-based algorithm based on the observed re- plies that site Y will not hold the token and site identifier
lationship. Y should not be in R,y. In other words, if site Y ac-
quires the token after site X has finished execution of
Although different data structures and methodolo-
the CS recently, site Y may hold the token and its iden-
gies are used in non-token-based and token-based algo-
tifier should be in R,y . This implicit no-token strategy is
rithms (for example, timestamps are used in non-token-
sunilar to the implicit no-Request message strategy used
based algorithms while sequence numbers are used in
in Carvalho et al.’s algorithm [l].
token-based algorithms), an interesting relationship be-
tween non-token-based algorithms (which do not use site Furthermore, Singhal’s dynamic information struc-
ture algorithm [15] has similar strategy to reduce mes-
locking) [ l , 11, 161 and token-based algorithms (which
sage traffic as that m Carvalho et al.’s algonthm. How-
use broadcast communication) [13, 15, 171 has been ob-
ever, in Singhal’s dynamic information structure a
served as shown in Figure 7. For every non-token-based
rithm, the initial value of R s is set to { 1,2, . . ., ( S -
algorithm, apparently there exists a token-based algo-
this algorithm can be considered as a special case of C
rithm with the same initialization of request sets and
valho et al.’s algorithm. Therefore, as Singhal’s dynamic
similar rules to update request sets.
information structure algorithm [16] is a special cas
For example, both Ricart et al.’s non-token-based al-
Carvalho et al.’s algorithm, Singhal’s hemstically-a
gorithm [ l l] and Suzuki et al.’s token-based algorithm
algorithm [ 151 can also be considered as a special c
[I71 use sratic request sets which contain the identi-
of the proposed token-based algorithm presented in Sec
fiers of all other sites in the system; both Singhal’s dy-
tion 5.
namic information structure algorithm [16] and Singhal’s
heuristically-aided algorithm [ 151 use dynamic request
sets which are initializedas R s = (1, 2, - .-,(S-l)}. This
relationship prompted us to search for a token-based al- 7 Conclusions
gorithm which has the same initialization of request sets
and similar rules to update request sets as Carvalho et In this paper, we have proposed a dynamic token-based
al.’s algorithm [l]. That is how we “discovered“ such a mutual exclusion algorithm for distributed systems.
dynamic token-based algorithm. the proposed algonthm, a site invoking mutual exclu
As compared to Ricart et al.’s non-token-based algo- sion sends its requests to a set of sites possibly holdin
rithm [ l l ] , Carvalho et al.’s algorithm [ l ] has avoided the token, instead of to all other sites as in Suzuki
some unnecessary Request and Reply messages by using al.’s algorithm. Therefore, the number of the messag
the implicit no-Request message strategy. In this algo- exchanged is reduced. As compared to Suzuki et al.
rithm, if site X has not received a Request message from algonthm, the proposed algorithm can reduce message
site Y since site X executed the CS last time. it implies traffic by 40% in light traffic, and needs N messages
that site Y is not requesting the CS and has given its (which is the same as Suzuki et al.’s algonthm) in heav
permission to site X. Therefore, site X does not have traffic.

245
 I Non-Toky-Based /
I
r I
Ricart & Agrawala’s
non-token-based
M 1dynamic R ?
f
I dynamic token-based 2 1
I
carvalho &
Roucairol
1 1Rs=[ 1,2,..,S-l]
1
I
Singhal’s
heuristically-aided
I
4 I
Singhal’sdynamic
information structure I
I

B 4-b A : Algorithms A and B have the same initialization of request

sets and similar rules to update the requet sets.

Figure 7: Relationship Between Token-based and Non-Token-based Algorithms

References [9] S. Nishio, K. F. Li, and E. G. Manning, “A Resilient

Mutual Exclusion Algorithm for Computer Network,”
[ I ] 0. S . F., Carvalho and G. Roucairol, “On Mutual Ex- IEEE Tran. on Parallel and Distributed Systems, Vol.
clusion in Computer Networks, Technical Correspon- 1, No. 3, pp. 344-355, July 1990.
dence,” Communications of ACM, Vol. 26, No. 2, pp.
146-148, Feb. 1983. [ 101 K. Raymond, “A Tree-Based Algorithm for Distributed
Mutual Exclusion,“ ACM Trans. on Computer Systems,
[ 2 ] Y. I. Chang, M. Singhal and M. T. Liu, “An Improved Vol. 7, No. 1, pp. 61-77, February 1989.
O(log N) Mutual Exclusion Algorithm”, Prof. of the
19th International conf. on Parailel Processing, vol. 3, [ 111 G. Ricart and A. K. Agrawala, “An Optimal Algorithm
pp. 295-302, Aug. 1990. for Mutual Exclusion in Computer Networks.” Commu-
nications of ACM, Vol. 24, No. 1, pp. 9-17, Jan. 1981.
[3] Y. I. Chang and M. Singhal, “A Correction to
[12] G. Ricart and A. K. Agrawala, “Performance of a Dis-
Maekawa’s V% Mutual Exclusion Algorithm”, Techni-
tributed Network Mutual Exclusion Algorithm,” Tech.
cal Report, Dept. of Computer and Information Science,
Rep. TR-774, Dept. Computer Science, Univ. of Mary-
The Ohio State University, Sept. 1990.
land, College Park, MD. March 1979.
C4i y. I. M. Singhai and M. T. Liu, “A Fault [ 131 G, Ricart and A. K, Agmwala, ”Author’s Response to
Algorithm for Distributed Mutual Exclusion”, Proc. of On Mutual Exclusion in Computer Networks. Techm-
the 9th IEEE Annual Symposium on Reliable Distributed cai Comspondence,” Communications of ACM, Vol. 26,
Systems, pp. 146-154, Oct. 1990. No. 2, pp. 146-148, Feb. 1983.
[ 5 ] Y.I. Chang, M. Singhal and M. T. Liu, “A Hybrid A p [14] B. A. Sanders, “The Information Structure of Dis-
proach to Mutual Exclusion for Distributed Systems”, tributed Mutual Exclusion Algorithms.” ACM Trans. on
Proc. of the 14th Annual International Computer SOB- Computer Systems, Vol. 5 , No. 3, pp. 284-299, August
ware and Application Conference, pp. 289-294, Oct. 1987.
19W.
[ 151 M. Singhal, “A Heuristically-Aided Algorithm for Mu-
[6] Y. I. Chang, M. Singhal and M. T. Liu, “A Deadlock- tual Exclusion in Distributed Systems,” IEEE Trans. on
Free O(-) Mutual Exclusion Algorithm for Dis- Computers. Vol. 38, No. 5 , pp. 651-662, May 1989.
tributed Systems”, to appear in the Proc. of the lnter-
national Computer Symposium, Dec. 1990. [ 161 M. Singhal, “A Dynamic lnformation Smcture Mutual
Exclusion Algorithm for Distributed Systems,” Proc. of
[7] L. Lamport, “Time, Clocks and Ordering of Events in the 9th International Conf. on Distributed Computing
Distributed Systems,” Communications of ACM, Vol. Systems, pp. 70-78, June 1989.
21, NO. 7, pp. 558-565, July 1978.
[17] I. Suzuki and T. Kasami, “A Distributed Mutual Ex-
[8] M. Maekawa, “A v% Algorithm for Mutual Exclusion clusion Algorithm,” ACM Trans. on Computer Systems.
in Decentralized Systems,” ACM Trans. on Computer Vol. 3, No. 4, pp. 344-349, Nov. 1985.
Systems, Vol. 3, No. 2, pp. 145-159, May 1985.

246