Making pull-based graph processing performant

Grossman, Samuel; Litz, Heiner; Kozyrakis, Christos

doi:10.1145/3178487.3178506

Cited by 39 publications

(43 citation statements)

References 44 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Gemini is a distributed graph processing system with notable shared-machine performance ]. Compared to existing frameworks, Grazelle has the fastest PR and CC using edge list vectorization, inner loop parallelism, and NUMA optimizations [Grossman et al 2018]. Table 7 shows the execution time of GraphIt and other systems.…”

Section: Datasetmentioning

confidence: 99%

GraphIt: a high-performance graph DSL

Zhang

Yang

Baghdadi

et al. 2018

Proc. ACM Program. Lang.

153

View full text Add to dashboard Cite

The performance bottlenecks of graph applications depend not only on the algorithm and the underlying hardware, but also on the size and structure of the input graph. As a result, programmers must try different combinations of a large set of techniques, which make tradeoffs among locality, work-efficiency, and parallelism, to develop the best implementation for a specific algorithm and type of graph. Existing graph frameworks and domain specific languages (DSLs) lack flexibility, supporting only a limited set of optimizations.This paper introduces GraphIt, a new DSL for graph computations that generates fast implementations for algorithms with different performance characteristics running on graphs with different sizes and structures. GraphIt separates what is computed (algorithm) from how it is computed (schedule). Programmers specify the algorithm using an algorithm language, and performance optimizations are specified using a separate scheduling language. The algorithm language simplifies expressing the algorithms, while exposing opportunities for optimizations. We formulate graph optimizations, including edge traversal direction, data layout, parallelization, cache, NUMA, and kernel fusion optimizations, as tradeoffs among locality, parallelism, and work-efficiency. The scheduling language enables programmers to easily search through this complicated tradeoff space by composing together a large set of edge traversal, vertex data layout, and program structure optimizations. The separation of algorithm and schedule also enables us to build an autotuner on top of GraphIt to automatically find high-performance schedules. The compiler uses a new scheduling representation, the graph iteration space, to model, compose, and ensure the validity of the large number of optimizations. We evaluate GraphIt's performance with seven algorithms on graphs with different structures and sizes. GraphIt outperforms the next fastest of six state-of-the-art shared-memory frameworks (Ligra, Green-Marl, GraphMat, Galois, Gemini, and Grazelle) on 24 out of 32 experiments by up to 4.8×, and is never more than 43% slower than the fastest framework on the other experiments. GraphIt also reduces the lines of code by up to an order of magnitude compared to the next fastest framework.

show abstract

Section: Datasetmentioning

confidence: 99%

GraphIt: a high-performance graph DSL

Zhang

Yang

Baghdadi

et al. 2018

Proc. ACM Program. Lang.

153

View full text Add to dashboard Cite

show abstract

“…Graph is a popular domain in the DSLs. The graph DSLs generate codes in parallel programming languages or lower-level runtime codes [14,26,33,35,36,40,41]. They provide reasonable performance and programmability by high-level API but lose an opportunity to optimize generated codes further when the applications are written directly in the target parallel programming languages.…”

Section: Related Workmentioning

confidence: 99%

Optimized Execution of Parallel Loops via User-Defined Scheduling Policies

Bak

Guo

Balaji

et al. 2019

Proceedings of the 48th International Conference on Parallel Processing

View full text Add to dashboard Cite

On-node parallelism continues to increase in importance for high-performance computing and most newly deployed supercomputers have tens of processor cores per node. These higher levels of on-node parallelism exacerbate the impact of load imbalance and locality in parallel computations, and current programming systems notably lack features to enable efficient use of these large numbers of cores or require users to modify codes significantly. Our work is motivated by the need to address application-specific load balance and locality requirements with minimal changes to application codes. In this paper, we propose a new approach to extend the specification of parallel loops via user functions that specify iteration chunks. We also extend the runtime system to invoke these user functions when determining how to create chunks and schedule them on worker threads. Our runtime system starts with subspaces specified in the user functions, performs load balancing of chunks concurrently, and stores the balanced groups of chunks to reduce load imbalance in future invocations. Our approach can be used to improve load balance and locality in many dynamic iterative applications, including graph and sparse matrix applications. We demonstrate the benefits of this work using MiniMD, a miniapp derived from LAMMPS, and three kernels from the GAP Benchmark Suite: Breadth-First Search, Connected Components, and PageRank, each evaluated with six different graph data sets. Our approach achieves geometric mean speedups of 1.16× to 1.54× over four standard OpenMP schedules and 1.07× over the static_steal schedule from recent research. CCS CONCEPTS • Computer systems organization → Multicore architectures; • Software and its engineering → Parallel programming languages; Runtime environments;

show abstract

“…HPC-enabled graph computation. Some studies [63,59,43,53,22,12,35,33,44,18] apply traditional HPC and database techniques (like shared memory, RDMA, versioning, and transactions) to enhance graph computation. For example, Ligra [44] is a single-machine graph processing framework for shared-memory multicore systems, which designs simple routines for mapping over edges/vertices to accelerate graph traversal algorithms that operate on subgraphs.…”

Section: Related Workmentioning

confidence: 99%

“…For example, Ligra [44] is a single-machine graph processing framework for shared-memory multicore systems, which designs simple routines for mapping over edges/vertices to accelerate graph traversal algorithms that operate on subgraphs. Grazelle [18] is a pull-based shared-memory graph processing framework, which parallelizes/vectorizes graph computation loops by designing (i) the scheduler-aware interface to reduce write traffic and synchronization and (ii) the Vector-Sparse edge-representation format to enable loop vectorization. These studies are focused on powerful sharedmemory machines with tens of cores and TB of memory, and thus are not for COTS (commercial off-the-shelf) clusters in the cloud.…”

Section: Related Workmentioning

confidence: 99%

“…Graph computation is central to machine-learning-datamining (MLDM) applications such as social computing, recommendation, and language processing [16,45,62,8,42]. Graph processing on a single machine has been extensively studied [64,52,28,41,38,44,58,44,18] and has achieved remarkably high efficiency. However, the rapidly-growing graph size has exceeded the capacity of any individual machines.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

TopoX

Zhang

Wang

et al. 2019

Proc. VLDB Endow.

View full text Add to dashboard Cite

Traditional graph partitioning methods attempt to both minimize communication cost and guarantee load balancing in computation. However, the skewed degree distribution of natural graphs makes it difficult to simultaneously achieve the two objectives. This paper proposes topology refactorization (TR), a topology-aware method allowing graph-parallel systems to separately handle the two objectives: refactorization is mainly focused on reducing communication cost, and partitioning is mainly targeted for balancing the load. TR transforms a skewed graph into a more communicationefficient topology through fusion and fission, where the fusion operation organizes a set of neighboring low-degree vertices into a super-vertex, and the fission operation splits a high-degree vertex into a set of sibling sub-vertices.Based on TR, we design an efficient graph-parallel system (TopoX) which pipelines refactorization with partitioning to both reduce communication cost and balance computation load. Prototype evaluation shows that TopoX outperforms state-of-the-art PowerLyra by up to 78.5% (from 37.2%) on real-world graphs and is significantly faster than other graph-parallel systems, while only introducing small refactorization overhead and memory consumption.

show abstract

Making pull-based graph processing performant

Cited by 39 publications

References 44 publications

GraphIt: a high-performance graph DSL

GraphIt: a high-performance graph DSL

Optimized Execution of Parallel Loops via User-Defined Scheduling Policies

TopoX

Contact Info

Product

Resources

About