[Paper Review] Parallel Louvain Community Detection Optimized for GPUs

Richárd Forster|arXiv (Cornell University)|May 28, 2018

Wireless Communication Networks Research3 citations

TL;DR

This paper presents a GPU-optimized parallel implementation of the Louvain community detection algorithm using CUDA, leveraging parallel heuristics to overcome the algorithm's inherent sequential nature. The approach achieves up to 31x theoretical speedup and 23x experimental speedup over a CPU-based parallel implementation on a GeForce GTX 980, significantly accelerating modularity optimization in large-scale graphs like those from CERN's Collaboration Spotting project.

ABSTRACT

Community detection now is an important operation in numerous graph based applications. It is used to reveal groups that exist within real world networks without imposing prior size or cardinality constraints on the set of communities. Despite its potential, the support for parallel computers is rather limited. The cause is largely the irregularity of the algorithm and the underlying heuristics imply a sequential nature. In this paper a GPU based parallelized version of the Louvain method is presented. The Louvain method is a multi-phase, iterative heuristic for modularity optimization. It was originally developed by Blondel et al. (2008), the method has become increasingly popular owing to its ability to detect high modularity community partitions in a fast and memory-efficient manner. The parallel heuristics used, were first introduced by Hao Lu et al. (2015). As the Louvain method is inherently sequential, it limits the possibility of scalable usage. Thanks to the proposed parallel heuristics, I observe how this method can behave on GPUs. For evaluation I implemented the heuristics using CUDA on a GeForce GTX 980 GPU and for testing Ive used organization landscapes from the CERN developed Collaboration Spotting project that involves patents and publications to visualize the connections in technologies among its collaborators. Compared to the parallel Louvain implementation running on 8 threads on the same machine that has the used GPU, the CUDA implementation is able to produce community outputs comparable to the CPU generated results, while providing absolute speedups of up to 30 using the GeForce GTX 980 consumer grade GPU.

Motivation & Objective

• To address the limited scalability of the sequential Louvain algorithm on parallel architectures due to its irregular, iterative, and greedy nature.
• To enable high-performance community detection on large-scale graphs by porting the Louvain method to GPU using CUDA.
• To evaluate the performance of the GPU-parallelized Louvain algorithm against a multi-threaded CPU implementation on real-world collaboration graphs.
• To identify performance bottlenecks and structural factors affecting GPU efficiency in community detection workloads.

Proposed method

• Adopted parallel heuristics from Hao Lu et al. (2015) to restructure the inherently sequential Louvain algorithm for GPU execution.
• Implemented the algorithm using CUDA on a GeForce GTX 980 GPU, managing memory transfers between host and device to minimize overhead.
• Optimized key phases: community assignment (modularity gain computation), graph induction (aggregation of communities), and neighbor processing.
• Used adjacency lists and weighted degrees to compute modularity gains efficiently in parallel across GPU threads.
• Applied node reordering heuristics to reduce thread divergence by grouping nodes with similar neighbor counts.
• Evaluated performance using real-world graphs from CERN’s Collaboration Spotting project, including coPapersDLBP and friendster.

Experimental results

Research questions

• RQ1 Can the inherently sequential Louvain algorithm be effectively parallelized on GPU architectures using CUDA?
• RQ2 What performance gains can be achieved by offloading Louvain’s modularity optimization to a GPU compared to a multi-threaded CPU implementation?
• RQ3 How do graph structure and data layout influence GPU performance in community detection workloads?
• RQ4 What are the dominant performance bottlenecks in GPU-parallelized Louvain, and can they be mitigated through algorithmic or memory optimization?

Key findings

• The GPU implementation achieved a 23x speedup over the 8-thread CPU parallel version on the coPapersDLBP graph, with a theoretical peak speedup of 31x.
• The one-phase modularity computation on the GPU was 7.2x faster than on the CPU for the CNR graph, and up to 20x faster for other test cases.
• Graph induction and neighbor processing phases were accelerated by 28x and 16x respectively on the GPU, demonstrating significant gains in preprocessing steps.
• The GPU version outperformed the CPU in all measured phases: t_onephase_gpu << t_onephase_cpu, t_induce_gpu << t_induce_cpu, and t_neighbour_gpu << t_neighbour_cpu.
• Performance was highly dependent on graph structure; the Europe-osm graph showed no speedup due to inefficient renumbering, indicating that data layout affects GPU efficiency.
• Thread divergence due to variable node degrees was a performance limiter, suggesting that node reordering could further improve GPU utilization.