Single Source Shortest Path Research Articles

Fault-Tolerant Subgraph for Single-Source Reachability: General and Optimal

Let $G$ be a directed graph with $n$ vertices, $m$ edges, and a designated source vertex $s$. We address the problem of single-source reachability (SSR) from $s$ in the presence of failures of vertices/edges. We show that for every $k\geq1$, there is a subgraph $H$ of $G$ with at most $2^kn$ edges that preserves the reachability from $s$ even after the failure of any $k$ edges. Formally, given a set $F$ of $k$ edges, a vertex $v\in V(G)$ is reachable from $s$ in $G\setminus F$ if and only if $v$ is reachable from $s$ in $H\setminus F$. We call $H$ a $k$-fault tolerant reachability subgraph ($\textsc{$k$-FTRS}$). We also prove a matching lower bound of $\Omega(2^kn)$ edges for such subgraphs that holds for all $n,k$ with $2^k\leq n$. Our results extend to vertex failures without any extra overhead. The construction of ${$k$-FTRS}$ is interesting from several different perspectives. From the Graph theory perspective it reveals a separation between SSR and single-source shortest paths (SSSP) in directed grap...

Utilization of OpenCL for Large Graph Problems on Graphics Processing Unit

During recent years graphics processing unit (GPU) has become an inexpensive high-performance parallel computing units and general purpose computation on graphics processing unit (GPGPU) become an alternative of conventional CPU computation, which provide massive parallel computation capability to a normal computer over a system which uses only CPU. This paper investigates the performance of the algorithm for the solution of single source shortest path (SSSP) problem, all pair shortest path (APSP) problem and graph coloring problem for large graph on GPU regardless of a specific vendor. The application programming interface (API) used for programming in graphic processing unit is open compute language (OpenCL), it is a specification for heterogeneous computing. The performance of solutions on GPU is compared with the solution on CPU in term of their execution time. The result indicates the significant improvement in the performance of the solutions on GPU over solutions on CPU.

WolfPath: Accelerating Iterative Traversing-Based Graph Processing Algorithms on GPU

There is the significant interest nowadays in developing the frameworks of parallelizing the processing for the large graphs such as social networks, Web graphs, etc. Most parallel graph processing frameworks employ iterative processing model. However, by benchmarking the state-of-art GPU-based graph processing frameworks, we observed that the performance of iterative traversing-based graph algorithms (such as Bread First Search, Single Source Shortest Path and so on) on GPU is limited by the frequent data exchange between host and GPU. In order to tackle the problem, we develop a GPU-based graph framework called WolfPath to accelerate the processing of iterative traversing-based graph processing algorithms. In WolfPath, the iterative process is guided by the graph diameter to eliminate the frequent data exchange between host and GPU. To accomplish this goal, WolfPath proposes a data structure called Layered Edge list to represent the graph, from which the graph diameter is known before the start of graph processing. In order to enhance the applicability of our WolfPath framework, a graph preprocessing algorithm is also developed in this work to convert any graph into the format of the Layered Edge list. We conducted extensive experiments to verify the effectiveness of WolfPath. The experimental results show that WolfPath achieves significant speedup over the state-of-art GPU-based in-memory and out-of-memory graph processing frameworks.

Broadcast tree construction framework in tactile internet via dynamic algorithm

Abstract Extremely low-latency and real-time communications are required in Tactile Internet to transfer physical tactile experiences remotely. In addition, its traffic has stringent requirements on bandwidth and quality of service (QoS). To minimize total costs of establishing the network and satisfy a pre-defined global upper delay-bound on the paths from the server to any other client for message broadcast in Tactile Internet, this paper presents a Rooted Delay-Constrained Minimum Spanning Tree (RDCMST) construction framework based on dynamic algorithm. The network is modeled as a connected weighted and undirected graph. Infeasible and suboptimal edges are discarded first by preprocessing techniques to reduce the processing complexity of the algorithm. Then the edges of the graph are processed based on a dynamic graph algorithm, which can maintain a single-source shortest path tree for the online edge deletions, such that total costs can be minimized while ensuring the delay-constraint and the tree structure. Experimental results show that our proposed approach greatly outperforms existing competing RDCMST formation algorithms, in terms of both average cost and stability of solutions.

Sublinear-Time Maintenance of Breadth-First Spanning Trees in Partially Dynamic Networks

We study the problem of maintaining a breadth-first spanning tree (BFS tree) in partially dynamic distributed networks modeling a sequence of either failures or additions of communication links (but not both). We present deterministic (1+ϵ)-approximation algorithms whose amortized time (over some number of link changes) is sublinear in D , the maximum diameter of the network. Our technique also leads to a deterministic (1+ϵ)-approximate incremental algorithm for single-source shortest paths in the sequential (usual RAM) model. Prior to our work, the state of the art was the classic exact algorithm of Even and Shiloach (1981), which is optimal under some assumptions (Roditty and Zwick 2011; Henzinger et al. 2015). Our result is the first to show that, in the incremental setting, this bound can be beaten in certain cases if some approximation is allowed.

EmptyHeaded

There are two types of high-performance graph processing engines: low- and high-level engines. Low-level engines (Galois, PowerGraph, Snap) provide optimized data structures and computation models but require users to write low-level imperative code, hence ensuring that efficiency is the burden of the user. In high-level engines, users write in query languages like datalog (SociaLite) or SQL (Grail). High-level engines are easier to use but are orders of magnitude slower than the low-level graph engines. We present EmptyHeaded, a high-level engine that supports a rich datalog-like query language and achieves performance comparable to that of low-level engines. At the core of EmptyHeaded’s design is a new class of join algorithms that satisfy strong theoretical guarantees, but have thus far not achieved performance comparable to that of specialized graph processing engines. To achieve high performance, EmptyHeaded introduces a new join engine architecture, including a novel query optimizer and execution engine that leverage single-instruction multiple data (SIMD) parallelism. With this architecture, EmptyHeaded outperforms high-level approaches by up to three orders of magnitude on graph pattern queries, PageRank, and Single-Source Shortest Paths (SSSP) and is an order of magnitude faster than many low-level baselines. We validate that EmptyHeaded competes with the best-of-breed low-level engine (Galois), achieving comparable performance on PageRank and at most 3× worse performance on SSSP. Finally, we show that the EmptyHeaded design can easily be extended to accommodate a standard resource description framework (RDF) workload, the LUBM benchmark. On the LUBM benchmark, we show that EmptyHeaded can compete with and sometimes outperform two high-level, but specialized RDF baselines (TripleBit and RDF-3X), while outperforming MonetDB by up to three orders of magnitude and LogicBlox by up to two orders of magnitude.

Scalable parallel graph algorithms with matrix–vector multiplication evaluated with queries

Graph problems are significantly harder to solve with large graphs residing on disk compared to main memory only. In this work, we study how to solve four important graph problems: reachability from a source vertex, single source shortest path, weakly connected components, and PageRank. It is well known that the aforementioned algorithms can be expressed as an iteration of matrix–vector multiplications under different semi-rings. Based on this mathematical foundation, we show how to express the computation with standard relational queries and then we study how to efficiently evaluate them in parallel in a shared-nothing architecture. We identify a common algorithmic pattern that unifies the four graph algorithms, considering a common mathematical foundation based on sparse matrix–vector multiplication. The net gain is that our SQL-based approach enables solving “big data” graph problems on parallel database systems, debunking common wisdom that they are cumbersome and slow. Using large social networks and hyper-link real data sets, we present performance comparisons between a columnar DBMS, an open-source array DBMS, and Spark’s GraphX.

Scalable Single Source Shortest Path Algorithms for Massively Parallel Systems

We consider the single-source shortest path (SSSP) problem: given an undirected graph with integer edge weights and a source vertex $v$ , find the shortest paths from $v$ to all other vertices. In this paper, we introduce a novel parallel algorithm, derived from the Bellman-Ford and Delta-stepping algorithms. We employ various pruning techniques, such as edge classification and direction-optimization, to dramatically reduce inter-node communication traffic, and we propose load balancing strategies to handle higher-degree vertices. These techniques are particularly effective on power-law graphs, as demonstrated by our extensive performance analysis. In the largest tested configuration, an R-MAT graph with $2^{38}$ vertices and $2^{42}$ edges on 32,768 Blue Gene/Q nodes, we have achieved a processing rate of three Trillion Edges Per Second (TTEPS), a four orders of magnitude improvement over the best published results.

Solving all-pairs shortest path by single-source computations: Theory and practice

Given an arbitrary directed graph G=(V,E) with non-negative edge lengths, we present an algorithm that computes all pairs shortest paths in time O(m∗n+mlgn+nTψ(m∗,n)), where m∗ is the number of different edges contained in shortest paths and Tψ(m∗,n) is the running time of an algorithm ψ solving the single-source shortest path problem (SSSP). This is a substantial improvement over a trivial n times application of ψ that runs in O(nTψ(m,n)). In our algorithm we use ψ as a black box and hence any improvement on ψ results also in improvement of our algorithm. A combination of our method, Johnson’s reweighting technique and topological sorting results in an O(m∗n+mlgn) all-pairs shortest path algorithm for directed acyclic graphs with arbitrary edge lengths. We also point out a connection between the complexity of a certain sorting problem defined on shortest paths and SSSP. Finally, we show how to improve the performance of the proposed algorithm in practice. We then empirically measure the running times of various all-pairs shortest path algorithms on randomly generated graph instances and obtain very promising results.

Incremental single-source shortest paths in digraphs with arbitrary positive arc weights

This paper studies the incremental single-source shortest paths (SSSP) problem in general digraphs with arbitrary positive arc weights. First, we examine several properties of single-source shortest paths in general digraphs with arbitrary positive arc weights, and devise a nontrivial local search algorithm LSA to handle a single arc weight increase in such a digraph, which takes at most O(n⋅max⁡{1,nlog⁡n/m}) expected update time where n is the number of nodes and m is the number of arcs in the digraph. LSA also works on undirected graphs.Furthermore, this paper analyzes the expected update time of LSA dealing with edge weight increases or edge deletions in Erdös–Rényi (a.k.a., G(n,p)) random graphs. For weighted G(n,p) random graphs with arbitrary positive edge weights, LSA takes at most O(h(Ts)) expected update time to deal with a single edge weight increase as well as O(pn2h(Ts)) total update time, where h(Ts) is the height of input SSSP tree Ts. For G(n,p) random graphs, LSA takes O(ln⁡n) expected update time to handle a single edge deletion as well as O(pn2ln⁡n) total update time when 20ln⁡n/n≤p<2ln⁡n/n, and O(1) expected update time to handle a single edge deletion as well as O(pn2) total update time when p>2ln⁡n/n. Specifically, LSA takes the least total update time of O(nln⁡nh(Ts)) for weighted G(n,p) random graphs with p=cln⁡n/n,c>1 as well as O(n3/2(ln⁡n)1/2) for G(n,p) random graphs with p=cln⁡n/n,c>2.

POSTER

In distributed computing, parallel overheads such as \emph{synchronization overhead} may hinder performance. We introduce the idea of \emph{Distributed Control} (DC) where global synchronization is reduced to \emph{termination detection} and each worker proceeds ahead optimistically, based on the local knowledge of the global computation. To avoid "wasted'' work, \DC relies on local work prioritization. However, the work order obtained by local prioritization is susceptible to interference from the runtime. We show that employing effective scheduling policies and optimizations in the runtime, in conjunction with eliminating global barriers, improves performance in two graph applications: single-source shortest paths and connected components.

EFS: Entropy First Search for Dynamic Shortest Path Problem in Large Sparse Graphs

Searching the dynamic shortest path is a hot topic recently. In this paper we proposed a new method to solve the dynamic single source shortest paths (SSSP) problem in sparse graphs. The main contributions are three: firstly, in the preprocessing stage, we use the unreachable and unstartable characteristics to avoid most of the non-solution path search. Secondly, Entropy first search (EFS) is introduced to speed up the search process in finding the possible shortest path and then the algorithm can converges as soon as possible. In addition, the update algorithm for dynamic shortest path search is proposed for practical use. The experiments in large random sparse graphs show the efficiency and benefits of the proposed method.

Hybrid Bellman–Ford–Dijkstra algorithm

We consider the single-source shortest paths problem in a digraph with negative edge costs allowed. A hybrid of the Bellman–Ford and Dijkstra algorithms is suggested, improving the running time bound of Bellman–Ford for graphs with a sparse distribution of negative cost edges. The algorithm iterates Dijkstra several times without re-initializing the tentative value d(v) at vertices. At most k+2 iterations solve the problem, if for any vertex reachable from the source, there exists a shortest path to it with at most k negative cost edges.In addition, a new, straightforward proof is suggested that the Bellman–Ford algorithm produces a shortest paths tree.

Modified Dijkstra’s Algorithm for Dense Graphs on GPU using CUDA

The objective of this research is to propose and implement a fast parallel Single source shortest path (SSSP) algorithm on Graphics Processing Unit (GPU) based highly parallel and cost effective platform for dense and complete graphs. The proposed algorithm is a variant of Dijkstra’s algorithm for SSSP calculation for complete and dense graphs. In place of relaxing all the edges of a selected node as in Dijkstra’s algorithm, it relaxes one-one selected edge of different nodes of the graph simultaneously at any iteration. This paper shows parallel implementation of both Dijkstra’s algorithm and our modified Dijkstra’s algorithm on a GPU-based machine. We evaluate these implementations on NVIDIA Tesla C2075 GPU- based machines. Parallel implementation of proposed modified Dijkstra’s algorithm gives a two to three times speed increase over a parallel Dijkstra’s algorithm on a GPU-based machine for complete and dense graphs. The proposed algorithm has minimized the number of edges relaxed by one parallel thread at any iteration of parallel Dijkstra’s algorithm.

A preference elicitation method based on bipartite graphical correlation and implicit trust

In the age of big data, information overload is getting worse. Most of the existing recommender systems which apply data analysis and behavioral analysis to make personal recommendation have suffered from the problem of low prediction accuracy. To address this problem, a new preference elicitation algorithm is developed by using bipartite graphical correlation and implicit trust. More precisely, to compute the bipartite graphical correlation, an improved single-source shortest path is firstly presented to get the shortest behavior path based on the user-item bipartite graph. While the Markov separation algorithm is employed to separate uncorrelated vertexes and obtain the values of bipartite graphical correlation. Secondly, the implicit trust is used to represent trust relationship between users and items which have no historical behaviors. Independent trust group is applied to represent the closed-loop path on the user-item bipartite graph, and a compute method is developed to get the values of implicit trust based on the trusty values of independent trust group and explicit trust. Finally, a weighted prediction method based on bipartite graphical correlation and implicit trust is employed to compute the final ratings. Our empirical experiments are performed on a sparse data set, the results of which have demonstrated that our method can achieve lower P@R and efficiently improve recommendation quality.

The Collection of The Main Issues for Wind Farm Optimisation in Complex Terrain

The paper aims at establishing the collection of the main issues for wind farm optimisation in complex terrain. To make wind farm cost effective, this paper briefly analyses the main factors influencing wind farm design in complex terrain and sets up a series of mathematical model that includes micro-siting, collector circuits, access roads design for optimization problems. The paper relies on the existing one year wind data in the wind farm area and uses genetic algorithm to optimize the micro-siting problem. After optimization of the turbine layout, single-source shortest path algorithm and minimum spanning tree algorithm are used to optimize collector circuits and access roads. The obtained results can provide important guidance for wind farms construction.

An Efficient Implementation of the Bellman-Ford Algorithm for Kepler GPU Architectures

Finding the shortest paths from a single source to all other vertices is a common problem in graph analysis. The Bellman-Ford's algorithm is the solution that solves such a single-source shortest path (SSSP) problem and better applies to be parallelized for many-core architectures. Nevertheless, the high degree of parallelism is guaranteed at the cost of low work efficiency, which, compared to similar algorithms in literature (e.g., Dijkstra's) involves much more redundant work and a consequent waste of power consumption. This article presents a parallel implementation of the Bellman-Ford algorithm that exploits the architectural characteristics of recent GPU architectures (i.e., NVIDIA Kepler, Maxwell) to improve both performance and work efficiency. The article presents different optimizations to the implementation, which are oriented both to the algorithm and to the architecture. The experimental results show that the proposed implementation provides an average speedup of $5 \times$ higher than the existing most efficient parallel implementations for SSSP, that it works on graphs where those implementations cannot work or are inefficient (e.g., graphs with negative weight edges, sparse graphs), and that it sensibly reduces the redundant work caused by the parallelization process.

Efficient Multistate Route Computation

A multi-state graph is defined as a graph where each edge is associated with a stochastic, rather than fixed, value. For cases where the stochastic value is discrete and represents a distance or time, an algorithm is presented which efficiently finds the single-source shortest paths and distances for all combinations of edge values. Infinite and negative weight values are allowed as long as there are no negative weight cycles. Efficiency is achieved by both leveraging dynamic programming and only finding solutions for the set of dominant states that correctly cover any possible edge metric setting for the graph. Although the method has exponential complexity in the worst case, some samples and example graphs are used to illustrate the savings over a brute-force combinatoric approach. Furthermore by leveraging some real-world assumptions, a pseudo-polynomial version is presented that can be applied to larger scale problems. The results of the method are then shown to enable the computation of most-likely shortest paths .

EmptyHeaded: A Relational Engine for Graph Processing.

There are two types of high-performance graph processing engines: low- and high-level engines. Low-level engines (Galois, PowerGraph, Snap) provide optimized data structures and computation models but require users to write low-level imperative code, hence ensuring that efficiency is the burden of the user. In high-level engines, users write in query languages like datalog (SociaLite) or SQL (Grail). High-level engines are easier to use but are orders of magnitude slower than the low-level graph engines. We present EmptyHeaded, a high-level engine that supports a rich datalog-like query language and achieves performance comparable to that of low-level engines. At the core of EmptyHeaded's design is a new class of join algorithms that satisfy strong theoretical guarantees but have thus far not achieved performance comparable to that of specialized graph processing engines. To achieve high performance, EmptyHeaded introduces a new join engine architecture, including a novel query optimizer and data layouts that leverage single-instruction multiple data (SIMD) parallelism. With this architecture, EmptyHeaded outperforms high-level approaches by up to three orders of magnitude on graph pattern queries, PageRank, and Single-Source Shortest Paths (SSSP) and is an order of magnitude faster than many low-level baselines. We validate that EmptyHeaded competes with the best-of-breed low-level engine (Galois), achieving comparable performance on PageRank and at most 3× worse performance on SSSP.

Exact Dominance Querying Algorithm on CP-nets

CP-nets (conditional preference networks) is a graphical model for representing qualitative conditional preference statements via ceteris paribus semantics interpretation. Dominance querying, the problem of determining whether an outcome is preferred to another on this graphical model, is of fundamental importance in preference querying. However, to date, the exact dominance querying algorithm with respect to any binaryvalued CP-nets has not been given, hence designing an exact dominance querying algorithm is quite necessary. Fortunately, we discover that dominance querying problem is essentially a single source shortest path problem, and the induced graph of CP-nets is a sparse graph, as a result, dominance querying problem can be solved by Johnson algorithm which is suitable for solving the single source shortest path problem on sparse graph. As a byproduct, this algorithm can determine least flip numbers if an outcome dominates another outcome. At last, we present results of experiments that demonstrate the feasibility of our approach to dominance querying on acyclic CP-nets.