1,574 research outputs found
Distributed Deterministic Edge Coloring using Bounded Neighborhood Independence
We study the {edge-coloring} problem in the message-passing model of
distributed computing. This is one of the most fundamental and well-studied
problems in this area. Currently, the best-known deterministic algorithms for
(2Delta -1)-edge-coloring requires O(Delta) + log-star n time \cite{PR01},
where Delta is the maximum degree of the input graph. Also, recent results of
\cite{BE10} for vertex-coloring imply that one can get an
O(Delta)-edge-coloring in O(Delta^{epsilon} \cdot \log n) time, and an
O(Delta^{1 + epsilon})-edge-coloring in O(log Delta log n) time, for an
arbitrarily small constant epsilon > 0.
In this paper we devise a drastically faster deterministic edge-coloring
algorithm. Specifically, our algorithm computes an O(Delta)-edge-coloring in
O(Delta^{epsilon}) + log-star n time, and an O(Delta^{1 +
epsilon})-edge-coloring in O(log Delta) + log-star n time. This result improves
the previous state-of-the-art {exponentially} in a wide range of Delta,
specifically, for 2^{Omega(\log-star n)} \leq Delta \leq polylog(n). In
addition, for small values of Delta our deterministic algorithm outperforms all
the existing {randomized} algorithms for this problem.
On our way to these results we study the {vertex-coloring} problem on the
family of graphs with bounded {neighborhood independence}. This is a large
family, which strictly includes line graphs of r-hypergraphs for any r = O(1),
and graphs of bounded growth. We devise a very fast deterministic algorithm for
vertex-coloring graphs with bounded neighborhood independence. This algorithm
directly gives rise to our edge-coloring algorithms, which apply to {general}
graphs.
Our main technical contribution is a subroutine that computes an
O(Delta/p)-defective p-vertex coloring of graphs with bounded neighborhood
independence in O(p^2) + \log-star n time, for a parameter p, 1 \leq p \leq
Delta
Deterministic Distributed Edge-Coloring via Hypergraph Maximal Matching
We present a deterministic distributed algorithm that computes a
-edge-coloring, or even list-edge-coloring, in any -node graph
with maximum degree , in rounds. This answers
one of the long-standing open questions of \emph{distributed graph algorithms}
from the late 1980s, which asked for a polylogarithmic-time algorithm. See,
e.g., Open Problem 4 in the Distributed Graph Coloring book of Barenboim and
Elkin. The previous best round complexities were by
Panconesi and Srinivasan [STOC'92] and
by Fraigniaud, Heinrich, and Kosowski [FOCS'16]. A corollary of our
deterministic list-edge-coloring also improves the randomized complexity of
-edge-coloring to poly rounds.
The key technical ingredient is a deterministic distributed algorithm for
\emph{hypergraph maximal matching}, which we believe will be of interest beyond
this result. In any hypergraph of rank --- where each hyperedge has at most
vertices --- with nodes and maximum degree , this algorithm
computes a maximal matching in rounds.
This hypergraph matching algorithm and its extensions lead to a number of
other results. In particular, a polylogarithmic-time deterministic distributed
maximal independent set algorithm for graphs with bounded neighborhood
independence, hence answering Open Problem 5 of Barenboim and Elkin's book, a
-round deterministic
algorithm for -approximation of maximum matching, and a
quasi-polylogarithmic-time deterministic distributed algorithm for orienting
-arboricity graphs with out-degree at most ,
for any constant , hence partially answering Open Problem 10 of
Barenboim and Elkin's book
On the Complexity of Distributed Splitting Problems
One of the fundamental open problems in the area of distributed graph
algorithms is the question of whether randomization is needed for efficient
symmetry breaking. While there are fast, -time randomized
distributed algorithms for all of the classic symmetry breaking problems, for
many of them, the best deterministic algorithms are almost exponentially
slower. The following basic local splitting problem, which is known as the
\emph{weak splitting} problem takes a central role in this context: Each node
of a graph has to be colored red or blue such that each node of
sufficiently large degree has at least one node of each color among its
neighbors. Ghaffari, Kuhn, and Maus [STOC '17] showed that this seemingly
simple problem is complete w.r.t. the above fundamental open question in the
following sense: If there is an efficient -time determinstic
distributed algorithm for weak splitting, then there is such an algorithm for
all locally checkable graph problems for which an efficient randomized
algorithm exists. In this paper, we investigate the distributed complexity of
weak splitting and some closely related problems. E.g., we obtain efficient
algorithms for special cases of weak splitting, where the graph is nearly
regular. In particular, we show that if and are the minimum
and maximum degrees of and if , weak splitting can
be solved deterministically in time
. Further, if and , there is a
randomized algorithm with time complexity
Gunrock: GPU Graph Analytics
For large-scale graph analytics on the GPU, the irregularity of data access
and control flow, and the complexity of programming GPUs, have presented two
significant challenges to developing a programmable high-performance graph
library. "Gunrock", our graph-processing system designed specifically for the
GPU, uses a high-level, bulk-synchronous, data-centric abstraction focused on
operations on a vertex or edge frontier. Gunrock achieves a balance between
performance and expressiveness by coupling high performance GPU computing
primitives and optimization strategies with a high-level programming model that
allows programmers to quickly develop new graph primitives with small code size
and minimal GPU programming knowledge. We characterize the performance of
various optimization strategies and evaluate Gunrock's overall performance on
different GPU architectures on a wide range of graph primitives that span from
traversal-based algorithms and ranking algorithms, to triangle counting and
bipartite-graph-based algorithms. The results show that on a single GPU,
Gunrock has on average at least an order of magnitude speedup over Boost and
PowerGraph, comparable performance to the fastest GPU hardwired primitives and
CPU shared-memory graph libraries such as Ligra and Galois, and better
performance than any other GPU high-level graph library.Comment: 52 pages, invited paper to ACM Transactions on Parallel Computing
(TOPC), an extended version of PPoPP'16 paper "Gunrock: A High-Performance
Graph Processing Library on the GPU
Local Conflict Coloring
Locally finding a solution to symmetry-breaking tasks such as
vertex-coloring, edge-coloring, maximal matching, maximal independent set,
etc., is a long-standing challenge in distributed network computing. More
recently, it has also become a challenge in the framework of centralized local
computation. We introduce conflict coloring as a general symmetry-breaking task
that includes all the aforementioned tasks as specific instantiations ---
conflict coloring includes all locally checkable labeling tasks from
[Naor\&Stockmeyer, STOC 1993]. Conflict coloring is characterized by two
parameters and , where the former measures the amount of freedom given
to the nodes for selecting their colors, and the latter measures the number of
constraints which colors of adjacent nodes are subject to.We show that, in the
standard LOCAL model for distributed network computing, if l/d \textgreater{}
\Delta, then conflict coloring can be solved in rounds in -node graphs with maximum degree
, where ignores the polylog factors in . The
dependency in~ is optimal, as a consequence of the lower
bound by [Linial, SIAM J. Comp. 1992] for -coloring. An important
special case of our result is a significant improvement over the best known
algorithm for distributed -coloring due to [Barenboim, PODC 2015],
which required rounds. Improvements for other
variants of coloring, including -list-coloring,
-edge-coloring, -coloring, etc., also follow from our general
result on conflict coloring. Likewise, in the framework of centralized local
computation algorithms (LCAs), our general result yields an LCA which requires
a smaller number of probes than the previously best known algorithm for
vertex-coloring, and works for a wide range of coloring problems
Distributed Approximation of Maximum Independent Set and Maximum Matching
We present a simple distributed -approximation algorithm for maximum
weight independent set (MaxIS) in the model which completes
in rounds, where is the maximum
degree, is the number of rounds needed to compute a maximal
independent set (MIS) on , and is the maximum weight of a node. %Whether
our algorithm is randomized or deterministic depends on the \texttt{MIS}
algorithm used as a black-box.
Plugging in the best known algorithm for MIS gives a randomized solution in
rounds, where is the number of nodes.
We also present a deterministic -round algorithm based
on coloring.
We then show how to use our MaxIS approximation algorithms to compute a
-approximation for maximum weight matching without incurring any additional
round penalty in the model. We use a known reduction for
simulating algorithms on the line graph while incurring congestion, but we show
our algorithm is part of a broad family of \emph{local aggregation algorithms}
for which we describe a mechanism that allows the simulation to run in the
model without an additional overhead.
Next, we show that for maximum weight matching, relaxing the approximation
factor to () allows us to devise a distributed algorithm
requiring rounds for any constant
. For the unweighted case, we can even obtain a
-approximation in this number of rounds. These algorithms are
the first to achieve the provably optimal round complexity with respect to
dependency on
- …