Resource Discovery in Networks under Bandwidth Limitations

Transcription

1 Resource Discovery in Networks under Bandwidth Limitations Kishori M. Konwar Department of Computer Science and Engg University of Connecticut 371 Fairfield Rd., Unit 2155 Storrs, CT 06269, USA Alex A. Shvartsman Department of Computer Science and Engg University of Connecticut 371 Fairfield Rd., Unit 2155 Storrs, CT 06269, USA and CSAIL, Massachusetts Institute of Technology Cambridge, MA 02139, USA Abstract The Resource Discovery Problem [4], where cooperating machines need to find one another in a network, was introduced by Harchol-Balter, Leighton, and Lewin in the context of Akamai Technologies with the goal of building an Internet-wide content-distribution system. In the solutions for the synchronous setting proposed so far [4, 11, 12] there is a possibility that during some time step many machines may contact a single machine, and this is not a realistic assumption. This work assumes a synchronous model, however at each step a machine can send and receive only a constant number of messages. It is shown that the conjectured poly-logarithmic upper bound [4] for such a setting is not possible. This is done by proving a lower bound on time of Ω(n), wheren is the number of participating nodes. For this model a randomized algorithm is presented that solves the resource discovery problem in O(n log 2 n) time, i.e., within a poly-logarithmic factor of the corresponding lower bound. The algorithm has a O(n 2 log 2 n) message complexity and O(n 3 log 3 n) communication complexity. Simulation results for the algorithm illustrate the lower and upper bounds, and lead to interesting observations. 1 Introduction In distributed systems it is often the case that a large subset of machines want to cooperate with one another to accomplish a common task. For example, the machines may want to perform a distributed computation or to implement a distributed file system. A first step in such an This work is supported in part by the NSF Grants , , , application would be to discover the available relevant resources that are distributed across the network. This first step is referred to as the Resource Discovery Problem [4]. In other words, it is equivalent to some set of machines finding all other machines that are willing to collaborate with them. This problem was first introduced by Harchol- Balter, Leighton and Lewin in the context of Akamai Technologies with the motivation of building an Internet-wide content-distribution system that would speed up the access to web pages of major content suppliers. The metrics used for evaluating the efficiency of algorithms solving this problem are time, and message and communication complexities. Solutions to such problems often rely on gossip and broadcast, both of which are among the basic communication patterns in network computing (e.g., [3, 5, 9, 14]). The goal of broadcasting is to deliver information known at one node to all other known nodes, while in the case of gossiping one is interested in all nodes exchanging their local information. In both broadcasting and gossiping, every node is aware of all other participating nodes. However, in the resource discovery problem this assumption does not hold and instead the initial setting can be described in terms of a weakly-connected knowledge graph, the directed graph where one node s awareness of another node is represented by a directed edge from the former to the latter. A similar task also appears in many peer-to-peer systems that share files among a large number of users across the Internet. A large number of such systems do not have centralized servers. Instead, each user may tell its local node the Internet address of other participating nodes. These nodes may inform other such nodes and so forth. For example in Gnutella [6, 15], a node wishing to join as a peer has to execute a bootstrapping operation in order to connect to other on-line peers. Until the bootstrapping step is complete, a node cannot participate in file sharing activities such as searching and downloading.

2 Konwar, Kowalski and Shvartsman [8] considered dynamic settings where the set of participants can change over time as new participants join, and as failures and voluntary departures remove those who have joined previously. The question posed for this settings is: how soon can newly joined nodes discover each other by means of gossiping? They abstracted the problem, called the Join Problem, and studied it for dynamic systems that use allto-all gossip in terms of join-connectivity graphs where vertices represent the participants and each edge represents one participant s knowledge about another. Ideally, such a graph has diameter one, i.e., all participants know each other. The diameter can grow as new participants join, and as failures remove edges from the graph. Gossip helps participants discover one another, decreasing the diameter. Our results describe the lower and upper bounds on the number of communication rounds such that the participants who have previously joined discover one another, under a variety of assumptions about joining and failures. The problem is defined for an asynchronous setting, but for the performance analysis, certain additional timing assumptions are made. The protocols in [8] have high message and communication complexity and make a less-thanrealistic assumption that a node can broadcast arbitrary information to arbitrary number of other nodes: the number of messages sent out concurrently could be O(n) and each message can be of size O(n log n), wheren is the number of participants. In [7], Konwar, Kowalski and Shvartsman considered the discovery problem in a static setting, where the nodes participating in the computation do not fail and new nodes do not join the computation. The problem is studied in several synchronous settings under different assumptions about the ability of the participating nodes to communicate. Specifically, the following aspects of communication are considered: (1) the ability of the nodes to multicast gossip messages, and (2) the size of the messages. They showed lower and upper bounds on the number of rounds required for the participants to discover each other and considered the following question: given a weaklyconnected graph describing the initial knowledge of the nodes is it possible for a node to know that it has discovered all the nodes? Related and Previous Work Harchol-Balter, Leighton and Lewin [4] presented several randomized algorithms for the resource discovery problem, in the synchronous setting. The randomized algorithms in [4] requires either time complexity O(log 2 n), message complexity O(n log 2 n), and communication complexity O(n 2 log 3 n) (or equivalently, O(n 2 log 2 n) pointer complexity), or communication complexity O(n E 0 ) (again with message complexity O(n 2 )). These complexity bounds hold with high probability. Law and Siu [12] provided a randomized algorithm for this problem with a slightly different model: it operates only for the initial graph being strongly connected case, i.e., initially, if a node is aware of another node then the latter node is also aware of the former; one variant of that algorithm has time complexity O(log n) and message complexity O(n 2 ), and another variant has time complexity O(log 2 n) and message complexity O(n). Kutten, Peleg and Vishkin [11] provided a deterministic algorithm for the resource discovery problem. Their algorithm has superior time, message and communication complexities. The algorithm has a time complexity of O(log n); message complexity of O(n log n) and a communication complexity of ( E 0 log 2 n), wheree 0 is the set of directed edges in the initial weakly connected graph. In [4], the the cost of communication is measured in terms of two complexity measures called connection complexity and pointer complexity. However, optimizing these measures is equivalent to optimizing the usual message and communication complexities. The deterministic algorithm in the models considered in [4, 11] does not impose limits on the message size. Furthermore, any number of messages can be sent by a node in a given step. Kutten and Peleg [10] extended their deterministic algorithm of [11] to the asynchronous network environment, maintaining similar complexities (when translated to the asynchronous model). The time complexity of their algorithm is T + O(log n), where T denotes the difference between the wake-up times of the last and first nodes to be awakened. Also, their algorithm has a message complexity of O(n log n) and the overall communication complexity is O( E 0 log 2 n). Abraham and Dolev in [1] provide upper and lower bounds on the asynchronous version of resource discovery problem and proved a Ω(n log n) message complexity lower bound when the size of the network is unknown. When each node knows about the size of the connected component they provide a highly efficient algorithm with near linear message complexity O(nα(n, n)), where α(n, n) is the inverse of the Ackerman s function. Moreover, they define a relaxed version of resource discovery problem, called Ad-hoc Resource Discovery Problem. In the ad-hoc resource discovery problem it is sufficient to have a directed path from any non-root node to a root node in contrast to having a directed edge from every non-root node to the root node as in the resource discovery problem [4, 11]. A dynamic version of gossiping, called perpetual gossiping, has been proposed by Liestman and Richards [13]. Here the new information is generated continuously and the goal is to update the received information, hence the gossiping-like protocol must be repeated. Another related problem is maintaining consistency among the sites in the face of updates in the replicated database. Demers et al. [2] developed randomized algorithms for distributing updates

3 and driving the replicas toward consistency. They use epidemic-like approach to model and analyze the performance of designed protocols. Motivation and Contributions. In the algorithms for resource discovery proposed so far there is a possibility that during some given time step many machines choose to contact a single machine. In realistic settings, that machine can only maintain a small number of simultaneous connections and would have to deny access to all the other machines trying to contact it [4]. In this work we consider a version of the Resource Discovery Problem where a node can have a limited number of connections, during a synchronous step, with other machines. We refer to this as the Bandwidth-Limited Resource Discovery Problem. We model our problem in terms of a directed knowledge graph, where a directed edge from node u to node v means that u knows v and can transmit a message to v. Initially, we assume that the graph is at least weakly connected. Nodes share their knowledge by sending gossip messages via which they discover one another, decreasing the diameter of the graph. Under this restricted model we first prove a lower bound of Ω(n) on the time complexity for this model. Then we propose a new randomized algorithm, called R and prove that it solves the resource discovery problem, with high probability, in O(n log 2 n) time, O(n 2 log 2 n) message and O(n 3 log 3 n) communication complexities. We also provide simulation results with up to 1000 vertices in the knowledge graph. Apart from validating the analytical bounds the simulation results indicates that with initial knowledge graphs of bounded degrees we may have the time complexity upper bound much lower than the lower bound proved. Document Structure The remaining part of the paper is organized as follows. In Section 2 we describe the model of computation for the problem followed by a formal definition of the bandwidth limited resource discovery problem. Section 3 describes the algorithm R and the datastructures pertinent to the algorithm. In Section 4 the upper and lower bound for the performance measures are proved followed by simulation results in Section 5 along with some interesting observations. Finally, in Section 6 we conclude the paper with reference to some interesting future work. 2 Models and Complexity Measures System Model We consider a universe of processes, with unique identifiers, able to communicate over a fully connected synchronous communication network. Initially, only a subset of n processes are participating in the computation, i.e., have already joined the computation. The set of n nodes participating remains the same, i.e., neither there are joins of nodes nor are there leaves or failures of nodes. Initially, a process may not be aware of all other processes participating in the computation. Communication and computation are synchronous and goes in synchronous rounds. In each round (or iteration), a node performs some local computation depending on its current state and messages received in that round, and sends out messages, of arbitrary sizes, to other nodes, depending on the algorithm. We assume that any node, during any synchronous step, can have only a constant number of connections with other nodes. For the purpose of our analysis we assume that in each step a destination can accept only one of the incoming messages. Also, we assume that messages are not lost. We are interested in solving the Bandwidth- Limited Resource Discovery Problem in terms of the following setting. Given the initial weakly-connected knowledge graph G 0 =(V 0,E 0 ), the problem is to arrive at a situation where the knowledge graph evolves into a fullyconnected graph. In this work, as in [4, 11] we measure the performance of the algorithms in terms of the commonly used measures of time, message and communication complexities (where message complexity measures the total number of messages sent, and communication complexity measures the total number of bits sent in all messages during an execution). We say that an event E occurs with high probability (w.h.p.) to mean that Pr[E] =1 O(n α ) for some constant α>0. Modeling knowledge. We model the knowledge in the system by a directed graph whose vertices represent nodes or processes and whose edges represent the knowledge of one processor about another. We denote by V the set of vertices, where V = n. For each vertex v we denoted by Γ(v) the set of vertices corresponding to the out-going edges of v and clearly, Γ(v) V. We call this graph the connectivity graph, which is defined below. Definition 1 Given a set V and for each v V, we define the connectivity graph as the directed graph, denoted as G =(V,E), wheree = {(u, v) :u, v V,v Γ(u)}. We assume that the connectivity graph is at least initially weakly-connected, which is a reasonable assumption, motivated by the that fact that every newly added machine is given a pointer to at least one previously added machine, in the context where the resource discovery problem was initially formulated [4]. Problem definition. We define below the resource discovery problem in our model as: given the initial weaklyconnected connectivity graph, G 0 =(V 0,E 0 ) the resource discovery problem is to arrive at a situation where the graph G 0 evolves into a fully-connected graph.

4 Algorithmic template. We will consider iterative algorithms, where each iteration consists of a constant, fixed at compile-time, number of steps, i.e. the number of synchronous steps involved in an iteration is known or decide apriori. We enumerate iterations using natural numbers. We define the following algorithmic template, it essentially consists of the following two synchronous steps executed repeatedly and alternatively: (i) At the beginning of the current step, the nodes perform some local computation based on its state and the messages received; and sends out messages to some destinations depending on the outcome of its computation. (ii) At some synchronous step every node receives all the messages sent to them by other nodes, during the previous synchronous step and at most one of them is chosen to be delivered. Each message may contain a set of identifiers and other control messages. Now let G 0 =(V 0,E 0 ) be the connectivity graph corresponding to the initial state. At the end of each iteration i>0, wedefineg i =(V i,e i ) to be the resulting connectivity graph. Clearly, V 0 = V i, i 0. Complexity measures. In this paper we measure the performance of the algorithms presented in terms of the commonly used measures of time, message and communication complexities. Given an initial connectivity graph G 0 and an algorithm to solve the resource discovery problem, wedefinethetime complexity as the number of synchronous rounds of the algorithm executed in solving the resource discovery problem. The message complexity of an algorithm that solves the resource discovery problem on an initial connectivity graph G 0 is the total number of messages sent during the execution of the algorithm to solve the resource discovery problem. The communication complexity of an algorithm is the total number of bits sent during the execution of the algorithm until it solves the resource discovery problem. 3 Description of Algorithm R Some notations and definitions Now we describe algorithm R and it associated data-structures. Each node, v has locally stores the data-structure, Γ(v). At each synchronous step a machine randomly chooses to establish connections to one of Γ(v) and sends a request for connection. During a synchronous step, of all incoming requests, the target accepts randomly one to connect to. If the node is successful in connecting then it sends its world Γ(v). The destination node u, after receiving the message (which consists of Γ(v)) from v, it adds Γ(v) to its world Γ(u). The reason behind the random section of the incoming messages is two-fold: (i) the node node may not have any information to choose one incoming connection over another; and (ii) in real networks, during the connection setups, it is natural to assume that the connection is setup randomly. The algorithm R essentially consists of two main phases, viz., the Send Phase and the Receive Phase. These two phases are repeatedly and alternately executed. The Send Phase consists of a step where each node chooses randomly a target to communicate with, followed by a step that involves the actual communication. In the Receive Phase the first step involves the target choosing one of the incoming requests to receive, followed by its delivering of the message and updating its Γ( ) datastructure. In the remaining part of the paper we use the terms receive and delivery of messages at a node. In the Receive Phase in Step 1 of algorithm R we say the incoming messages are received although the message may not be delivered in step 2 of Receive Phase. Send Phase: 1. Choose a node u uniformly randomly from Γ(v). 2. Send the list Γ(v) to node u. Receive Phase: 1. Choose one of the incoming messages, say Γ(u), uniformly randomly. 2. Add the list of nodes, Γ(u), from the message selected, to Γ(v). Figure 1. The steps in algorithm R at node v. 4 Complexity Measures 4.1 Lower bounds In this section we show that under the restrictions on the number of connections a machine can open with other machines, during a synchronous step, there is a lower bound of Ω(n) on the time and message complexities. Lemma 4.1 The bandwidth limited resource discovery problem has a lower bound of Ω(n) on time and message complexities. Proof: For the proof we consider the initial weaklyconnected connectivity graph, G 0 =(V 0,E 0 ) as shown in Fig. 2. The star graph G 0 consists of n vertices

5 v n-2 v i Lemma 4.4 In algorithm R, for any u, v, w V such that (w, v), (w, u) E then in O(n log n) time steps the edges (v, u) and (u, v) are in E, with high probability. v n-1 v 1 Figure 2. An initial weakly connected graph where the only edges in the graph G 0 =(V 0,E 0 ) are from the peripheral vertices v 1,v 2,,v n 1 to the vertex at the center v 0 V 0 = {v 0,v 1,,v n 1 } and the center vertex v 0 has n 1 incoming edges from the vertices v 1,v 2,,v n 1 and no outgoing edges. Now, note that any vertex v i, 1 i n 1 will not be known to any other vertex from v 0,v 1, v i 1,v i+1, v n 1 until at least v i is successfully able to deliver a message to the center vertex v 0. Thus to solve the bandwidth limited resource discovery problem for the initially graph G 0 =(V 0,E 0 ) each of the n 1 vertices v 1,,v n 1 needs to send at least one message to the center vertex v 0.Sincevertexv 0 can open at most some constant number of connections with other vertices, in a single synchronous step, then it would require Ω(n) time to establish connection with every one of v 1,v 2,,v n 1 at least once. v Performance of algorithm R In this section we prove the time complexity, message complexity and communication complexity of the algorithm R. First we prove Lemmas 4.4 and 4.5 which are used to prove Lemma 4.6 which provides the upper bound on the time complexity. From Lemma 4.6 it is almost trivial to show the message and communication complexities as in Lemma 4.7. Lemma 4.2 (Chernoff Bounds) Let X 1,X 2,,X n be n independent Bernoulli random variables with Pr[X i = 1] = p i and Pr[X i =0]=1 p i, then it holds for X = n i=1 X i and µ = E[X] = n i=1 p i that for all δ>0, (i) Pr[X (1 + δ)µ] exp ). (1 δ)µ] exp ( µδ2 2 v 2 ( µδ2 3 v 3 ), and (ii) Pr[X Lemma 4.3 (Bounded Markov Argument [4]) Let X be a random variable so that 0 X U then for t U we have Pr[X t] U E(X) U t. Proof: We fix our analysis from some time step of an execution of the algorithm R and count the time steps from this step as 1,2,...We refer to some sets at time t by subscripting them with t,e.g., E t denotes the set of edges in the connectivity graph at time step t. Suppose, initially, (w, v), (w, v) E 1 and (u, v), (v, u) E 1. Denote by A t the set of vertices, such that, every vertex w in A t knows both the vertices u and v at time t, i.e., (w, u), (w, v) A t. Now, we want to show that during any single time step t the following cases hold: (i) the probability that (u, v) E t+1 is at least some c n,forsome constant, c>0;or(ii) the probability that the set A grows by a factor is of probability at least d n, for some constant, d>0. Now,inanystep,t of algorithm R, for every vertex w in A t, we know the probability of vertex u receiving a message from vertex w is Pr(u receives message from w) 1 d w Let us now first analyze the size of the set A 2 andthengeneralize the result to A t+1 for any time step t>1. Observe that the probability the edge (u, v) appears in E 2 is Pr ((u, v) E 2 ) =1 Pr ((u, v) E 2 ) =1 (1 Pr (u receives message from w)) w A 1 1 ( 1 1 ) nd w w A 1 1 e 1 n Pw A 1 1 dw Now, if Pr ((u, v) E 2 ) 1 e 1 4n then since 1 e 1 4n 1 4n so that Pr ((u, v) E 2) 1 4n. But in that case we would have 1 w A 1 d w 1 4 and so at least 1 2 -fraction of the vertices in A 1 has degree at least 2 A 1 and therefore, every such vertex knows at least A 1 other vertices outside of A 1. So, each such vertex w in A 1, sends a message in the Send Phase of algorithm R to a vertex x not in A 1 is at least 1 4 and the probability of x selecting w s message in the immediate Receive Phase is at least 1 n. Therefore, the probability that each such vertex in w A 1 1 successfully contacts a vertex outside of A 1 is at least 4n. Hence the expected number of vertices outside of A 1 is at least A1 8n. Now by the Bounded Markov Argument in Lemma 4.3 we have ( Pr A 2 \ A 1 A ) n 16n n

6 In the above argument there is nothing specific about the time step 1 and can easily extended to any time step t to get either (i) Pr ((u, v) E t+1 ) 1 4n = c, for some c>0 n or ( ( (ii) Pr A t ) ) A t 1 16n 16n = d n, for some d>0. Now, consider kn log n (for some k>0) consecutive steps of the algorithm R and during at least k 2 n log n of the steps one of the cases (i) and (ii) are going to be true and each even is independent of the previous one. So, for case (i), Pr ((u, v) appears in k2 ) n log n steps =1 1 k 2 n log n i=1 k 2 n log n i=1 (1 Pr ((u, v) E i )) ( 1 c ) n 1 1, for some l>0 nl Similarly, for case (ii) by Chernoff bound we can show that there exists a constant λ>0so that ( ) Pr A t+ k 2 n log n (1 + λ) A t 1 1, n l for some l > 0. Now,, if case (ii) occurs, for O(n log n) steps then the size of the set A grow to A =Θ(n), thenin another O(n log n) time steps the edge (u, v) forms with high probability. Hence combining the arguments for both the cases (i) and (ii) we have the edge (u, v) with high probability in O(n log n) steps. Lemma 4.5 For algorithm R, if for some vertices u and v, (u, v) E then (v, u) E in O(n log n) time steps, with high probability. Proof: We have two possible cases regarding the out-degree of vertex u: (i) out-degree of u is 1 (outdegree(u) =1)or(ii)out-degreeofu is at least 2 (outdegree(u) > 1). In case (i) u going to repeatedly send out messages to v, in every time step, until the out-degree becomes more than 1. But in any given time step the vertex v may receive at most n messages out of which it chooses to deliver one randomly. Therefore, by a simple application of Chernoff bound, Lemma 4.2 argument v delivers a message from u at least oncein O(n log n) steps, with high probability. In other words, the out-degree of u is 1 for at most O(n log n) time steps, with high probability. So, due to such delivery of a message from u,nowv knows u,i.e.,(v, u) E. If case (ii) occurs then we have (u, w) E where w is some other vertex other than v. In this case by Lemma4.3 we have the edge appear (v, u) E in another O(n log n) time steps, with high probability. Theorem 4.6 Let G 0 be a weakly-connected connectivity graph with n vertices, then after O(n log 2 n) iterations of the algorithm R the graph evolves to a complete graph with high probability, i.e., with probability greater than 1 1 n c,forsomec>0. Proof: We prove this result by putting together the results of several lemmas mentioned above. The proof is based on the basic and simple idea that a new edge (u, v) appears if there is a vertex w that already knows u and v, i.e., (w, v) and (w, u) exist already. This idea is also used in [4]. However, in our model we have the additional constraint that, in a synchronous step, a vertex accepts at most one of the incoming messages. Consider any three vertices u, v and w such that there are directed edges between u and v; v and w, i.e., (edges (u, v) or (v, u) exists) and (edges (v, w) or (w, v) exists). First we want to show that in O(n log n) time steps the edges (u, w) appears. This is because by Lemma 4.5 the edges (v, u) and (v, w) appears in O(n log n) time steps and hence by Lemma 4.4 (u, w) appears in another O(n log n) time steps. Now, consider any pair of vertices x and y in the connectivity graph and consider the shortest path between them in the connectivity graph in the undirected sense of the edges. By the preceding argument in every O(n log n) steps the path shortens by a factor of half. Therefore, the connectivity graph becomes a complete graph in O(n log 2 n) time steps. Lemma 4.7 The message complexity and communication complexity of the algorithm R, to solve the resource discovery problem, are O(n 2 log 2 n) and O(n 3 log 3 n), respectively. Proof: From Theorem 4.6 the time required to solve the resource discovery problem is O(n log n). However, in each time step any vertex sends message to at most one other vertex and hence in each time step there could be up to n messages. Therefore, the total number of messages sent during the algorithm is O(n 2 log 2 n). The bound of communication complexity comes from the observation that a message may consist of O(n log n) bits since there are n vertices and each identifier can be represented with O(log n) bits.

7 Time(Graph)/Time(nlog^2(n)) Time(Linear Graph)/Time(Star Graph) #vertices (a) star/analytic linear/analytic #vertices (b) linear/star Figure 3. The comparison of the number of time steps taken for the algorithm R to solve the resource discovery problem via simulations versus the analytical result. (a) The ratio of the time steps taken in the simulation for the initial graphs star-graphs and linear directed graphs versus analytical bound (n log 2 n), for the initial graphs star-graphs and linear directed graphs. (b) The ratio of the time steps taken in the simulations for linear graphs versus stargraphs. The simulations have been carried for the initially connectivity graph of star graphs and linear directed graphs, for the number of vertices in the range and averaged over 5-10 runs. 5 Simulation Results In Fig. 3(a)-(b) we provide simulation results for the time complexity for the algorithm R against the number of nodes, n. The simulations are carried out on initial weakly-connected knowledge graphs consisting of up to 1000 nodes. All the simulations were carried run on a Systemax Linux server with 1 GB of RAM and one Intel(R) Pentium(R) 4 CPU 2.60GHz. We ran our simulations on two types of initial weakly-connected knowledge graphs G 0 =(V 0,E 0 ), viz., star graph as in Fig. 2 and a linear directed chain (i.e., a graph v 0 v 1 v n 1 ). The results are then compared with the analytic result O(n log 2 n), by plotting the number of steps the simulated algorithm R takes to evolve the initial graph to a complete graph, i.e., to solve the resource discovery problem. For the sake of simplicity we choose the constant hidden under the asymptotic result to be 1, i.e., n log 2 n. These two types of initial weakly-connected knowledge graphs are chosen so as to consider two extreme cases of maximum degree of a vertex, viz, the star graph has maximum degree of a vertex of O(n) and that of the linear directed chain is O(1). In Fig. 3(a) is a plot of the ratio of the number of time steps, T G0, required for the simulation of the algorithm R, to solve the resource discovery problem on the initial graph G 0, over the analytical bound of O(n log 2 n). In T other words G0 is plotted against n for two kinds of n log 2 n the initial weakly-connected knowledge graph G 0,viz., (i) a linear directed graph and (ii) a star graph. From Fig. 3(a) is evident that in the case of an initial star graph T the plot of G0 approaches a constant, as n increases. n log 2 n This indicates that for initial graph as star graph, the time to solve the resource discovery problem in the simulation closely matches with the analytical result. However, when the initial graph is chosen to be a directed linear graph the T ratio G0 decreases fast enough (Fig. 3(a)) indicating n log 2 n that the time it takes to solve the resource discovery problem is much lower than the analytical bound. Based on this latter observation it is likely that the time complexity to solve the resource discovery on linear directed graphs G 0 or graphs of bounded degree is poly-logarithmic in n. However, we have not been able to prove this result on such specific initial weakly-connected graphs analytically. On the other hand it is noteworthy that for general initial weakly-connected graphs the lower bound is already proven to be linear in n (ref Lemma 4.1). In order to see this from the simulations, in Fig. 3(b) we plot the ratio of times when the initial connectivity graph is (i) a linear directed graph and (ii) star graph to solve the resource discovery problem against n. It is evident from the plot this ratio declines quickly as n increases. This indicates a possible difference of a factor of n between the number of time steps required to solve the resource discovery problem in the two kinds of initial knowledge graphs considered here. This perhaps suggests a lower time complexity dependent of the maximum degree of the initial connectivity graph. 6 Conclusion In this paper we studied the resource discovery problem in the a more realistic, from the bandwidth point of view, setting than considered in the previously known work [11, 4]. In the previous work, the distributed protocols used for solving the resource discovery problems assumed that any machine can send out messages to unbounded number of machines and also any machines can accept unbounded number of messages, in a single synchronous step. In reality, almost every machines has a

8 limitation on the number of incoming connections it can establish, in a synchronous step, in order to pass information. Here we consider a much more closer to reality assumption, any machine can try to connect to at most some constant number of machines to send messages, and any machines can setup connection with at most some constant number of incoming requests. We assume that message is always pushed to the destination to be able to to model datagram type network layer protocols. First, we proved a lower bound of Ω(n) for the time complexity. We provided a randomized algorithm, for this communication and computing model, to solve the resource discovery problem within a poly-logarithmic factor of this lower bound on time complexity, i.e., O(n log 2 n). The algorithm also has a O(n 2 log 2 n) message complexity and O(n 3 log 3 n) communication complexity. We provided simulation results validating the upper bound on time complexity. Through our simulation we observed that in the case of the initial connectivity graph linear the algorithm R takes much lesser number of time steps than the analytical bound. Interesting future work would be able to look into some bounded degree initial connectivity graph where the time complexity of the algorithm R is poly-logarithmic. Another aspect of this problem is to look at the scenario where the nodes may leave and new nodes may migrate during the computation. Also, we can model loss of messages where each message sent is lost or not delivered with some probability, leading to a much more realistic scenario. References [1] I. Abraham and D. Dolev. Asynchronous resource discovery. In Proceedings of the 22nd ACM Symposium on Principles of Distributed Computing, pages , [2] A. Demers, D. Greene, C. Hauser, W. Irish, J. Larson, S. Shenker, H. Sturgis, D. Swinehart, and D. Terry. Epidemic algorithms for replicated database maintenance. In Proceedings of the Sixth Symposium on Principles of Distributed Computing, pages 1 12, [3] C. Georgiou, D. Kowalski, and A. Shvartsman. Efficient gossip and robust distributed computation. In Proceedings of the 17th International Symposium on Distributed Computing, pages , [4] M. Harchol-Balter, F. T. Leighton, and D. Lewin. Resource discovery in distributed networks. In Proceedings of the 18th Symposium on Principles of Distributed Computing, pages , [5] S. Hedetniemi, T. Hedetniemi, and A. L. Liestman. A survey of gossiping and broadcasting in communication networks. Networks, 18: , [6] P. Karbhari, M. Ammar, A. Dhamdhere, H. Raj, G. Riley, and E. Zegura. Bootstrapping in gnutella: A preliminary measurement study. In Proceedings of the 5th anuual Passive and Active Measurement Workshop, [7] K. Konwar, D. Kowalski, and A. Shvartsman. Node discovery in networks. In Proceedings of the 9th International Conference on Principles of Distributed Systems, pages , [8] K. Konwar, D. R. Kowalski, and A. A. Shvartsman. The join problem in dynamic network algorithms. In Proceedings of the International Conference on Dependable Systems and Networks, pages , [9] D. Kowalski and A. Pelc. Deterministic broadcasting time in radio networks of unknown topology. In Proceedings of the 43rd Ann. IEEE Symp. on Foundations of Computer Science, pages 63 72, [10] S. Kutten and D. Peleg. Asynchronous resource discovery in peer to peer networks. In Proceedings of the 21st IEEE Symposium on Reliable Distributed Systems (SRDS 02), pages , [11] S. Kutten, D. Peleg, and U. Vishkin. Deterministic resource discovery in distributed networks. In Proceedings of the 13th ACM Symposium on Parallel Algorithms and Architectures, pages 77 83, [12] C. Law and K.-Y. Siu. An o(log n) randomized resource discovery algorithm. In Brief Announcements of the 14th International Symposium on Distributed Computing, Technical Report FIM/110.1/DLSIIS/2000, Technical University of Madrid, pages 5 8, [13] A. L. Liestman and D. S. Richards. Perpetual gossiping. Parallel Processing Letters, 3: , [14] A. Pelc. Fault-tolerant broadcasting and gossiping in communication networks. Networks, 28: , [15] M. Ripeanu, I. Foster, and A. Iamnitchi. Mapping the gnutella network: Properties of large-scale peerto-peer. IEEE Internet Computing Journal special issue on peer-to-peer networking, 6(1), 2002.