Maintaining a Dynamic Set of Processors in a ... - Semantic Scholar

Maintaining a Dynamic Set of Processors in a Distributed System Satoshi Fujita1 and Masafumi Yamashita1 Faculty of Engineering, Hiroshima University Kagamiyama 1-4-1, Higashi-Hiroshima, 739, Japan

Abstract. Consider a distributed system consisting of a set V of processors, and assume that every pair of processors can directly communicate with each other. A processor structure is proposed, for implementing a dynamic set U  V of processors in the distributed system. The dynamic set supports the following three operations: Insert inserts the caller (i.e., the processor executing this operation) in U , Delete removes the caller from U , and Find searches for a processor in U . To evaluate the eciency of the implementation, an amortized analysis of the message complexity of operations is performed; the amortized number of messages per each operation is 8 + 12 log 2 (jV j ? 1), in the worst case. The dynamic set is applicable to many important problems, including the load balancing problem, and the proposed processor structure is used to solve the mutual exclusion problem, and to construct a more complex dynamic set of processors like FIFO queue. Keywords: processor structure, data structure, dynamic set, amortized message complexity, group communication

1 Introduction Developing algorithms to manipulate dynamic sets is an essential part of designing time ecient algorithms, and therefore, many data structures that can be used to eciently implement dynamic sets have been proposed. Dynamic set manipulations are very important in designing ecient distributed algorithms, also. As in sequential algorithms, many distributed problems can be solved eciently by accommodating key information in a dynamic set to share and manipulate it among the processors. For example, the load balancing problem is reducible (in part) to the problem of searching processors for an idle one; i.e., to the problem of manipulating a \dictionary"1 that accommodates currently idle processors. If a (FIFO) \queue" can be manipulated eciently, the distributed mutual exclusion is easily solvable by accommodating requests for entering the critical section in the queue. Since a dynamic set is 1

A dictionary is a dynamic set supporting three operations, Insert that augments the dynamic set with a speci ed element, Delete that removed a speci ed element from the dynamic set, and Search that returns an element in the dynamic set with a speci ed key, or a special value nil if no such element belongs to the dynamic set.

shared by the processors, it can be manipulated by plural processors, and data in the dynamic set may look to change autonomously (for some processors, or even they may not notice the change). Algorithms to manipulate the dynamic set must be designed so that they work eciently and correctly under those situations. In designing distributed algorithms, logical structures of processors, which we simply call processor structures , have been used to reduce the communication complexity. For example, a spanning tree of the underlying communication network is used to design broadcast and information collection algorithms. If each processor can tell which local ports correspond to tree edges of the spanning tree, both broadcasting and collecting information are eciently achieved by owing information along tree edges. Important applications of ecient broadcast and collection algorithms include the leader election problem (e.g., the extrema nding problem), and the problem of constructing the minimum spanning tree was rst discussed in this context [1, 3, 5, 7]. An in-tree is another useful structure and is used to solve the mutual exclusion problem [2, 10, 11] and the decentralized object nding problem [4]. In this paper, we propose an idea of implementing dynamic sets by processor structures. To show that our idea is promising, we propose a processor structure that can be used to eciently implement a dynamic set that supports the following three operations:

{

: This operation inserts the processor executing the operation, i.e., caller, in the set as a new element. { : This operation removes the caller from the set. { : This operation returns the identi er of a processor in the set, or a special symbol Fail if the set is empty. This dynamic set is slightly simpler than dictionary, but can be used to solve many problems, including the load balancing problem. The proposed implementation of this dynamic set is very ecient; the amortized message complexity per operation is 8 + 12 log2(jV j ? 1) in the worst case. The analysis is based on the amortized analysis invented by Ginat et al [6]. The main idea of our processor structure is to maintain a dynamic set U of processors in a form of a distributed circular list: Each processor has a local register to store the next pointer to the \next" processor. We naturally identify the distributed system with a directed graph G; the node set is the set of processors, and there is a directed edge from u to v i the next pointer of u points to v. Dynamic set U is maintained in such a way that all processors in U are contained in a unique directed cycle C in G, and that G ? C are in-trees, each of whose sink has the next pointer to a processor in C. Cycle C may contain processors not in U, since is simply implemented by marking the processor executing in most of the cases. Actual removal of marked processors from C will be done later, when either or is executed. and executed by a processor not in C, say u, follow the directed path starting with u, until it encounters a processor in cycle C, say v, Insert

Delete Find

Delete

Delete

Find

Insert

Find

Insert

and for , u and v update the next pointers so as to insert u as the next processor of v. The message complexity of those operations therefore mainly depends on the length of the directed path the executing processor traverses. To shorten the length of the traversed path, in the proposed processor structure, we adopt the heuristic of path compression used in the Union-Find algorithm [8]. The processor structure proposed in this paper can be used to solve important problems besides to implement the dynamic set in this paper: To solve the mutual exclusion problem, we circulate a single token along C and regard it as a token ring system. We can use it to implement a more complex dynamic set like a queue. The paper is organized as follows. In Section 2, we propose a processor structure for implementing the dynamic set de ned in this section. In Section 3, we show several applications of our processor structure. Section 4 concludes the paper with future problems. Insert

2 The Processor Structure 2.1 The Model In what follows, we call a processor a node, since we will identify a distributed system with a directed graph with the node set being the set of processors (in the sense we explained in Section 1). Consider a distributed system with a node set V = f0; 1; . . .; n ? 1g. There is a communication link between each pair of nodes in V , so that they can directly communicate with each other. Each link is FIFO in the sense that messages are received in the order they are sent. We assume that the processors and links are reliable. Let U  V be a dynamic set of processors that we implement in the distributed system. Set U supports the three operations and de ned in Section 1. In the rest of this section, we rst present a processor structure for implementing U, then show its correctness, and nally evaluate its eciency. Insert, Delete

Find

2.2 Local Registers Our processor structure uses some local registers. In this subsection, we introduce them. Each node v 2 V has a local register nextv to store the next pointer that points to a node in V . (We use two more local registers tokenv and markv . We explain about them later.) The node pointed by nextv is called the next node of v. By associating a directed edge from v to nextv with each ordered pair (v; nextv ), we naturally obtain a directed graph G, in which every node has exactly one outgoing edge. Figure 1 illustrates an example of G, in which, for example, node 1 points to node 3 (i.e., next1 = 3) and node 3 points to node 6 (i.e., next3 = 6). Graph G is dynamic in the sense that its edge set dynamically changes, as nodes update their local registers.

'$'$'$ &% &% &% '$ '$ '$ '$ &%&%&%&% circular list C

1

3

6

-

5

-

2

-

6



?4

7



Fig. 1. A graph G representing the relation de ned by the next pointers. In our processor structure, the corresponding graph G is always kept connected. It therefore consists of a unique directed cycle C and a set of in-trees whose sink points to a node in C, since every node in G has exactly one outgoing edge. Further, circular list C is maintained so as to include all nodes in U. That is, we maintain U in C. As you will see, C may contain nodes not in U, since, in many cases, only marks the caller (in C) to distinguish it from the nodes in U and the actual removal process from C is postponed until or is executed. A local register ( ag) markv is used to memorize whether v is marked or not. That v 2 U i markv = 0 is intended to hold. When the processor structure is initialized, we appoint a single node in C to be the anchor . The anchor works as the arbiter, and breaks a symmetric situation occurred in C, which may cause a deadlock or a starvation. The anchor, however, is not a xed node, but the role is taken over from one node to another. More clearly, we circulate a token along C, and the node having the token acts as the anchor. A local register ( ag) tokenv is used to memorize whether or not v has the token. That v is the anchor i tokenv = 1 is intended to hold. The anchor is not marked unless U = ;. If the current anchor executes , it rst sends the token to another node in U, and then marks itself. The anchor is used to check whether U = ; or not. Delete

Find

Insert

Delete

2.3 Primitive Operations The processor structure is initialized as follows. We assume that initially U = V holds. Hence initially, markv = 0 for each v 2 V . Local register nextv is initialized to nextv := v + 1 (mod n) for each v 2 V , i.e., the corresponding

procedure FindNode begin

f For initiator v. g

S := ;; f Nodes to be contracted. g w := nextv ;

repeat

end

Send(inquire; w); Receive(M; w); if M = skip me(nextw ) then S := S [ fwg and w := nextw until M = found(nextw ; tokenw ; markw ); return w;nextw ; markw and S

Fig. 2. Procedure FindNode. G is a single directed cycle. The token is initially given to node 0 (2 V ). Hence, initially, tokenv = 1 i v = 0. In the following, we present three procedures , and that are implementations of the corresponding operations. Those procedures are assumed to be executed as atomic ones, in the sense that once the execution starts, the processor is dedicated to execute it until it nishes. The only exception is the case in which is initiated by the anchor; the anchor may need to handle messages that before nishes, to avoid possible deadlocks. The procedures are described in a Pascal-like language. Note that comments are enclosed by `f' and `g'. Find

Insert

Delete

Delete

Delete

(A) Procedure

FindNode

We rst present a procedure that is used as a central subroutine in the implementations of the three operations. When a node v calls , it returns w; nextw ; tokenw ; markw and S, where w is either the rst node in U appeared in the unique directed path from v (if U 6= ;), or the anchor node (otherwise). Let Pv (G) denote the directed path in G connecting from v to w. In , variable S is used to store the set of nodes appeared in Pv (G), excluding v and w, and is used to apply the heuristic of path compression later. If returns markw = 1, w is the anchor since does not nd a node in U, and therefore U = ; since the anchor is marked. is given in Figure 2. Each node u on the path traversed, upon receiving a message M 0 from v, responds as in Figure 3. All nodes u traversed by block themselves until a further instruction (message) arrives from v, which will be issued in the procedure that calls as a subroutine. Note that for the simplicity of description, v may send or receive a message to or from v itself. In this case, we assume that v behaves like u (without actually exchanging messages), except that v does not block itself. FindNode

FindNode

FindNode

FindNode

FindNode

FindNode

FindNode

FindNode

(B) Procedure

Find

Case M of inquire: begin if marku = 1 and tokenu = 0 then 0

f if u 62 U and u is not the anchor g

end;

Send(skip me(nextu ); v) and block the execution of u until it receives message contract from v else f if u 2 U or u is the anchor g Send(found(nextu ; tokenu ; marku ); v) and block the execution of u until it receives a message from v

w

next w token token

contract( ): u := ; place token: u := 1; remove token: u := 0 and unblock: unblock the execution

end

f Used in Delete. g nextu := v; f Used in Insert. g of u, but do nothing else

Fig. 3. Procedure for a node u upon receiving a message M . procedure Find f For initiator v. g begin if markv = 0 then return v; if tokenv = 1 then return Fail; 0

end

Call FindNode; f It returns w; nextw ; tokenw ; markw , and S . g nextv := w; f nextv points to the found node. g Send(contract(w);x) for all x 2 S ; f Path compressed. g if markw = 0 then return w else return Fail

Fig. 4. Procedure Find. Suppose that a node v wishes to nd a node u 2 U and calls Procedure . If markv = 0, it returns v itself, since markv = 0 implies v 2 U. If tokenv = markv = 1, it returns Fail , since U = ; in this case. When v is neither an element in U nor the anchor, returns a u 2 U as long as U 6= ;. If U = ;, Fail is returned. The node u found is the rst node in U appeared in the directed path Pv (G) from v. is given in Figure 4. Find

Find

Find

(C) Procedure

Delete

Suppose that a node v wishes to delete itself from U and calls Procedure . If v is not the anchor, i.e., if tokenv = 0, then the deletion is simply achieved by marking itself. Otherwise, if it is the anchor, rst nds a node u 2 U by calling , transfers the token to u, marks itself, and then the path compression is applied. Finally, if cannot nd a node in U and returns the anchor v itself as w, then U = fvg. The anchor v marks itself and the path compression is applied. As a result, U becomes empty and tokenv = markv = 1 Delete

Delete

FindNode

FindNode

procedure Delete f For initiator v with markv = 0. g begin if tokenv = 0 then markv := 1 and terminate;

end

Call FindNode; f It returns w;nextw ; tokenw ; markw , and S . g nextv := w; if w 6= v then tokenv := 0 and Send(place token,w); f Send token. g markv := 1; f Mark itself. g Send(contract(w);x) for all x 2 S ; f Path compressed. g Send(unblock; w)

Fig. 5. Procedure Delete. Interrupt Handler f For the anchor v. g

When the anchor v receives an inquire message from a node v and is waiting for a reply from a node w to the previous inquire message to w:

begin

0

f Flush S . g

Send(contract(w);x), for all x 2 S ; S := ;; Send(unblock; w) and ignore a reply message arriving from w;

f Acknowledge to v . g 0

Send(found(nextv ; tokenv ; markv ); v ) and block itself until it nishes processing the next message from v ; 0

0

end

f Resume execution. g Resume the execution of FindNode by resending an inquire message to w

Fig. 6. Interrupt handler for the anchor. hold. is given in Figure 5. As mentioned earlier, the execution of a procedure is usually indivisible. The only exception is the execution of by the anchor, which can occur only in . If the anchor v receives an inquire message from a node v0 when it executes and is waiting for a reply from a node w, it rst applies the path compression for the nodes in S, then suspends the execution of , and responds to the inquire message. resumes the control after processing it. Such an interrupt is necessary to guarantee deadlock-freedom. A formal description of this interrupt handler is given in Figure 6. Delete

FindNode

Delete

FindNode

FindNode

(D) Procedure

FindNode

Insert

Suppose that a node v wishes to insert itself in U and calls procedure . It rst looks for a node w in U by calling . Then it inserts v in the circular list as the next node of w. If tokenw = markw = 1, which implies that U = ;, Insert

FindNode

procedure Insert f For initiator v with markv = 1. g begin if tokenv = 1 then markv := 0 else begin

end

end

Call FindNode; f It returns w; nextw ; tokenw ; markw , and S . g markv := 0; f Remove mark. g if tokenw = markw = 1 then Send(remove token,w), nextv := v and tokenv := 1 f Token Received. g else Send(remove token,w) and nextv := nextw ; f v inserted. g Send(contract(w);x) for all x 2 S f Path compressed. g

Fig. 7. Procedure Insert. the anchor is transferred to v from w. A formal description of Figure 7.

Insert

is given in

2.4 Proving Correctness Lemma 1. The circular list C always contains all nodes in U . Proof. We show that every node not in C is marked. Every node is not marked and resides in the circular list C at the time of initiation. Suppose that an unmarked node u exists outside of C at some time instant. Then either u was removed from C despite that it was not marked, or its mark was removed despite that it was outside of C. The latter case never occur, since the removal of mark occurs only in and it always inserts the caller as the next node of the node in U that found. Let us check that the former does not occur, either. This occurs only when a contract message is sent to an unmarked node. However, always returns a set S of marked nodes. Therefore, C includes all nodes in U. ut Lemma 2. The graph G is weakly connected all the time, i.e., the procedures never generate a new directed cycle besides C . Proof. We show that the following two claims hold: 1. At any time instant, C contains the anchor. 2. A contract message to a node x asks x for setting its next pointer to a node in C. The rst claim holds, since the anchor is in C at the initiation time, and it is transferred to a node found by , i.e., to a descendant of the current anchor. To show that the second claim holds, examine the value of parameter w that a contract message takes. If it is issued in or , w is the node Insert

FindNode

FindNode

FindNode

Find

Insert

found by , which belongs to C. Otherwise, if it is issued in by the anchor, w is a node reachable from the anchor, which also belongs to C. Using the two claims, it is easy to show that the anchor is reachable from every node in G at any time instant. Hence, G is weakly connected. ut FindNode

Delete

Lemma 3. Deadlocks never occur in the proposed processor structure. Proof. Suppose that a deadlock occurs. Then there are a set D of nodes who

are executing , and each of search paths initiated by D encounters a node already blocked by another search path. Since the number of outdegree of every node is 1, it implies that every node in C belongs to one of the search paths (because there is only one cycle in G). Consider the search path containing the anchor v. v must be the initiator of the path and markv = 1. Hence there is a node w 2 D such that the search path initiated by w sent an inquire to v but cannot get a reply from v (which causes the deadlock). However, this is a contradiction, since v will execute the interrupt handler which interrupts the search initiated by v and processes the inquire. The execution of called by w will return the data about v and terminate. ut FindNode

FindNode

The following theorem can be shown using the above three lemmas, by induction on the set of time instants, at which an operation is performed.

Theorem4. The implementations of operations

rect.

, Insert and Delete are cor-

Find

ut

2.5 Performance Analysis of Implementation In this subsection, we evaluate the performance of the implementation proposed in the previous subsections, by deriving the amortized message complexity per operation in the worst case. Let E be a sequence of operations with {X operations and {Y or operations. Let N ? denote the total number of nodes deleted from U during E . We estimate the number of messages issued in E . First, observe that a sequence of communications always starts with an inquire message issued in and at most two more messages will be exchanged to processing it. Suppose that a node v sends an inquire to a node w. Then w replies either a skip me or found message and blocks itself. Later, v will send one more message (either a contract, place token, remove token, or unblock) to unblock w. Thus we can count the number of messages issued in E by counting the number of inquire messages, if is not called by the anchor and no message is discarded without processing it by the interrupt handler in Figure 6. Suppose that the execution of by the anchor v is interrupted by an inquire message from a node v0 , when it is waiting for a reply from a node Insert

Find

Delete

FindNode

FindNode

FindNode

w. Since v needs to send an unblock message to unblock w, two messages are wasted by the interrupt. The search for a node in U by v will be restarted from w by resending an inquire message to w. Let us estimate the number interrupts in E . Clearly, it is bounded from above by the number of times that is called in E . Hence at most 2(X + Y ) messages can be wasted. We rst estimate the number M of inquire messages sent to nodes in C. Then M  X + Y + N ?; since all but the last node in each search path return a skip me message and are removed from C. Therefore, the total number Z of messages processed (i.e., received or sent) by nodes in C is at most FindNode

2(X + Y ) + 3(X + Y + N ? ): Since N ?  Y ,

Z  5X + 8Y; which is a constant per operation in the amortized sense. Next, we count the total number Z 0 of messages handled by nodes in T, letting T = V ? C. Graph G changes in E , so does T. Note that T always forms a forest.2 Since T does not contain the anchor, Z 0  3M 0, where M 0 is the number of inquire messages processed by nodes in T in E . In what follows, we estimate M 0 by the potential method. An operation in E modi es the con guration of T, by deleting a node, by inserting a node, and/or by applying the heuristic of path compression. Since no node in T returns a found message, the number of inquire messages processed by nodes in T in the execution of the ith operation Oi in E is equal to the length Li of the path compressed in Oi . Using the terminology in amortized analysis, the actual cost ci of Oi is de ned to be Li . Hence, M0 =

Xc : i

i

To apply the potential function method invented in [6], de ne the potential of T by X (T) = 21 log2 s(v); v2T

where s(v) is the size of a node v in T de ned to be the number of descendants of v including v itself. Then de ne the amortized cost cbi of Oi by

cbi = ci ? (Ti?1 ) + (Ti); 2 Formally, the subgraph of G = (V; E ) induced by T  V , i.e., (T; E \ (T  T )), is a forest.

where Ti?1 and Ti are the forests T before and after the execution of Oi , respectively. For any sequence E of m operations, we have m m X X cb = (c ?  i=1

i

i=1

i

i?1

m X c ? + ) = i

i=1

i

0

+ m :

where 0 is the potential of the initial forest and m is the potential of the forest after the mth event. Since 0 = 0 (because T0 is empty) and m  0 (by de nition), we have m X c i=1

i



m X cb : i=1

i

Now, let us bound the amortized cost cbi of each operation. A key lemma is obtained by Ginat, et al. [6]: The amortized cost of a path compression on a tree is at most log2(jV j ? 1). The execution of operation Oi may call , and nd a node, traversing a search path. Let Pi be the search path. If Oi is operation, the path compression along Pi modi es T from Ti?1 to Ti . We regard that the path compression consists of two phases: In the rst phase, the subpath of Pi in Ti?1 is compressed, and in the second phase, the rest of Pi is compressed. Let T  be the T immediately after nishing the rst phase. We have cbi = ci ? (Ti?1) + (T  ) ? (T  ) + (Ti): FindNode

Find

By the key lemma, ci ? (Ti?1) + (T )  log2(jV j ? 1). On the other hand, it is easy to check that (Ti ) ? (T  )  Ni? log2 (jV j ? 1), where Ni? denotes the number of nodes deleted from C (i.e., added to T) in Oi . Hence, cbi  (1+Ni? ) log2 (jV j? 1). The amortized costs of the other two operations can be in the same way, and are bounded by (1+Ni? ) log2 (jV j? 1). Since Pmestimated ? ? ? i=1 Ni = N and N  Y , we have M 0  (m + N ? ) log2 (jV j ? 1)  (m + Y ) log2 (jV j ? 1): We now conclude the following theorem.

Theorem5. For any sequence of operations with X Find

or Delete operations,

Insert

operations and Y

(5 + 6 log2(jV j ? 1))X + (8 + 12 log2 (jV j ? 1))Y messages are issued, in the worst case. Or equivalently, the amortized message complexity per operation is 8 + 12 log2 (jV j ? 1), in the worst case. ut

3 Applications

3.1 Dynamic Load Balancing

Consider a distributed system, in which tasks are dynamically created, processed and removed on processors. The dynamic load balancing problem is the problem of migrating tasks so that the load of processor balances (see, e.g., [9]). Such a migration must be planed and performed by processors autonomously, and not by an instruction of central controller that observes the global con guration of system. As in [9], we classify the degree of load of a processor into three classes; light, medium, and heavy, for the simplicity. If a processor with heavy load can search for a processor with light load eciently, the load balancing can be solved eciently. Theimer and Lantz's load balancing algorithm, for example, is an algorithm for nding such a lightly loaded processor, with message complexity O(jV j), in the worst case. Our dynamic set of processors can be used to this end. We simply accommodate processors with light load in U. If the condition of a processor u changes from medium to light, u executes to insert itself in U. If the condition of u changes from light to medium, it executes to delete itself from U. If a processor u with heavy load wishes to migrate some tasks to a light one, it executes to nd such a processor. For the implementation we proposed in the last section, the amortized time complexity per operation is O(log2 jV j) in the worst case. Insert

Delete

Find

3.2 Distributed Mutual Exclusion

The distributed mutual exclusion problem is the problem of guaranteeing that at most one processor can be in the critical section at a time. As in the case of dynamic load balancing, we look for a distributed solution. The problem can be solved using the processor structure proposed in the last section. We initiate the system in such the way that U = ; holds. If a processor wishes to enter the critical section, it executes and waits until it becomes the anchor. The anchor has the right to enter the critical section. When a processor v leaves the critical section, it executes . Since v is the anchor, rst sends the token to the next node in C (who is waiting for its turn), and then deletes v from C. This mutual exclusion algorithm requires only O(log2 jV j) messages per entry in the amortized sense. Furthermore, this solution has the following advantages. In many cases, the set of processors that are waiting for their turn to enter the critical section is rather a small dynamic subset U of the set V of all processors. The above solution can be viewed as a token ring system among U, in which U may dynamically change. The token is circulated among a small group U. Insert

Delete

Delete

3.3 Implementing a FIFO Queue

In Section 2, we propose an implementation of a dynamic set by using a processor structure. The dynamic set implemented supports three simple operations. If we

can implement dynamic sets supporting more powerful operations, we can design ecient distributed algorithms using those dynamic sets. A (FIFO) queue of processors can be implemented using the processor structure proposed in Section 2. In this implementation, the queue is implemented in the form of circular list. The anchor represents its head. We modify so that it returns the head. Operation then returns the head. Operation rst searches for the head and then inserts the caller as the predecessor of the head, i.e., from the tail of the circular list. We do not change the implementation of operation . It passes the token to the next node, and deletes the previous head, i.e., the caller, from C. FindNode

Find

Insert

Delete

4 Concluding Remarks In this paper, we proposed a processor structure for implementing a dynamic set U of processors supporting three operations; , , and . The amortized message complexity per operation is at most 8+12 log2 (jV j? 1), in the worst case. The dynamic set can be used to many important problems, including the dynamic load balancing problem. The processor structure we proposed to implement the dynamic set can be used to solve the distributed mutual exclusion problem and be used to implement other dynamic sets supporting more powerful operations, like a queue. An important future problem is to consider an processor structure by which some dynamic set is eciently implementable on a distributed system in which the communication cost between two processors dynamically changes. Find

Insert

Delete

References 1. B. Awerbuch. Optimal distributed algorithms for minimal weight spanning tree, counting, leader election and related problems. In Proc. 19th STOC, pages 230{ 240. ACM, 1987. 2. J. M. Bernabeu-Auban and M. Ahamad. Applying a path-compression technique to obtain an ecient distributed mutual exclusion algorithm. In Proc. 3rd WDAG (LNCS 392), pages 33{44, 1989. 3. F. Chin and H. F. Ting. An almost linear time and O(n log n + e) messages distributed algorithm for minimum-weight spanning trees. In Proc. 26th FOCS, pages 257{266. IEEE, 1985. 4. R. J. Fowler. The complexity of using forwarding addresses for decentralized object nding. In Proc. 5th PODC, pages 108{120. ACM, 1986. 5. R. G. Gallager, P. A. Humblet, and P. M. Spira. A distributed algorithm for minimum-weight spanning tree. In ACM Transactions on Programming Languages and Systems 5, 1 66{77, 1983. 6. D. Ginat, D. D. Sleator, and R. E. Tarjan. A tight amortized bound for path traversal. Information Processing Letters, 31:3{5, April 1989. 7. G. Singh and A. J. Bernstein. A highly asynchronous minimum spanning tree protocol. Distributed Computing, 8:151{161, 1995.

8. R. E. Tarjan. Data Structures and Network Algorithms. Society for Industrial and Applied Mathematics, 1983. 9. M. M. Theimer and K. A. Lantz. Finding idle machines in a workstation-based distributed system. In Proc. 8th ICDCS, pages 112{122, IEEE, 1988. 10. M. Trehel and M. Naimi. A distributed algorithm for mutual exclusion based on data structures and fault tolerance. In Proc. 6th Annual Phoenix Conf. on Computers and Communications, pages 35{39. IEEE, 1987. 11. T.-K. Woo. Human trees as a basis for a dynamic mutual exclusion algorithm for distributed systems. In Proc. 12th IEEE Int. Conf. on Distr. Comp. Sys., pages 126{133. IEEE, 1992.

This article was processed using the LaTEX macro package with LLNCS style