a two-layer hierarchical permission based mutual exclusion algorithm

8/13/2019 A Two-Layer Hierarchical Permission Based Mutual Exclusion Algorithm

1/7

A Two-Layer Hierarchical Permission Based Mutual Exclusion Algorithm

Mohammad Ashiqur Rahman , Md. Mostof a Akbar , Mohammad Shafiul Alam Dept. of Computer Science and Engineering, Ahsanullah University of Science and Technology, Dhaka.

Dept. of Computer Science and Engineering, Bangladesh University of Engineering and Technology, [email protected], [email protected], [email protected]

Abst ract Due to the growing application of peer-to-peer comput-ing, the distributed applications are continuouslyspreading over extensive number of nodes. To cope withthis large number of participants, various cluster basedhierarchical solutions have been proposed. Clusterbased algorithms are scalable by nature. Several ofthem are quorum based solutions. All of these solutionsexploit the idea of coordinator/leader of cluster. Thus,

fault tolerance of these algorithms is low. If any coordi-nator fails, election of new one is required. Here we

propose a two-layer hierarchical cluster based solutionwhere no coordinator is used. We simulate our pro-

posed algorithm and show that it outperforms related ME algorithms.

Keywords : Cluster, Distributed Algorithm, Hierarchi-cal, Mutual Exclusion, Permission, Quorum.

I. INTRODUCTION

In distributed systems, different processes run on differ-ent nodes of a network and they often need to accessshared data and resources, or need to execute somecommon events. These processes should be consistent,and the access to these shared entities should be mutu-ally exclusive. The portion of an event or application,where any shared component or common events areaccessed, is the Critical Section (CS). Mutual Exclusion(ME) algorithms ensure the consistent execution of theCS. As the shared memory is absent in distributed sys-tems, the solutions of the ME problem is not straight-forward. Due to the enormous importance of ME andthe difficulty of its solution, it is an active research area

since last three decades. The classic algorithms for Mu-tual exclusion that have been proposed for fixed net-works can be classified in two types: centralized anddistributed approaches. In the centralized solutions, anode is designated as coordinator to deliver permissionto the other nodes to access the CS, while in the distrib-uted solutions the permission is obtained from consen-sus among all network nodes.Distributed mutual exclusion algorithms are generallyclassified in two categories: token based and permission

based [18]. Permission based mutual algorithms [4][7]impose that a requesting node must receive permissions

from other nodes (a set of nodes or all other nodes) toaccess the CS. In the token-based mutual exclusion al-

gorithms [1][3], a unique token is shared among the setof nodes. The node holding the token can enter the CS.The basic idea of token based algorithms is: a nodemust own the unique token before entering the CS. So,in the best case, no communication is necessary sincethe token may be available locally. Otherwise, a mecha-nism is needed to locate the token. In Raymond [1], aspanning tree of network for locating the token is usedand it shows that the average number of messages ex-changed in this protocol is O(log n ). But if the nodeholding the token fails, expensive token regeneration

protocols [17] must be executed. Nisho presented ahighly resilient, though still complex, token based mu-tual exclusion algorithm [2]. Naimi proposed an algo-rithm [3] that takes O(log n) cost too.Ricart and Agrawala proposed the first permission

based algorithm [4] in 1981, which takes 2(n 1) mes-sages for a node to get consensus. To access the CS anode sends request to all other n 1 nodes in the networkand then waits for the replies from them. When it re-ceives all the replies, it enters into the CS. A node sendsreply against a request only if it is earliest than anyother requests, otherwise it defers the request. As con-sensus from every node is required, this algorithm suf-fers due to high message cost and node and communica-tion failures.Concept of quorum improves the performance of per-mission-based algorithms to a great extent. In quorum

based algorithms, to achieve mutually exclusive accessof the CS, a node needs to have permissions from all ofthe nodes of a quorum. This kind of algorithms takeslower message cost and is resilient to node and commu-nication failures. Message cost of these algorithms is

proportional to the quorum size. Therefore these algo-rithms try to achieve the two goals: small quorum sizewith high degree of fault tolerance.The majority quorum algorithm [15] is the first and avery simple algorithm of this kind. According to thisalgorithm, a node must obtain permission from a major-ity of nodes in the network. Since there can be only onemajority at any point, ME is achieved easily. Maekawa

presented an ME algorithm [5] by forming a logicalstructure on the network. In this scheme, a set of nodesis associated with each node, and this set has a non-empty intersection with all sets corresponding to theother nodes. As the size of each set is n, the algorithmincurs n order of cost.


2/7

Garcia-Molina and Barbara [16] have properly definedthe concept of quorums with the notion of coterie . Acoterie is a set of sets with the property that any twomembers of a coterie have a nonempty intersection.Combining the idea of logical structures and the notionof coteries, an efficient and fault tolerant quorum gen-eration algorithm for ME is proposed by Agarwal andAbbadi [6]. Here the nodes form a logical binary tree togenerate quorums. The quorum can be regarded as at-tempting to obtain permissions from nodes along aroottoleaf path. If the root fails, then the obtaining

permissions should follow two paths: one roottoleaf path on the left subtree and one root-to-leaf path on theright subtree. This algorithm tolerates both node failuresand network partitions. In the best case, this algorithmincurs logarithmic cost considering the size of the net-work. However, the cost increases with the increase ofnode failures.At present, the number of distributed nodes has becomevery large. With the increasing importance of peer-to-

peer computing [23] as well as grid computing [24], thedistributed applications have been extended over a largenumber of nodes. The performance of these distributedapplications depends on the number of participatingnodes. Classical ME algorithms illustrated above do notconsider these matters. Hence, we need scalable algo-rithms that reduce the number of participating nodes.Sometimes the nodes in a network are divided into sev-eral groups where each group is often called a cluster.According to this concepts some hybrid ME solutions

[8] [9] are proposed. Actual goal of these proposed al-gorithms was to combine two different approaches indifferent layers, intra-group (lower layer) and inter-group (upper layer). Two distributed ME solutions are

presented by Erciyes [10] using a logical structure,where clusters are arranged on a ring. Bertier et al. pro-

posed two token-based algorithms in [11] taking intoaccount the hierarchical network topology, which re-duce both latency cost and number of message. Thesethree solutions are modification of Naimis token-basedalgorithm [3] for proxy-based cluster. As these algo-rithms are basically token based, they suffer due to to-

ken failure. A two-layer permission based algorithm is presented by Rahman et al. in [12], where the coordina-tors (named as message routers) of the clusters form theupper layer. For quorum formation, tree-quorum algo-rithm [6] is used in each layer of the algorithm. Rahmanand Akbar extended this algorithm in [13] for multi-level clustered network. However, the main problem ofthese algorithms [12] [13] is the failures of coordina-tors. Any failed coordinator has to be replaced using aleader election algorithm, which incurs extra cost.In this paper, we propose a cluster-based two-layer dis-tributed ME algorithm that uses no specific coordinator

for a particular cluster, but improves the performance by reducing participating nodes. Fault tolerance of our

proposed solution is much higher than the algorithm ofRahman et al. [12] and incurs less communication costespecially when failures occur. We also choose tree-quorum algorithm for selecting quorums in both of thelayers, so that we can compare the performance of ouralgorithm with that of Rahmans algorithm. In SectionII we describe the proposed network. Our proposedsolution along, its proofs of correctness and livenessand analysis for optimality are presented in Section III.

Next section includes the simulated comparison of thealgorithm especially with Rahman et al. Finally a con-clusion is given.

II. PROPOSED NETWORK

A. Descr ipti on of the EnvironmentWe consider an asynchronous distributed system, whichfollows the model proposed in [20]. Each pair of nodesis connected through a communication channel. Linksmay fail causing intermittent message drop. The mes-sage delays for communication and processing are fi-nite. No assumption is made for the relative speeds ofthe nodes. A node may fail by stopping or crashing, inaccordance with fail-stop model [19]. However, a failednode may restart afterwards (after a reasonably longtime), which will be referred as recovery. When a proc-ess fails, it loses all its states. However, it may use localstable storage to save some information (that neverchanges throughout the execution of the algorithm), sothat it can retrieve them later for proper execution of

ME algorithm.

B. Networ k Archit ecture

b a d

c

Fig. 1. Network architecture of the proposed algorithm

The nodes in a network are partitioned into several non-intersecting groups. Each group is called a cluster. Thenodes inside the clusters form the lower layer of nodes.Though any number of arbitrary nodes forms the next(upper) layer, as a matter of guideline, from each of theclusters an arbitrary node is taken for the upper layer.Thus, the number of nodes of this layer is equal to thenumber of clusters. The upper layer can be consideredas a single cluster. In Fig.1, C l,1, C l,2, C l,3 and C l,4 arefour nonintersecting lower layer clusters. Four nodes a,

b, c and d, taken from each of the lower layer clustersrespectively, form the upper layer cluster C u, which isonly cluster of the upper layer. Note that, each node is a

a b

c

d

C l,1 C l,3C l,2

C u

C l,4


3/7

member of a lower layer cluster; so each member of theupper layer cluster is also a member of one of the lowerlayer clusters.Each node knows the members of its lower layer clusteras well as the members of the upper layer cluster. As thememberships to the clusters remain unchanged through-out the program, a node keeps this information in stablestorage, so that it can retrieve this data after recovery.

III. PROPOSED ALGORITHM

A. Brief Outl ineTwo layers of nodes participate in our proposed algo-rithm: the members of a lower layer cluster and themembers of the upper layer cluster. A coordination al-gorithm, as in [12] [13], communicates between thesetwo layers of executions. In both layers, we use the tree-

quorum algorithm [6] for quorum creation. When anode x wants to access the CS, first it requires to havethe consensus from the nodes inside its lower layer clus-ter. When x gets permission at this layer, it needs tohave permission from the upper layer. To get this per-mission, x selects an arbitrary node y among the mem-

bers of the upper layer cluster as its representing node .To y, x is identified as the represented node . At the up-

per layer y executes the ME algorithm on behalf of x. If y gets consensus from the members of the upper layercluster, it informs x about the consent. At this point, thenode x has the total consensus, i.e., permissions from

both layers, and can use the CS safely. We apply classi-cal quorum based ME algorithm [5] [6] inside a clusterfor collecting consensus.

B. Messages and StatesAs we apply quorum based ME algorithm inside theclusters, our ME algorithm uses Request , Reply , Re-lease , Inquire and Yield messages. Since some nodesare members of two clusters of both layers, Layer No isadded to the contents of these messages to identify thelayer (i.e., the cluster) of executing ME algorithm. Pos-sible values of Layer No are only 0 and 1, which iden-

tify the upper layer and the lower layer respectively.The communication between the CS requesting node,a member of a lower layer cluster, and its representingnode, a member of the upper layer cluster, is donethrough Layer_Request , Layer_Reply and

Layer_Release messages, similar to [12, 13]. Functionsof these messages are briefly described below:

When a node x gets the consensus from aquorum of its lower layer cluster, it sends a

Layer_Request message to an arbitrary node y, its representing node, to process the re-quest in the upper layer cluster.

If y receives consensus inside the upperlayer cluster, it sends a Layer_Reply mes-

sage to x.

In order to release the consensus in the upper layer x sends a Layer_Release messageto y.

Timestamp, a global logical time [14], consists in eachmessage and denotes the time of sending the message.This timestamp is crucial for Request message. As mul-tiple requests can come from different nodes to a singlenode, a node often needs to keep them in a queue to

process afterward. A node keeps the incoming Request messages in a minimum priority queue, be identified asQUEUE, according to their timestamps. If timestampsof two Request messages are equal, then node identifi-cation numbers are used for this determination. Thisordering is crucial for avoiding deadlock and starvation.A member node of the upper layer cluster also main-tains a normal first-in first-out queue, be identified asFIFO, for Layer_Request messages.Different nodes participate in the algorithm. At an in-stant, a node, according to its role, owns a state. Assome nodes play at both layers, they possess same ordifferent states at these two layers. To represent the

proposed system, we define following arrays of states,where each element of an array represents the state ofthe corresponding node at a particular layer. Size ofeach array is only two with 0 and 1 indices: 0 for theupper layer and 1 for the lower layer. REQUESTING [01]: A node set this state to true

if it sends Request messages to its fellow nodes(members of its cluster).

LOCKED [01]: This state is set to true when anode sends Reply to a fellow REQUESTING node.Latter node is the locking node of the former.

BUSY [01]: When a requesting node of the upperlayer (Layer 0) cluster gets consensus from its clus-ter, its BUSY [0] state becomes true. In case of thelower layer (Layer 1), when a requesting node of alower layer cluster gets consensus from its clusteras well as from the upper layer cluster, its BUSY [1]state is set to true.

INQUIRING [01]: When a LOCKED node wantsits consensus back, it sends an Inquire message toits locking node. At this point, the node sets the

INQUIRING state to true.State LAYER_REQUESTING is also defined for thenodes of the lower layer cluster. When a requestingnode of a lower layer cluster gets necessary consensusfrom its cluster, it sends a Layer_Request message to itsrepresenting node. At this time, its

LAYER_REQUESTING state is set to true. Initially, allthe states are false. We will use a state is set or similarlanguages to mean that the state is set to true. Similarly,we will use a state is unset to mean that the state isfalse and a state is reset to mean that the state is set tofalse.


4/7

C. AlgorithmIn order to obtain consensus, a requesting node requiresconsensus from two separate quorums. Firstly, the re-questing node forms a quorum in its lower layer clusterand seeks consensus from the quorum. Next, its repre-senting node seeks consensus by forming a quorum inthe upper layer cluster.A node, if its LOCKED state is unset, chooses the Re-quest message at the head of its QUEUE and sends a

Reply message, as its consensus, to the requesting nodeand sets its LOCKED state. Once a node exits from itscritical section, it sends Release messages to all nodesof the lower layer quorum and, through the representingnode, to all nodes of the upper layer quorum. After get-ting the release message, a node resets its LOCKED state and chooses another request residing at top of itsQUEUE, if it is not empty, for next processing.The following points briefly describe our proposed al-gorithm: Requests for the CS are generated at lower layer

clusters. These requests are processed sequentiallyin both layers. The clusters C l,1 and C u in Fig. 1, forexample, represent the participating clusters, if anode of C l,1 places a request for the CS.

The CS requesting node x first executes ME algo-rithm in its lower layer cluster C l. It selects a quo-rum q l and sends a Request message to each of thequorum members. Now, its REQUESTING [1] stateis set. When x receives Reply messages from allmembers of q l, it has the consensus in this layer.

Now it picks an arbitrary node y (as representingnode) from the members of the upper layer clusterC u and sends a Layer_Request message to y. At this

point, xs REQUESTING [1] state is reset and LAYER_REQUESTING state is set.

When y gets Layer_Request from x (as representednode), it queues the message into its FIFO, if it isalready processing another Layer_Request (i.e., anyof its states at this layer is true). Otherwise, it se-lects a quorum qu inside C u and executes ME algo-rithm on behalf of x. Its REQUESTING [0] state isset at this stage. When y gets Reply messages fromall qu members, it has the consensus in C u. Now itresets REQUESTING [0] state and sets BUSY [0]state and sends a Layer_Reply message to x.

When x receives the Layer_Reply message from y,it has the total consensus, i.e., permissions from

both layers, and so it resets its LAYER_REQUESTING state and sets its BUSY [1]state and executes the CS. In this way, a node mu-tual exclusively enters the CS. After execution ofthe CS, x resets its BUSY [1] state and sends Re-lease messages to the members of q l. At the sametime, it also sends a Layer_Release message to y.

When y gets Layer_Release from x, it resets its BUSY [0] state and sends release messages to the

members of qu. If there is one or more Layer_Request message in ys FIFO, y will take outone from the FIFO and will start processing by se-lecting a quorum q / u inside C u.

Inquire and Yield messages works to avoid deadlock,similarly as in [6, 12, 13]. Let a node u receives a re-quest from node v that possesses an earlier timestampthan its currently processing request of a node w, towhich it has already sent Reply message. Then u putsthe request of v into QUEUE and sends an Inquire mes-sage to w and waits for either a Yield or Release mes-sage from w. At this time, its LOCKED state is reset and

INQUIRING state is set. When w receives the Inquire message from u, it relinquish the consensus of u as wellas sends a Yield message to u if and only if it has notreceived all replies from its requesting quorum mem-

bers. If w has already acquired all necessary replies toaccess the CS and may be already executing the CS,then it simply ignores the Inquire message and proceedsnormally, that is, it continues to execute the CS. Afterfinishing the execution, it sends a Release message tothe inquiring node u. When u receives the Yield mes-sage, it resets it INQUIRING state and puts back therequest of w into its QUEUE. Now it pop out the re-quest from the top of QUEUE and accordingly sends a

Reply message to corresponding node and gets into LOCKED state again. In the mean time, if no requestwith the earlier timestamp has come, the Request of y isthe selected request message. If u receives Release mes-sage instead of Yield message from w, it does the same

except reinserting the request of w into QUEUE, sincethe request has been served.

D. Proofs

D. 1. Correctness

A mutual exclusion solution is said to be correct if nomore than one node gets simultaneous access to the CS.For quorum based algorithms, this condition holds, ifthere is at least one common node between any twoquorums. In our proposed two-layer ME solution, wemust get consensus at each layer: in a lower layer clus-

ter and in the upper layer cluster. So, a quorum of oursolution can be defined as , where and

are the quorums formed respectively with the mem-

bers of a lower layer cluster and with the members ofthe upper layer cluster.

ul qqq = lq

uq

Similarly, another quorum could be , where

and are the quorums respectively of a lower

layer cluster and of the upper layer cluster. Now,

ul p p p =

l p u p

)()( uull q pq pq p =

Here, uu q p , since these are the quorums selectedfrom the members of the same cluster, the only clusterof the upper layer, and these are formed according tothe tree-quorum algorithm, which ensures the intersec-


5/7

tion between any two quorums. So, we get q p .Thus, the solution must maintain mutual exclusion foraccessing the CS.

D. 2. Liveness

To prove the liveness, we need to show that each re-quest is served within a finite period. Let the C nodes ofa cluster be N 1, N 2, , N C . Consider the worst casescenario where the requests from each of the fellownodes are queued at N p. The timestamp of the queuedrequest of N i at N p are T i, where 1 i C . The requestsent by N m contains the maximum timestamp. Thus,T current > T m > T i, where T current is the current time and

. Let, the timestamp of the next request comingfrom N

mi

j (after completion of its earlier request with

timestamp T j) is denoted by . Definitely,

T

next jT

next jT

current . Hence, > T next

jT m. Therefore, the request from

N m will be served in a finite duration (after C 1 out-standing requests are served) as it has the earlier time-stamp than the next group of requests. So, any requestof a node in a cluster of the lower layer or the upperlayer must be served in a finite period.In our two-layer architecture, a requesting node musthave consensus at both layers. After getting consensusfrom its lower layer cluster, the node asks (by sending a

Layer_Request message) its representing node to collectconsensus in the upper layer cluster. Since the repre-senting node processes the Layer_Request messages inFIFO manner, every Layer_Request will be processed ina finite time. Again, as the request of the representingnode in the upper layer cluster must be served, ulti-mately the request is served in both layers within a fi-nite period. So, liveness is proved.

E. Optimal Cluster SizeTo find the optimal cluster size of the proposed solu-tion, we do analysis in this section considering the tree-quorum algorithm [6] that is applied for quorum forma-tion. According to the tree-quorum algorithm, the ex-

pected quorum size for a network with size n is ex- pressed as )2)(1()1( 11 ++= hhh c f c f c , where f denotes the fraction of the quorums that include the rootof the binary tree with height h, while h is approxi-mately log n 1. So, f is the probability of the root to beincluded in the quorum, when all the quorums areequally probable. As we assume that the root is includedin the quorum if it is available, f is equivalent to the

probability of the root being available. In the recursiveequation of expected quorum size, each node becomesthe root of a subtree in a particular level of the tree.Therefore, f denotes the probability that a node is avail-able at a particular instant, simply, the availability of anode. The average number of messages needed againsta single request of a node to enter the CS is proportionalto quorum size. Thus , expected quorum size, repre-

sents message cost function. Solving this recurrence,following equation is found:

hc

=+

=

1 when ,1

1when,1

)2(

f h

f f

f h f c h

In our algorithm, there are participating clusters in twolayers: a lower layer cluster and the upper layer cluster.We consider two parameters: n, the number of nodes inthe network and C , cluster size of each lower layer clus-ter. Therefore, the number of lower layer clusters is n/C and this is the cluster size of the upper layer cluster. Theheight of the tree formed by the nodes inside a lowerlayer cluster is 1log = C hl . Thus, the height of the tree

formed by the nodes of the upper layer clusteris 1= lu hhh . Now, the total message cost of the

proposed solution is:

c = lhc + uhc + 1

Here, lhc and are the message costs at the lowerlayer and the upper layer respectively and lastly 1 isadded for the representing node. Hence,

uhc

11

)2(1)2( 11 1 +

+

=

f f f

f f f

chhh

Taking the derivative of c with respect to h l and equat-

ing it to zero, we get nC = as the condition of opti-mality.

IV. SIMULATION

We simulate our proposed ME algorithm usingPARSEC [21], which is a parallel Cbased discrete event simulation language. The aim of the simulation isto compare the performance of our algorithm with thatof Rahman et al. [12]. For comparison message cost istaken as the performance metric. Message Cost is theaverage message complexity per request to enter intothe CS, i.e., the average number of messages requiredfor a node from request placing to getting consensus inorder to execute the CS.

A. Si mu lat io n Envi ro nment

Our simulation is executed on a peer-to-peer networkhaving an arbitrary number (up to 1200) of nodes ran-domly spread over the network. The network is as-sumed to ensure the ordered delivery of messages be-tween a source and a destination. Communication la-tency between two specific nodes is taken constant. Thetimes for message communication and message prepara-tion/processing follows normal distribution with a meanof 12 and 8 time units respectively and a common vari-ance of 50% of the mean. A node requests for the CSfollowing a Poisson process with 0.0000002 request(arrival) rate. Node failures are modeled as a Poisson

process with a failure rate calculated from the value of f and the recovery time. Recovery time is an exponential


6/7

distribution with a mean of 1000000 time units.In the simulation, initially we form the clusters arbitrar-ily according to the optimal cluster size and select thenodes of the upper layer cluster by taking a randomnode from each cluster. Elections of the message routersare not simulated for [12]. Rather, a cost (both time andmessage) is assumed according to a leader election al-gorithm [22].

B. Performance Comparison

800

12001300

6 7 7 2 7 7 8 0 5 0 5 3 5 5 5 7

950

0

400

800

1200

1600

600 800 1000 1200 Number of Nodes ( n )

M e s s a g e

C o s

t

Algorithm of Agarwal and AbbadiAlgorithm of Rahman et al.

Newly Proposed Algorithm

(a)

3 5 8 0 1 0

8 1 8 8

3 5 5 7 7 6 1

2 7 3 6

3 8 0

1300

4200

0

1000

2000

3000

4000

5000

1 0.9 0.8 0.7

Node Availability ( f )

M e s s a g e

C o s

t

Algorithm of Agarwal and Abbadi

Algorithm of Rahman et a l.

Newly Proposed Algorithm

(b)

Fig. 2. Message cost of ME algorithms for (a) different n with f =0.9 and (b) different f with n=1200.

Message costs per CS entry for the classic tree-quorum based ME algorithm of Agarwal and Abbadi [6], thetwo-layer ME algorithm of Rahman et al. [12] and our

proposed two-layer ME algorithm are plotted in Fig.2(a) and 2(b) against different network sizes ( n) anddifferent availability of nodes ( f ) respectively. Both ofthe figures show that our algorithm simply outperformsthe others especially when f decreases. According to thetree-quorum algorithm, the quorum size is inversely

proportional to the value of f and varies from (for

high values of f ) to

V log

2V (for low values of f ), where V is

the number of participating nodes. Both of the two-layeralgorithms reduce this size of participating nodes to C ,i.e., n , while the participating nodes in the classical

algorithm is n. So, both algorithms outperforms the lat-ter when f


7/7

ternational Conference on Computer Systems and Applications , June 2001, pp. 253259.

[10] K. Erciyes, Distributed Mutual Exclusion Algo-rithms on a Ring of Clusters, ICCSA, SV-Lecture

Notes in Computer Science, 2004.[11] M. Bertier, L. Arantes and P. Sens, Distributed

Mutual Exclusion Algorithms for Grid Applica-tions: a Hierarchical Approach, Journal of Paral-lel and Distributed Computing (JPDC) , Elsevier,Vol. 66, 2006, pp. 128-144.

[12] Mohammad Ashiqur Rahman, Mohammad ShafiulAlam, M. M. Akbar, A Two Layer Quorum BasedDistributed Mutual Exclusion Algorithm, The 9th

International Conference on Computer and Infor-mation Technology (ICCIT) , December 2006.

[13] Mohammad Ashiqur Rahman, M. M. Akbar, AQuorum Based Distributed Mutual Exclusion Algo-rithm for Multi-Level Clustered Network Architec-ture, Workshop on Algorithms and Computation(WALCOM), Dhaka , February 2007.

[14] L. Lamport, Time, clocks, and the ordering ofevents in a distributed system., Communicationsof the ACM , Vol. 21, No. 7, July 1978, pp. 558-564.

[15] R. H. Thomas, A majority consensus approach toconcurrency control, ACM Transaction on Data-base System , Vol. 4, No. 2, June 1979, pp.180-209.

[16] H. Garcia-Molina and D. Barbara, How to Assignvotes in a Distributed System, Journal of the As-sociation for Computer Machinery , Vol. 32, No. 4,1985, pp. 841-860.

[17] J. Misra, Detecting termination of distributedcomputations using markers, Proceedings of the2nd ACM Annual Symposium on Principles of Dis-tributed Computing , 1985, pp. 237249.

[18] M. Raynal, A simple taxonomy for distributedmutual exclusion algorithms, ACM SIGOPS Op-

erating Systems Review , Vol. 25, No. 2, 1991, pp.47-50.

[19] R. D. Schlichting and F. B. Schneider, Fail-stop processors: an approach to designing fault-tolerantcomputing systems, ACM Trans. on ComputingSystems , Vol. 1, No. 3, 1983, pp. 222238.

[20] F. Cristian and C. Fetzer, The timed asynchronousdistributed system model, IEEE Transactions onParallel and Distributed Systems , Vol. 10, No. 6,1999, pp. 642627.

[21] R. Bagrodia, R. Meyerr, and et al., PARSEC: a parallel simulation environment for complex sys-tem, UCLA Technical Report , 1997.

[22] Scott D. Stoller, Leader election in asynchronousdistributed systems, IEEE Transactions on Com-

puters , Vol. 49, No. 3, 2000, pp. 283284.[23] R. Steinmetz and K. Wehrle, Peer-to-Peer Systems

and Applications, Lecture Notes in Computer Sci-ence , Vol. 3485, 2005.

[24] Buyya and Rajkumar, Grid Computing: Makingthe Global Cyber-infrastructure for e-Science a Re-ality. CSI Communications , Vol. 29, No. 1, 2005.

a two-layer hierarchical permission based mutual exclusion algorithm

Documents