HPGA: A High-Performance Graph Analytics Framework on the GPU

Abstract

pages. https://doi.org/10. 1145/nnnnnnn.nnnnnnn High-performance implementations of graph algorithms are challenging to implement on new parallel hardware such as GPUs because of three challenges: (1) the difficulty of coming up with graph building blocks, (2) load imbalance on parallel hardware, and (3) graph problems having low arithmetic intensity. To address some of these challenges, GraphBLAS is an innovative, on-going effort by the graph analytics community to propose building blocks based in sparse linear algebra, which will allow graph algorithms to be expressed in a performant, succinct, composable and portable manner. In this paper, we examine the performance challenges of a linear-algebra-based approach to building graph frameworks and describe new design principles for overcoming these bottlenecks. Among the new design principles is exploiting input sparsity, which allows users to write graph algorithms without specifying push and pull direction. Exploiting output sparsity allows users to tell the backend which values of the output in a single vectorized computation they do not want computed. Load-balancing is an important feature for balancing work amongst parallel workers. We describe the important load-balancing features for handling graphs with different characteristics. The design principles described in this paper have been implemented in "GraphBLAST", the first open-source linear algebra-based graph framework on GPU targeting high-performance computing. The results show that on a single GPU, GraphBLAST has on average at least an order of magnitude speedup over previous GraphBLAS implementations SuiteSparse and GBTL, comparable performance to the fastest GPU hardwired primitives and shared-memory graph frameworks Ligra and Gunrock, and better performance than any other GPU graph framework, while offering a simpler and more concise programming model.

FastSV: A Distributed-Memory Connected Component Algorithm with Fast Convergence

“…FastSV attains high performance by employing scalable GraphBLAS operations and optimized communication. Given the generic nature of our algorithm, it can be easily implemented for any computing platforms such as using Graph-BLAST [28] for GPUs and can be programmed in most programming languages such as using pygraphblas (https://github.com/michelp/pygraphblas) in Python.…”

Parallel algorithms for finding connected components using linear algebra

“…In terms of reducing the number of actual operations performed, we plan to utilize the automatic direction optimization feature of GraphBLAST [41] in order to be competitive with Ligra on very sparse graphs as well. Porting our code to Graph-BLAST will also enable LACC to seamlessly run on GPUs.…”

“…The GrB mxv function within SuiteSparse:GraphBLAS does not automatically implement this fea- ture that would switch search direction depending on the sparsity of input and output vectors. This feature, however, is implemented in GraphBLAST [41] and we expect it to be available soon in other GraphBLAS-inspired libraries. LACC is approximately 2× to 3× slower than FastSV and Ligra.…”

HPGraph: High-Performance Graph Analytics with Productivity on the GPU

“…A variety of optimizations have been performed to improve the performance of SPMV [20], one of the most important operations in high-performance computing (HPC), on GPUs. However, as far as we know, existing matrix-based graph analytics on GPUs achieve nowhere near the same performance as these optimized libraries [21,22]. In this work, our goal is to achieve high performance (optimized sparse matrix backend) for graph analytics as well as the productivity of vertex programming (such as vertex programming for users) for GPUs.…”