2,831 research outputs found

    An Optimal Self-Stabilizing Firing Squad

    Full text link
    Consider a fully connected network where up to tt processes may crash, and all processes start in an arbitrary memory state. The self-stabilizing firing squad problem consists of eventually guaranteeing simultaneous response to an external input. This is modeled by requiring that the non-crashed processes "fire" simultaneously if some correct process received an external "GO" input, and that they only fire as a response to some process receiving such an input. This paper presents FireAlg, the first self-stabilizing firing squad algorithm. The FireAlg algorithm is optimal in two respects: (a) Once the algorithm is in a safe state, it fires in response to a GO input as fast as any other algorithm does, and (b) Starting from an arbitrary state, it converges to a safe state as fast as any other algorithm does.Comment: Shorter version to appear in SSS0

    Distributed Computation of Connected Dominating Set for Multi-Hop Wireless Networks

    Get PDF
    AbstractIn large wireless multi-hop networks, routing is a main issue as they include many nodes that span over relatively a large area. In such a scenario, finding smallest set of dominant nodes for forwarding packets would be a good approach for better communication. Connected dominating set (CDS) computation is one of the method to find important nodes in the network. As CDS computation is an NP problem, several approximation algorithms are available but these algorithms have high message complexity. This paper discusses the design and implementation of a distributed algorithm to compute connected dominating sets in a wireless network with the help of network spectral properties. Based on local neighborhood, each node in the network finds its ego centric network. To identify dominant nodes, it uses bridge centrality value of ego centric network. A distributed algorithm is proposed to find nodes to connect dominant nodes which approximates CDS. The algorithm has been applied on networks with different network sizes and varying edge probability distributions. The algorithm outputs 40% important nodes in the network to form back haul communication links with an approximation ratio ≤ 0.04 * ∂ + 1, where ∂ is the maximum node degree. The results confirm that the algorithm contributes to a better performance with reduced message complexity

    Finding Optimal 2-Packing Sets on Arbitrary Graphs at Scale

    Full text link
    A 2-packing set for an undirected graph G=(V,E)G=(V,E) is a subset SV\mathcal{S} \subset V such that any two vertices v1,v2Sv_1,v_2 \in \mathcal{S} have no common neighbors. Finding a 2-packing set of maximum cardinality is a NP-hard problem. We develop a new approach to solve this problem on arbitrary graphs using its close relation to the independent set problem. Thereby, our algorithm red2pack uses new data reduction rules specific to the 2-packing set problem as well as a graph transformation. Our experiments show that we outperform the state-of-the-art for arbitrary graphs with respect to solution quality and also are able to compute solutions multiple orders of magnitude faster than previously possible. For example, we are able to solve 63% of our graphs to optimality in less than a second while the competitor for arbitrary graphs can only solve 5% of the graphs in the data set to optimality even with a 10 hour time limit. Moreover, our approach can solve a wide range of large instances that have previously been unsolved

    Approximating max-min linear programs with local algorithms

    Full text link
    A local algorithm is a distributed algorithm where each node must operate solely based on the information that was available at system startup within a constant-size neighbourhood of the node. We study the applicability of local algorithms to max-min LPs where the objective is to maximise minkvckvxv\min_k \sum_v c_{kv} x_v subject to vaivxv1\sum_v a_{iv} x_v \le 1 for each ii and xv0x_v \ge 0 for each vv. Here ckv0c_{kv} \ge 0, aiv0a_{iv} \ge 0, and the support sets Vi={v:aiv>0}V_i = \{v : a_{iv} > 0 \}, Vk={v:ckv>0}V_k = \{v : c_{kv}>0 \}, Iv={i:aiv>0}I_v = \{i : a_{iv} > 0 \} and Kv={k:ckv>0}K_v = \{k : c_{kv} > 0 \} have bounded size. In the distributed setting, each agent vv is responsible for choosing the value of xvx_v, and the communication network is a hypergraph H\mathcal{H} where the sets VkV_k and ViV_i constitute the hyperedges. We present inapproximability results for a wide range of structural assumptions; for example, even if Vi|V_i| and Vk|V_k| are bounded by some constants larger than 2, there is no local approximation scheme. To contrast the negative results, we present a local approximation algorithm which achieves good approximation ratios if we can bound the relative growth of the vertex neighbourhoods in H\mathcal{H}.Comment: 16 pages, 2 figure

    Byzantine Approximate Agreement on Graphs

    Get PDF
    Consider a distributed system with n processors out of which f can be Byzantine faulty. In the approximate agreement task, each processor i receives an input value x_i and has to decide on an output value y_i such that 1) the output values are in the convex hull of the non-faulty processors\u27 input values, 2) the output values are within distance d of each other. Classically, the values are assumed to be from an m-dimensional Euclidean space, where m >= 1. In this work, we study the task in a discrete setting, where input values with some structure expressible as a graph. Namely, the input values are vertices of a finite graph G and the goal is to output vertices that are within distance d of each other in G, but still remain in the graph-induced convex hull of the input values. For d=0, the task reduces to consensus and cannot be solved with a deterministic algorithm in an asynchronous system even with a single crash fault. For any d >= 1, we show that the task is solvable in asynchronous systems when G is chordal and n > (omega+1)f, where omega is the clique number of G. In addition, we give the first Byzantine-tolerant algorithm for a variant of lattice agreement. For synchronous systems, we show tight resilience bounds for the exact variants of these and related tasks over a large class of combinatorial structures
    corecore