Many protocols in distributed computing make use of dominating and connected dominating sets, for example for broadcasting and the computation of routing. Ad hoc networks impose an additional requirement that algorithms for the construction of such sets should be local in the sense that each node of the network should make decisions based only on the information obtained from nodes located a constant (independent of the size of the network) number of steps away from it. The focus of the present paper is on providing local, constant approximation, deterministic algorithms for the construction of dominating and connected dominating sets of a Unit Disk Graph (UDG) with location aware nodes (i.e., nodes that know their coordinates in the plane). The size of the constructed set, in the case of the dominating set, is shown to be 5 times the optimal, while for the connected dominating set 7.453 + ɛ the optimal, for any arbitrarily small ɛ> 0. These are the first local algorithms in the scientific literature whose time

We study the problem of computing the diameter of a network in a distributed way. The model of distributed computation we consider is: in each synchronous round, each node can transmit a different (but short) message to each of its neighbors. We provide an ˜ Ω(n) lower bound for the number of communication rounds needed, where n denotes the number of nodes in the network. This lower bound is valid even if the diameter of the network is a small constant. We also show that a (3/2 − ε)approximation of the diameter requires ˜ Ω ( √ n) rounds. Furthermore we use our new technique to prove an ˜ Ω ( √ n) lower bound on approximating the girth of a graph by a factor 2 − ε. Contact author:

Fraigniaud et al. (2006) introduced a new measure of difficulty for a distributed task in a network. The smallest number of bits of advice of a distributed problem is the smallest number of bits of information that has to be available to nodes in order to accomplish the task efficiently. Our paper deals with the number of bits of advice required to perform efficiently the graph searching problem in a distributed setting. In this variant of the problem, all searchers are initially placed at a particular node of the network. The aim of the team of searchers is to capture an invisible and arbitrarily fast fugitive in a monotone connected way, i.e., the cleared part of the graph is permanently connected, and never decreases while the search strategy is executed. We show that the minimum number of bits of advice permitting the monotone connected clearing of a network in a distributed setting is O(n log n), where n is the number of nodes of the network, and this bound is tight. More precisely, we first provide a labelling of the vertices of any graph G, using a total of O(n log n) bits, and a protocol using this labelling that enables clearing G in a monotone connected distributed way. Then, we show that this number of bits of advice is almost optimal: no protocol using an oracle providing o(n log n) bits of advice permits the monotone connected clearing of a network using the smallest number of searchers.

Distributed fault tolerance algorithms are used for many ultra-reliable systems. For example, aviation fly-by-wire and automotive drive-by-wire network protocols need to reliably deliver data despite the presence of faults. Careful design is required, since ultrareliable systems permit a failure rate on the order of just 10−9 failures per hour. Unfortunately, investing more effort at the design stage does not assure a more reliable product if no objective measurement technique is used at this stage. The key idea of this dissertation is to estimate the reliability of a service by measuring the probability that the algorithm’s maximum fault assumption will be violated. An algorithm’s maximum fault assumption states the number of active faults that can be tolerated. The service (and the system) may fail if this assumption is violated. The maximum fault assumption can be tested at design time, before costly design commitments have been made. This dissertation defines a methodology to measure the reliability of a service’s maximum fault assumption. The methodology is applied to clock synchronization and group membership services from three safety-critical protocols — the FlexRay Consortium’s

We explore the fundamental limits of distributed balls-intobins algorithms, i.e., algorithms where balls act in parallel, as separate agents. This problem was introduced by Adler et al., who showed that non-adaptive and symmetric algorithms cannot reliably perform better than a maximum bin load of Θ(loglogn/logloglogn) within the same number of rounds. We present an adaptive symmetric algorithm that achieves a bin load of two in log ∗ n + O(1) communication rounds using O(n) messages in total. Moreover, larger bin loads can be traded in for smaller time complexities. We prove a matching lower bound of (1−o(1))log ∗ n on the time complexity of symmetric algorithms that guarantee small bin loads at an asymptotically optimal message complexity of O(n). The essential preconditions of the proof are (i) a limit of O(n) on the total number of messages sent by the algorithm and (ii) anonymity of bins, i.e., the port numberings of balls are not globally consistent. In order to show that our technique yields indeed tight bounds, we provide for each assumption an algorithm violating it, in turn achieving a constant maximum bin load in constant time. As an application, we consider the following problem. Given a fully connected graph of n nodes, where each node needs to send and receive up to n messages, and in each round each node may send one message over each link, deliver all messages as quickly as possible to their destinations. We give a simple and robust algorithm of time complexity O(log ∗ n) for this task and provide a generalization to the case where all nodes initially hold arbitrary sets of messages. Completing the picture, we give a less practical, but asymptotically optimal algorithm terminating within O(1) rounds. All these bounds hold with high probability.

Abstract. Downward communication is a popular push-based scheme to forward messages from headquarters to front-line staff in a large-scaled company. With the maturing intranet and web technology, broadcasting algorithms, including pull-based and push-based broadcasting algorithms, it is feasible to send downward messages through web-based design by sending packets on a network. To avoid losing messages due to the traditional push-based method, companies adopt a pull-based algorithm to build up the broadcasting system. However, although the pull-based method can ensure that a message is received, it has a critical problem, the network is always congested. The push-based method can avoid congesting the network, but it needs a specific robust design to ensure that the message reaches its destination. Hence, adopting only a pull-based or a push-based broadcasting algorithm is no longer feasible especially not for a large-scaled company with complex network architecture. To ensure that every receiver will read downward messages thereby reducing the consumption of network bandwidth, this work proposes a robust web-based push- and pull-based broadcasting system for sending downward messages. This proposed system was successfully applied to a large-scaled company for a one-year period.

This paper introduces solo-valency, a variation on the valency proof technique originated by Fischer, Lynch, and Paterson. The new technique focuses on critical events that influence the responses of solo runs by individual operations, rather than on critical events that influence a protocol’s single decision value. It allows us to derive √ n lower bounds on the time to perform an operation for lock-free implementations of concurrent objects such as linearizable queues, stacks, sets, hash tables, counters, approximate agreement, and more. Time is measured as the number of distinct base objects accessed and the number of stalls caused by contention in accessing memory, incurred by a process as it performs a single operation. We introduce the influence level metric that quantifies the extent to which the response of a solo execution of one process can be changed by other processes. We then prove the existence of a relationship between the space complexity, latency, contention and influence level of all lock-free object implementations. Our results are broad in that they hold for implementations that may use any collection of read-modify-write operations in addition to read and write, and in that they apply even if base objects have unbounded size. 1

anonymous function computation in

We study communication complexity of consensus in synchronous message-passing systems with processes prone to crashes. The goal in the consensus problem is to have all the nonfaulty processes agree on a common value from among the input ones, after each process has been initialized with a binary input value. The system consists of n processes and it is assumed that at most t < n processes crash in an execution. A consensus algorithm that tolerates up to t failures is called fast when its time complexity is O(t). All the previously known fast deterministic consensus solutions sent Ω(n 2) bits in messages. We give a fast deterministic consensus algorithm that has processes send only O(n log 4 n) bits. In our solution, processes exchange messages according to topologies of overlay graphs that have suitable robustness and connectivity properties related to graph expansion.

We establish the necessary conditions for solving wait-free, eventually fair mutual exclusion in message-passing environments subject to crash faults. Wait-freedom guarantees that every correct hungry process eventually enters its critical section. Eventual fairness guarantees that every run has an infinite suffix during which no correct hungry process is overtaken more than b times. Previously, we showed that the eventually perfect failure detector (3P) is sufficient to solve waitfree, eventually fair mutual exclusion. The present paper completes this reduction by proving that 3P is also necessary, and hence is the weakest oracle to solve this problem. Our construction uses wait-free, eventually fair exclusion to build an elastic clock that provides an eventually reliable time-out mechanism for detecting crashed processes. This lease-based implementation of 3P uses bounded-capacity, non-FIFO channels, and is crash-quiescent. The construction itself may be of independent interest, insofar as it demonstrates how fairness properties can be sufficient to encapsulate temporal assumptions about partial synchrony.