Randomized Rumor Spreading in Ad Hoc Networks with Buffers

12/31/2018 ∙ by Dariusz R. Kowalski, et al. ∙ 0

The randomized rumor spreading problem generates a big interest in the area of distributed algorithms due to its simplicity, robustness and wide range of applications. The two most popular communication paradigms used for spreading the rumor are Push and Pull algorithms. The former protocol allows nodes to send the rumor to a randomly selected neighbor at each step, while the latter is based on sending a request and downloading the rumor from a randomly selected neighbor, provided the neighbor has it. Previous analysis of these protocols assumed that every node could process all such push/pull operations within a single step, which could be unrealistic in practical situations. Therefore we propose a new framework for analysis rumor spreading accommodating buffers, in which a node can process only one push/pull message or push request at a time. We develop upper and lower bounds for randomized rumor spreading time in the new framework, and compare the results with analogous in the old framework without buffers.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Rumor spreading is a fundamental concept in ad hoc communication, databases and systems: a rumor, initially stored in one node, needs to be delivered to all other nodes in the network by passing it along available links. Randomized and distributed spreading algorithms are of special interest due to their simplicity, robustness and locality [19, 13]. A well known randomized spreading algorithm proposed in the literature [8] is called Push. Push algorithm is executed in each node and it works in steps. At each step: if a node holds the rumor, it chooses uniformly at random one neighbor to establish a point-to-point communication. If the chosen neighbor does not hold the rumor, the rumor is pushed through and the neighbor becomes a holder of the rumor at the same step. If a node does not hold the rumor, it waits until it becomes a holder. Push algorithm has its counterpart known as Pull spreading algorithm. Pull algorithm is executed in each node and it also works in steps. At each step: if a node does not hold the rumor, it chooses uniformly at random one neighbor to establish a point-to-point communication. If the chosen neighbor holds the rumor, the rumor is pulled through and the node becomes a holder of the rumor at the same step. If a node holds the rumor, it waits until every node holds the rumor (while neighbors may pull the rumor from it). A third well studied randomized algorithm is a combination of Push and Pull algorithms. It is called Push&Pull and it works as follows: at each step, every node that holds the rumor acts according to Push algorithm, and every node that does not hold the rumor acts according to Pull algorithm. Some appealing applications of randomized rumor spreading are data aggregation [1], maintenance of replicated databases [8], resource discovery [18] and failure detector [26], among others.

The classical framework that was used for studying the behavior of Push, Pull and Push&Pull protocols assumes discrete time running in synchronized time steps for all nodes. At each time step, every node can establish many parallel point-to-point communications if many neighbors request one via Push or Pull. Hence, it is implicitly assumed that, at each step, every node is able to process every received Push message and Pull request. Therefore, if a node that holds the rumor is contacted by many neighbors at the same time step trying to push or pull the rumor, the classical framework allows this node to process all the Push messages and/or answer all the Pull requests in the same time step. Such an assumption makes that some important phenomena occurring in practical situations may not be captured. For instance, if the graph consists in one central node connected to leaves and the spreading algorithm is Push&Pull, the results proved in [16] say that the rumor is spread in at most time steps. While, even if the central node can send messages at the same time, it may need in practice steps to process all the messages (Push messages and/or Pull requests) sent by the leaves. Therefore, if the source node is one of the leaves, in the worst case, the central node may learn the rumor after steps (after processing all the messages sent by the leaves). This fact is clearly not captured by the analysis done so far in the previous work on randomized rumor spreading, which assumed such parallelism when processing Push messages and answering Pull requests.

Our contributions.

In order to address the aforementioned phenomena, we introduce a new framework to study rumor spreading. In the literature, we find the phone call model used to study gossiping problem [20, 7]. The model we introduce in this document can be seen as the phone call model where every node has a telephone answering machine (the buffer). Therefore, if a node receives a call while it is already in a different call, the buffer takes the message. Then, the node can check the buffer making a call and it writes down the message in the local memory. In the model we introduce, a node is allowed to perform in one time step: a call to one neighbor, and a call to the the buffer to take note of one message recorded in the buffer. If the buffer is empty at some step, one incoming call goes directly to the node and the rest incoming calls (if they exist) go to the buffer (the call that goes directly to the node is chosen uniformly at random). When the buffer is not empty, since the node is calling to the buffer to take note of a message, every incoming call goes directly to the buffer.

We prove similarities and, most importantly, crucial differences between the performance of randomized spreading algorithms when they are analyzed under the new framework or under the classical framework for rumor spreading problem. In particular, when the spreading algorithm is Push, we prove that every result obtained in the classical model applies in the introduced model. Contrarily to what happens when the spreading algorithm is Pull: in that case, time complexity for rumor spreading increases considerably since the amount of messages stored in the buffer grows rapidly. Particularly, we show that for some class that includes also Caterpillar graphs, i.e., a chain of star graphs, Pull algorithm requires at least rounds, where is the diameter of the graph and is the degree of internal nodes. We also prove upper bounds for general graphs and for regular graphs , where , is the maximum degree and is the degree in regular graphs.

The rest of the document is organized as follows. We review the related work in Section 2. In Section 3, we define notation and give a detailed description of the introduced model. In Section 4, we prove the equivalence in terms of time complexity between the classical model and the model with buffers when Push algorithm is used to spread the rumor. In Section 5, we show crucial difference in terms of time complexity between the classical model and the model with buffers when Pull algorithm is used to spread the rumor. Finally, in Section 6, we provide conclusions and discuss about the future work.

2 Related work

Time complexity for rumor spreading has been widely studied in the literature. Concerning rumor spreading via Push algorithm, time complexity has been studied for complete graphs in [15, 23]

proving that, in probability, the rumor is spread to all vertices within

steps. Time complexity via Push algorithm in Cayley graphs was studied in [11]. The authors proved a time complexity of to Star graphs, Pancacke graphs and Transposition graphs, among others. Interestingly, they upper bounded the time complexity when Push algorithm spreads the rumor by the mixing time of a random walk in the graph. On the other hand, in [14], time complexity for Push protocol is studied for random regular graphs and expanders. Upper bounds for general graphs have been presented in [13] and improved in [12]. Time complexity for rumor spreading via Push algorithm has been studied as well in the asynchronous model in [24].

When Push&Pull algorithm is used to spread the rumor, time complexity has been upper bounded via vertex expansion when the graph is regular [25] as well as for general graphs [17] where it was proved an upper bound of , where is the vertex expansion of the graph under analysis. On the other hand, time complexity for rumor spreading has been also studied via conductance for complete graphs [8, 19, 10, 9], social networks [6], or general graphs [5, 4, 16] where a tight upper bound of was proved, when denotes the conductance of the graph under analysis. In the same work, an upper bound of was proved for Pull algorithm in general graphs.

Randomized spreading algorithms has slightly modified to substantially improve time complexity for tumor spreading. The authors of [3] used weak conductance to decrease form polynomial to polylogarithmic time complexity in graphs with large weak conductance by adding some determinism in the algorithm to discover bottlenecks. Finally, it was proved in [2] that a simple modification of the Push&Pull algorithm gives a solution for rumor spreading with time complexity of at most , where is the diameter of the network, hence, with no dependence on the conductance.

3 Model

The network is modeled by an undirected graph, denoted by , with the set of nodes , representing the computing entities, and the set of edges , representing point-to-point bi-directional communication links available. Let denote the set of neighbors of node , i.e., the point-to-point bi-directional communication links available incident to node . Let denote the diameter of the graph and denote the maximum degree of the graph. We do not assume any global node or link labeling; instead, only local link labeling is required to be able to select an outgoing port for a message to be sent and to identify the incoming point of a received message. Time is considered to be slotted in synchronized steps, also called rounds.

Buffers.

Every node has a bounded size buffer. We use letter to denote the size of the buffer. is a parameter of the system, therefore, we might consider to be large enough so that it can be considered as “unbounded” from perspective of a finite-time execution. In this document, indeed, we study the case when the size of the buffers is “unbounded”. All messages sent to a node are queued in its buffer. Unless stated otherwise, messages are stored according to the FIFO (First-In-First-Out) policy, with ties broken either arbitrarily (by some adversary) or uniformly at random.

Local memory.

Every node has a bounded local memory. In this work we focus on algorithms with a “small” memory, i.e., logarithmic size memory. In particular, this work focuses on algorithms that could store ids of only a constant number of links (e.g., leading to some of its neighbors). The local memory can store enough information so that the node only knows which of its neighbors has sent a request in the current round, and it also has enough space to save the rumor.

Local steps: Sending, delivering and reading a message.

Each node runs a given algorithm in consecutive steps. Every node can read one message per time step from the buffer. If the message contains the rumor, the node stores the rumor provided it has not stored the rumor earlier. Otherwise, the rumor is discarded. Every node can send one message per time step.

Push, Pull and Push&Pull spreading algorithms.

Push algorithm works as follows: if a node has the rumor stored in its memory, it sends a message with the rumor to one neighbor selected uniformly at random among all its neighbors (so called Push action). If a node does not have the rumor stored in its memory, it waits until it receives the rumor (in the meantime, it keeps reading messages from its buffer, one reading attempt per step).

Pull algorithm works symmetrically: If a node does not have the rumor stored in its memory, it sends a request to a neighbor selected uniformly at random among all its neighbors (so called Pull request). If a node has the rumor stored in its memory, it keeps reading messages from its buffer and answering every Pull request it reads at the same step it reads the request. We recall that a node can read only one message from its buffer; Hence, even if the request from some node is in its buffer, it does not mean that it will be answered immediately.

Push&Pull algorithm is a combination of both Push and Pull algorithms. If a node has the rumor stored in its memory, it acts as follows: If it has no pending request, it selects one neighbor uniformly at random among all its neighbors and sends the rumor to that neighbor (Push action). If it has pending requests in memory, it sends the rumor to the currently read Pull request from its buffer, if any (answering Pull request). We describe Push&Pull algorithm for the sake of completeness, though in this document we focus only on the study of Push and Pull algorithms in the newly introduced model with buffers.

Rumor spreading problem.

In the beginning of an execution, there is one node that has a rumor; we call that node the source node. The goal is to spread the rumor to every node in the network.

In the execution of an algorithm, a node could be in one of the two states: informed and uninformed. We say that a node is informed at a step if it is the source node or it has already read a message containing the rumor by the step. A node that is not yet informed is called uninformed. An uninformed node that has a message containing the source rumor in its buffer is called nearly-informed. Note that a node can locally recognize and remember whether it is informed or not, but an uninformed node cannot locally check if it is nearly-informed, as this would require reading messages containing the source rumor from its buffer, which will eventually take place, but not faster than one message per step.

Objective function.

Let us denote by the set of informed nodes in an execution of spreading algorithm at step . The time complexity of an execution of spreading algorithm is defined as the expected time step such that . Time complexity for an execution of a spreading algorithm depends on the source node. Hence, we define the time complexity of spreading algorithm for rumor spreading in a graph , denoted by , as the worst time complexity of any execution of spreading algorithm in over all possible source nodes.

4 Push algorithm: equivalence between classical and buffer models

The main goal of this section is to show that when nodes in a network with buffers spread the rumor using Push algorithm, its time complexity is equivalent to the time complexity in the classical rumor spreading model without buffers. The intuition behind it is the fact that, if nodes use only Push algorithm to transmit the rumor, uninformed nodes do not transmit any type of messages that slow down (or speed up) the whole process by creating queues in the buffers. They wait until they receive the rumor to then start to transmit it.

Theorem 1

Let be a graph and the source node. Let be an execution of Push algorithm that spreads the rumor to all the nodes in in time in the classical model. Then, when the model with buffers is considered for the same graph and the same initial node , the execution of the Push algorithm has the same time complexity .

Proof: The proof is by induction. We prove that for all time step , the set of informed nodes in the classical model is equal to the set of informed nodes in the model with buffers . The first step of the induction holds by the assumption of the Theorem, i.e., is the node that initially holds the rumor in both cases, the classical model and the model with buffers. Hence, it holds .

Let us assume now that for some time step . We will prove that . If the set of informed nodes does not change from step to step in the classical model, it means that in the execution every random selection did not select an uninformed node. Hence, since the model with buffers is executing the same execution and , it holds that does not differ from . Therefore, it holds that . On the other hand, if some uninformed nodes become informed at time step in the classical model, since the model with buffers is executing the same execution , then the same nodes receive the rumor in their buffers at the same time step . Now, since those nodes were uninformed and the spreading algorithm is Push, the buffers of these nodes did not contain any message (otherwise, the message would have been the rumor and the nodes would have been informed). Therefore, these nodes read the rumor at the same step and become informed at the same step . In conclusion, .

Theorem 1 allows us to state the following corollary of equivalence between classical model and model with buffers when Push is the algorithm used to spread the rumor.

Corollary 1

Every result that holds for the time complexity of rumor spreading in the classical model for Push algorithm also holds for the model with buffers when Push algorithm is used to spread the rumor.

5 Pull protocol: bounds for the time complexity in the buffer model

In this Section we give upper bounds on the time complexity of Pull spreading algorithm in the case of regular graphs and general graphs.

In order to mark clear differences between the performance of Pull algorithm in the classical model and in the newly introduce model with buffers, we first describe the following example. Consider a graph that consists in the concatenation of -stars, where -star is a central node connected to leaves. More precisely, the concatenation of -stars is the graph where -stars are connected by additional edges such that the central nodes form a path of length . When the rumor is spread in such a graph via Pull according to the classical model, any informed central node informs in constant number of rounds all its leaves. On the other hand, by the coupon collector argument, the rumor is transmitted from one central node to the next central node in rounds. Therefore, when the source node is the leftmost central node, rounds are enough to inform the rightmost central node and all the leaves.

If the same situation is analyzed under the model with buffers, we obtain a completely different result. Since leaves have only one neighbor, which is its corresponding central node, they send one request message to the central node in every round while being uninformed. Hence, each central node collects request messages per each round when all its leaves are uninformed. In the best case, the rumor will be transmitted from one central node to the next central node in the round right after the former becomes informed. Even though, the second central node has accumulated more requests in its buffer in that round, which will delay the process of informing the second central node by at least more rounds. Therefore, in the best case, when the source node is the leftmost central node, the rightmost central node will become informed after steps. This shows a huge gap between the performance of Pull analyzed in the classical model and in the model with buffers, for the same graph.

5.1 Upper bounds

For any network , we denote by the degree of node and by the maximum degree in the network. On the other hand, we denote by the expected number of messages that could be received by node in a single step provided that each of its neighbors transmits a message to one of its own neighbors (randomly selected). Let us denote by the maximum of such expectations over all nodes.

Lemma 1

Let be any graph. It holds that .

Proof: First, we point out the fact that in any graph, it holds the following equality: . This equality comes from the following. By definition of the expectation, it holds: . Then, in the sum the inverse of the degree of every node appears summed one time per each neighbor of it, which sum up to for each node.

Now, let us assume by contradiction that there exists a graph such that . By definition of , it holds . By the assumption, it holds . Hence, we obtain a contradiction.

According to the previous Lemma, a given graph is either regular or its corresponding is strictly larger than .

In order to prove the upper bound, we use the following notation. Let us denote by the expected number of steps such that every node at distance from the source is informed or nearly-informed.

Lemma 2

The following recursive formula holds:

Proof: We prove the Theorem by upper bounding the expected time complexity that every node in the -th layer of the BFS tree rooted at the source is informed or nearly-informed (i.e., has the rumor in its buffer). Note that the number of messages stored in the buffer of every node may grow in time. Nevertheless, once the rumor has been sent to a node (and thus was put to the buffer of that node), no message arriving later to the buffer could delay the time of reading the rumor by the node from its buffer. For every node, we bound the number of messages in the buffer that arrive earlier than the rumor by taking into account the layer number of the node.

In case , in expectation there is at most one message arriving per to each node. Though, due to the model, if the buffer is not empty, the node processes one message from the buffer at each step. Let us denote by the expected number of messages queued in the buffer of a node after steps. It is known that the probability of the buffer size being is constant [22]. It follows directly from the fact that the increase of the buffer size in each step can be modeled by Bernoulli trials with probability of success minus one, which in the period of steps is with a constant probability (e.g., by using Chernoff bound).

Hence, the following recursive formula holds: . The part in this formula represents the time required so that every node in the previous layer is informed or nearly-informed. The part in the formula is an upper bound on the maximum size of the buffer at that step, so that nearly-informed nodes could become informed after reading messages from their buffers one after another. Finally, is the number of pull requests that any node (in the previous layer) has to answer so that each of its neighbors, and in particular - neighbors in the next layer, receives the rumor in its buffer; this bound follows by the coupon collector argument.

In case the above mentioned expected buffer size is constant. Hence, the following recursive formula holds: . The part in this formula represents the time required so that every node in the previous layer is informed or nearly-informed. Moreover, the is the number of pull requests that any node (in the previous layer) has to answer so that each neighbors in the next layer receives the rumor in its buffer

Finally, in the case when the above mentioned expected buffer size grows at most by a factor of at each step. Then, it holds that .

Theorem 2

The expected number of steps for rumor spreading, taken by protocol Pull in any synchronous execution on any regular networks of diameter and degree , is .

Proof:

Since the graph is regular, in expectation there is one message arriving per step. Therefore, it applies the case in the previous Lemma. Hence, the following recursive formula holds: .

We set . Indeed, by applying coupon collector argument, by time , in expectation, each neighbor of the source will receive the rumor. Standard algebraic calculation, c.f., [21], shows that the solution to the above defined recursive formula is . The expected number of steps after during which nodes nearly-informed at time become informed is . Therefore, the expected number of steps so that the rumor is read by all nodes is .

Theorem 3

The expected number of steps for rumor spreading, taken by protocol Pull in any synchronous execution on any network of diameter and maximum degree , is .

Proof: In this case, it holds the second case of Lemma 2. Hence, the corresponding recursive formula is . We set and by algebraic manipulation we obtain that .

Finally, let us recall the example that opens this Section. In that case, we showed that for the concatenation of -stars Pull algorithm requires at least steps to spread the rumor. Note that the upper bound given by Theorem 3 in that case is .

6 Conclusions

In this paper we formally introduced a new model for randomized rumor spreading, which encapsulates realistic behavior of nodes restricted by one operation on the message buffer at a time. We demonstrated differences between our model and the classical model without buffering, which is particularly visible in some non-regular types of graphs. These kinds of graphs might be important from practical perspective, as they model hierarchical topologies with dense end points that could be used in some future technologies such as the Internet of Things. Obtaining results for other specific classes of networks and communication tasks is the most important open direction.

The new model is also very challenging from mathematical perspective, as it combines in a non-trivial way different types of random processes, such as message queuing and rumor spreading. Therefore, tight estimates of rumor spreading time for specific classes of networks might be much more difficult to obtain than in the classical model. New generic methods of transferring results between the two models are also of great importance.

Finally, considering other variations of the basic protocols, especially Pull but also Push&Pull, and analyzing their performance in synchronous and asynchronous executions, is another perspective direction.

References

  • [1] Boyd, S., Ghosh, A., Prabhakar, B., Shah, D.: Randomized gossip algorithms. Information Theory, IEEE Transactions on 52(6) (june 2006) 2508 – 2530
  • [2] Censor-Hillel, K., Haeupler, B., Kelner, J.A., Maymounkov, P.: Global computation in a poorly connected world: fast rumor spreading with no dependence on conductance.

    In: Proceedings of the 44rd annual ACM symposium on Theory of computing. STOC ’12, ACM (2012) 961–970

  • [3] Censor-Hillel, K., Shachnai, H.: Fast information spreading in graphs with large weak conductance. In Randall, D., ed.: Proceedings of the Twenty-Second Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2011, San Francisco, California, USA, January 23-25, 2011. SODA’11, SIAM (2011) 440–448
  • [4] Chierichetti, F., Lattanzi, S., Panconesi, A.: Almost tight bounds for rumour spreading with conductance. In Schulman, L.J., ed.: Proceedings of the 42nd ACM Symposium on Theory of Computing, STOC 2010, Cambridge, Massachusetts, USA, 5-8 June 2010. STOC, ACM (2010) 399–408
  • [5] Chierichetti, F., Lattanzi, S., Panconesi, A.: Rumour spreading and graph conductance. In Charikar, M., ed.: Proceedings of the Twenty-First Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2010, Austin, Texas, USA, January 17-19, 2010. SODA’10, SIAM (2010) 1657–1663
  • [6] Chierichetti, F., Lattanzi, S., Panconesi, A.: Rumor spreading in social networks. Theor. Comput. Sci. 412(24) (2011) 2602–2610
  • [7] Chlebus, B.S., Diks, K., Pelc, A.: Fast gossiping with short unreliable messages. Discrete Applied Mathematics 53(1-3) (1994) 15–24
  • [8] Demers, A., Greene, D., Houser, C., Irish, W., Larson, J., Shenker, S., Sturgis, H., Swinehart, D., Terry, D.: Epidemic algorithms for replicated database maintenance. SIGOPS Oper. Syst. Rev. 22 (January 1988) 8–32
  • [9] Doerr, B., Fouz, M.: Asymptotically optimal randomized rumor spreading. In Aceto, L., Henzinger, M., Sgall, J., eds.: Automata, Languages and Programming - 38th International Colloquium, ICALP 2011, Zurich, Switzerland, July 4-8, 2011, Proceedings, Part II. Volume 6756 of Lecture Notes in Computer Science., Springer (2011) 502–513
  • [10] Elsässer, R.: On the communication complexity of randomized broadcasting in random-like graphs. In: Proceedings of the eighteenth annual ACM symposium on Parallelism in algorithms and architectures. SPAA ’06 (2006) 148–157
  • [11] Elsässer, R., Sauerwald, T.: Broadcasting vs. mixing and information dissemination on cayley graphs. In Thomas, W., Weil, P., eds.: STACS. Volume 4393 of Lecture Notes in Computer Science., Springer (2007) 163–174
  • [12] Elsässer, R., Sauerwald, T.: On the runtime and robustness of randomized broadcasting. Theor. Comput. Sci. 410(36) (2009) 3414–3427
  • [13] Feige, U., Peleg, D., Raghavan, P., Upfal, E.: Randomized broadcast in networks. Random Struct. Algorithms 1(4) (1990) 447–460
  • [14] Fountoulakis, N., Panagiotou, K.: Rumor spreading on random regular graphs and expanders. Random Structures & Algorithms (2012)
  • [15] Frieze, A.M., Grimmett, G.R.: The shortest-path problem for graphs with random arc-lengths. Discrete Applied Mathematics 10(1) (1985) 57–77
  • [16] Giakkoupis, G.: Tight bounds for rumor spreading in graphs of a given conductance. In Schwentick, T., Dürr, C., eds.: STACS. Volume 9 of LIPIcs., Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik (2011) 57–68
  • [17] Giakkoupis, G., Sauerwald, T.: Rumor spreading and vertex expansion. In Rabani, Y., ed.: Proceedings of the Twenty-Third Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2012, Kyoto, Japan, January 17-19, 2012. SODA’12, SIAM (2012) 1623–1641
  • [18] Harchol-Balter, M., Leighton, T., Lewin, D.: Resource discovery in distributed networks. In: Proceedings of the eighteenth annual ACM symposium on Principles of distributed computing. PODC ’99, ACM (1999) 229–237
  • [19] Karp, R., Schindelhauer, C., Shenker, S., Vocking, B.: Randomized rumor spreading. In: Proceedings of the 41st Annual Symposium on Foundations of Computer Science. (2000) 565–574
  • [20] Krumme, D.W., Cybenko, G., Venkataraman, K.N.: Gossiping in minimal time. SIAM J. Comput. 21(1) (1992) 111–139
  • [21] Mathematica 9, W.: Produced by Wolfram Research, Inc. http://www.wolfram.com/mathematica/
  • [22] Petrov, V.:

    Sums of independent random variables.

    Ergebnisse der Mathematik und ihrer Grenzgebiete. Springer-Verlag (1975)
  • [23] Pittel, B.: On spreading a rumor. SIAM J. Appl. Math. 47 (1987) 213–223
  • [24] Sauerwald, T.: On mixing and edge expansion properties in randomized broadcasting. Algorithmica 56 (2010) 51–88
  • [25] Sauerwald, T., Stauffer, A.: Rumor spreading and vertex expansion on regular graphs. In Randall, D., ed.: Proceedings of the Twenty-Second Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2011, San Francisco, California, USA, January 23-25, 2011. SODA’11, SIAM (2011) 462–475
  • [26] van Renesse, R., Minsky, Y., Hayden, M.: A gossip-style failure detection service. In: Proceedings of the IFIP International Conference on Distributed Systems Platforms and Open Distributed Processing. Middleware ’98, Springer-Verlag (1998) 55–70