Distributed Coloring of Graphs with an Optimal Number of Colors

This paper studies sufficient conditions to obtain efficient distributed algorithms coloring graphs optimally (i.e. with the minimum number of colors) in the LOCAL model of computation. Most of the work on distributed vertex coloring so far has focused on coloring graphs of maximum degree Delta with at most Delta+1 colors (or Delta colors when some simple obstructions are forbidden). When Delta is sufficiently large and c >= Delta-k_Delta+1, for some integer k_Delta ~~ sqrt{Delta}-2, we give a distributed algorithm that given a c-colorable graph G of maximum degree Delta, finds a c-coloring of G in min{O((log Delta)^{13/12}log n), 2^{O(log Delta+sqrt{log log n})}} rounds, with high probability. The lower bound Delta-k_Delta+1 is best possible in the sense that for infinitely many values of Delta, we prove that when chi(G) = Delta-k_Delta deciding whether chi(G) <= c is in P, while Embden-Weinert et al. proved that for c <= Delta-k_Delta-1, the same problem is NP-complete. Note that the sequential and distributed thresholds differ by one. Our first result covers the case where the chromatic number of the graph ranges between Delta-sqrt{Delta} and Delta+1. Our second result covers a larger range, but gives a weaker bound on the number of colors: For any sufficiently large Delta, and Omega(log Delta) 0, with a randomized algorithm running in O(log n/log log n) rounds with high probability

Bounds for self-stabilization in unidirectional networks

A distributed algorithm is self-stabilizing if after faults and attacks hit the system and place it in some arbitrary global state, the systems recovers from this catastrophic situation without external intervention in finite time. Unidirectional networks preclude many common techniques in self-stabilization from being used, such as preserving local predicates. In this paper, we investigate the intrinsic complexity of achieving self-stabilization in unidirectional networks, and focus on the classical vertex coloring problem. When deterministic solutions are considered, we prove a lower bound of $n$ states per process (where $n$ is the network size) and a recovery time of at least $n(n-1)/2$ actions in total. We present a deterministic algorithm with matching upper bounds that performs in arbitrary graphs. When probabilistic solutions are considered, we observe that at least $\Delta + 1$ states per process and a recovery time of $\Omega(n)$ actions in total are required (where $\Delta$ denotes the maximal degree of the underlying simple undirected graph). We present a probabilistically self-stabilizing algorithm that uses $\mathtt{k}$ states per process, where $\mathtt{k}$ is a parameter of the algorithm. When $\mathtt{k}=\Delta+1$, the algorithm recovers in expected $O(\Delta n)$ actions. When $\mathtt{k}$ may grow arbitrarily, the algorithm recovers in expected O(n) actions in total. Thus, our algorithm can be made optimal with respect to space or time complexity

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, $\text{poly}\log n$-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 $G=(V,E)$ 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 $\text{poly}\log n$-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 $\delta$ and $\Delta$ are the minimum and maximum degrees of $G$ and if $\delta=\Omega(\log n)$, weak splitting can be solved deterministically in time $O\big(\frac{\Delta}{\delta}\cdot\text{poly}(\log n)\big)$. Further, if $\delta = \Omega(\log\log n)$ and $\Delta\leq 2^{\varepsilon\delta}$, there is a randomized algorithm with time complexity $O\big(\frac{\Delta}{\delta}\cdot\text{poly}(\log\log n)\big)$

Between 2- and 3-colorability

We consider the question of the existence of homomorphisms between $G_{n,p}$ and odd cycles when $p=c/n,\,1<c\leq 4$. We show that for any positive integer $\ell$, there exists $\epsilon=\epsilon(\ell)$ such that if $c=1+\epsilon$ then w.h.p. $G_{n,p}$ has a homomorphism from $G_{n,p}$ to $C_{2\ell+1}$ so long as its odd-girth is at least $2\ell+1$. On the other hand, we show that if $c=4$ then w.h.p. there is no homomorphism from $G_{n,p}$ to $C_5$. Note that in our range of interest, $\chi(G_{n,p})=3$ w.h.p., implying that there is a homomorphism from $G_{n,p}$ to $C_3$

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