Showing papers by "John Augustine published in 2022"

Brief Announcement: Distributed MST Computation in the Sleeping Model: Awake-Optimal Algorithms and Lower Bounds

Abstract: We study the distributed minimum spanning tree (MST) problem, a fundamental problem in distributed computing. It is well-known that distributed MST can be solved in Õ(D+√n) rounds in the standard CONGEST model (where n is the network size and D is the network diameter) and this is essentially the best possible round complexity (up to logarithmic factors). However, in resource-constrained networks such as wireless ad hoc and sensor networks, nodes spending so much time can lead to significant spending of resources such as energy. Motivated by the above consideration, we study distributed algorithms for MST under the sleeping model [Chatterjee et al., PODC 2020], a model for design and analysis of resource-efficient distributed algorithms. In the sleeping model, a node can be in one of two modes in any round --- sleeping or awake (unlike the traditional model where nodes are always awake). Only the rounds in which a node is awake are counted, while sleeping rounds are ignored. A node spends resources only in the awake rounds and hence the main goal is to minimize the awake complexity of a distributed algorithm, the worst-case number of rounds any node is awake. We present distributed MST algorithms that have optimal awake complexity with a matching lower bound. We also show that our awake-optimal algorithms have essentially the best possible round complexity by presenting a lower bound on the product of the awake and round complexity of any distributed algorithm (including randomized).

Distributed MST Computation in the Sleeping Model: Awake-Optimal Algorithms and Lower Bounds

Abstract: We study the distributed minimum spanning tree (MST) problem, a fundamental problem in distributed computing. It is well-known that distributed MST can be solved in ˜ O ( D + √ n ) rounds in the standard CONGEST model (where n is the network size and D is the network diameter) and this is essentially the best possible round complexity (up to logarithmic factors). However, in resource-constrained networks such as ad hoc wireless and sensor networks, nodes spending so much time can lead to significant spending of resources such as energy. Motivated by the above consideration, we study distributed algorithms for MST under the sleeping model [Chatterjee et al., PODC 2020], a model for design and analysis of resource-efficient distributed algorithms. In the sleeping model, a node can be in one of two modes in any round — sleeping or awake (unlike the traditional model where nodes are always awake). Only the rounds in which a node is awake are counted, while sleeping rounds are ignored. A node spends resources only in the awake rounds and hence the main goal is to minimize the awake complexity of a distributed algorithm, the worst-case number of rounds any node is awake. We present distributed MST algorithms that have optimal awake complexity with a matching lower bound. We also show that our awake-optimal algorithms have essentially the best possible round complexity by presenting a lower bound on the product of the awake and round complexity of any distributed algorithm (including randomized). Specifically, we show the following results: We show that both the above algorithms have optimal awake complexity by proving that Ω(log n ) is a lower bound on the awake complexity for computing an MST even for randomized algorithms. To better understand the relationship between awake and round complexities, we prove a lower bound 1 of ˜Ω( n ) on the product of round complexity and awake complexity for any distributed algorithm (even randomized) that outputs an MST. This lower bound shows that our randomized algorithm that has the optimal awake complexity of O (log n ) also has essentially the best possible round complexity of O ( n log n ).

A Fully-Distributed Scalable Peer-to-Peer Protocol for Byzantine-Resilient Distributed Hash Tables

Abstract: Performing computation in the presence of faulty and malicious nodes is a central problem in distributed computing. Over 35 years ago, Dwork, Peleg, Pippenger, and Upfal [STOC 1986, SICOMP 1988] studied the fundamental Byzantine agreement problem in sparse, bounded degree networks and presented the first protocol that achieved almost-everywhere agreement among good nodes. However, this protocol and several subsequent protocols including that of King, Saia, Sanwalani, and Vee [FOCS 2006] had the drawback that they were not fully-distributed - in those protocols, nodes are required to have initial knowledge of the entire network topology. This drawback makes such protocols not applicable to real-world communication networks such as peer-to-peer (P2P) networks, which are typically sparse and bounded degree and where nodes initially have only local knowledge of themselves and of their neighbors.

Distributed Graph Realizations

Abstract: We study graph realization problems for the first time from a distributed perspective. Graph realization problems are encountered in distributed construction of overlay networks that must satisfy certain degree or connectivity properties. We study them in the node capacitated clique (NCC) model of distributed computing, recently introduced for representing peer-to-peer overlay networks. We focus on two central variants, degree-sequence realization and minimum threshold-connectivity realization. In the degree sequence problem, each node $v$ v is associated with a degree $d(v)$ d ( v ) , and the resulting degree sequence is realizable if it is possible to construct an overlay network in which the degree of each node $v$ v is $d(v)$ d ( v ) . The minimum threshold-connectivity problem requires us to construct an overlay network that satisfies connectivity constraints specified between every pair of nodes. Overlay network realizations can be either explicit or implicit. Explicit realizations require both endpoints of any edge in the realized graph to be aware of the edge. In implicit realizations, on the other hand, at least one endpoint of each edge of the realized graph needs to be aware of the edge. The main realization algorithms we present are the following. (Note that all our algorithms are randomized Las Vegas algorithms unless specified otherwise. The stated running times hold with high probability.) 1) An $\tilde{O}(\min \lbrace \sqrt{m},\Delta \rbrace)$ O ˜ ( min { m , Δ } ) time algorithm for implicit realization of a degree sequence. Here, $\Delta = \max _v d(v)$ Δ = max v d ( v ) is the maximum degree and $m = (1/2) \sum _v d(v)$ m = ( 1 / 2 ) ∑ v d ( v ) is the number of edges in the final realization. 2) $\tilde{O}(\Delta)$ O ˜ ( Δ ) time algorithm for an explicit realization of a degree sequence. We first compute an implicit realization and then transform it into an explicit one in $\tilde{O}(\Delta)$ O ˜ ( Δ ) additional rounds. 3) An $\tilde{O}(\Delta)$ O ˜ ( Δ ) time algorithm for the threshold connectivity problem that obtains an explicit solution and an improved $\tilde{O}(1)$ O ˜ ( 1 ) algorithm for implicit realization when all nodes know each other’s IDs. These algorithms yield 2-approximations w.r.t. the number of edges. We complement our upper bounds with lower bounds to show that the above algorithms are tight up to factors of $\log n$ log n . Additionally, we provide algorithms for realizing trees (including a procedure for obtaining a tree with a minimal diameter), an $\tilde{O}(1)$ O ˜ ( 1 ) round algorithm for approximate degree sequence realization and finally an $O(\log ^2 n)$ O ( log 2 n ) algorithm for degree sequence realization in the non-preassigned case namely, where the input degree sequence may be permuted among the nodes.

Awake Complexity of Distributed Minimum Spanning Tree

Abstract: The awake complexity of a distributed algorithm measures the number of rounds in which a node is awake. When a node is not awake, it is sleeping and does not do any computation or communication and spends very little resources. Reducing the awake complexity of a distributed algorithm can be relevant in resource-constrained networks such as sensor networks, where saving energy of nodes is crucial. Awake complexity of many fundamental problems such as maximal independent set, maximal matching, coloring, and spanning trees have been studied recently. In this work, we study the awake complexity of the fundamental distributed minimum spanning tree (MST) problem and present the following results.

Recurrent Problems in the LOCAL model

Abstract: The paper considers the SUPPORTED model of distributed computing introduced by Schmid and Suomela [HotSDN’13], generalizing the LOCAL and CONGEST models. In this framework, multiple instances of the same problem, differing from each other by the subnetwork to which they apply, recur over time, and need to be solved efficiently online. To do that, one may rely on an initial preprocessing phase for computing some useful information. This preprocessing phase makes it possible, in some cases, to obtain improved distributed algorithms, overcoming locality-based time lower bounds. A first contribution of the current paper is expanding the spectrum of problem types to which the SUPPORTED model applies. In addition to subnetwork -defined recurrent problems, we introduce also recurrent problems of two additional types: (i) instances defined by partial client sets , and (ii) instances defined by partially fixed outputs . Our second contribution is exploring and illustrating the versatility and applicabil-ity of the SUPPORTED framework via examining new recurrent variants of three classical graph problems. The first problem is Minimum Client Dominating Set ( CDS ) , a recurrent version of the classical dominating set problem with each recurrent instance requiring us to dominate a partial client set. We provide a constant time approximation scheme for the CDS problem on trees and planar graphs, overcoming the Ω(log ∗ n ) based locality lower bound. The second problem is Color Completion ( CC ) , a recurrent version of the coloring problem in which each recurrent instance comes with a partially fixed coloring (of some of the vertices) that must be completed. We study the minimum number of new colors and the minimum total number of colors necessary for completing this task. We show that it is not possible to find a constant time approximation scheme for the minimum number of additional colors required to complete the precoloring. On the positive side, we provide an algorithm that computes a 2-approximation for the total number of colors used in the completed coloring (

Guarding Polygons with Holes

Abstract: We study the Cooperative Guarding problem for polygons with holes in a mobile multi-agents setting. Given a set of agents, initially deployed at a point in a polygon with n vertices and h holes, we require the agents to collaboratively explore and position themselves in such a way that every point in the polygon is visible to at least one agent and that the set of agents are visibly connected. We study the problem under two models of computation, one in which the agents can compute exact distances and angles between two points in its visibility, and one in which agents can only compare distances and angles. In the stronger model, we provide a deterministic O(n) round algorithm to compute such a cooperative guard set while not requiring more than n+h 2 agents and O(log n) bits of persistent memory per agent. In the weaker model, we provide an O(n) round algorithm, that does not require more than n+2h 2 agents.