BLEST: Blazingly Efficient BFS using Tensor Cores

TL;DR

BLEST is a GPU framework that leverages Tensor Cores to accelerate BFS graph traversal by reformulating the algorithm to optimize load balancing, memory efficiency, and synchronization, achieving significant speedups over existing methods.

Contribution

This paper introduces BLEST, a novel Tensor Core-based BFS framework that reformulates the algorithm for better load balancing, memory efficiency, and reduced synchronization, outperforming prior GPU implementations.

Findings

Achieves up to 4.9x speedup over existing BFS frameworks.

Effectively utilizes Tensor Cores for irregular graph computations.

Improves load balancing and memory locality across diverse graphs.

Abstract

Breadth-First Search (BFS) is a fundamental graph kernel that underpins a wide range of applications. While modern GPUs provide specialised Matrix-Multiply-Accumulate (MMA) units, e.g., Tensor Cores (TC), with extremely high throughput, they target dense operations, making it non-trivial to exploit them for irregular, unstructured graph computations. In particular, fully utilising them for a BFS requires an efficient mapping of the edge operations onto TCs while avoiding redundancy, load imbalance, and synchronisation. We present BLEST, a TC-accelerated framework that reformulates the pull-based BFS pipeline around a bitmap-oriented structure and a carefully engineered execution layout. BLEST introduces Binarised Virtual Slice Sets (BVSS) to enforce warp-level load balancing and to eliminate frontier-oblivious work assignment. To improve both memory efficiency and update locality across diverse graphs, we apply two complementary graph reordering strategies: a compression-oriented ordering for social-like graphs and a bandwidth-reducing ordering for non-social graphs. At the compute level, we develop a batched SpMSpV multiplication pattern that uses the bitwise TC tiles to handle dot products without wasting output entries, thereby reducing the number of required MMA calls. Finally, BLEST combines kernel fusion with a lazy vertex update scheme to reduce host-side synchronisation, mitigate atomic overheads, and improve cache locality. Experiments show that BLEST delivers, on average, $3.58\times$, $4.64\times$ and $4.9\times$ speedup over BerryBees, Gunrock, and GSWITCH, respectively, across a broad set of real-world graphs.