Connected component identification and cluster update on GPU

Cluster identification tasks occur in a multitude of contexts in physics and engineering such as, for instance, cluster algorithms for simulating spin models, percolation simulations, segmentation problems in image processing, or network analysis. While it has been shown that graphics processing units (GPUs) can result in speedups of two to three orders of magnitude as compared to serial codes on CPUs for the case of local and thus naturally parallelized problems such as single-spin flip update simulations of spin models, the situation is considerably more complicated for the non-local problem of cluster or connected component identification. I discuss the suitability of different approaches of parallelization of cluster labeling and cluster update algorithms for calculations on GPU and compare to the performance of serial implementations.

💡 Research Summary

The paper investigates how to accelerate the inherently non‑local problem of connected‑component (cluster) identification and subsequent cluster updates on modern graphics processing units (GPUs). Starting from the well‑known Swendsen‑Wang (SW) algorithm for the q‑state Potts model, the author decomposes a single Monte‑Carlo sweep into three stages: (i) bond activation, (ii) cluster labeling, and (iii) cluster flipping. Bond activation is embarrassingly parallel; each lattice edge is examined independently, a random number is drawn, and the bond is set to active with probability p = 1 − e^{‑βJ} when the neighboring spins are equal. To exploit the GPU’s SIMD architecture, the lattice is partitioned into square tiles of size B × B, each tile assigned to a CUDA thread block. Memory layout is chosen to guarantee coalesced global‑memory accesses, and each thread holds its own 32‑bit linear‑congruential generator (LCG) to avoid RNG bottlenecks while keeping per‑thread state minimal. Performance measurements on GTX 480, GTX 580 and Tesla M2070 show a compute‑bound kernel with an asymptotic cost of about 0.46 ns per lattice site for bond activation.

The core difficulty lies in stage (ii), the labeling of connected components formed by the activated bonds. Three classic approaches are examined: (1) the Hoshen‑Kopelman (HK) union‑find algorithm, (2) a breadth‑first search (BFS) that grows clusters layer by layer using a FIFO queue, and (3) a “self‑labeling” scheme in which each site repeatedly adopts the minimum label among its neighbors until convergence. While HK is serial‑friendly and BFS is conceptually simple, both suffer from irregular memory access patterns and thread divergence on a GPU. Self‑labeling, by contrast, consists of a series of parallel “min‑reduce” steps that map naturally onto the GPU’s warp‑synchronous execution model, yielding high occupancy and minimal synchronization overhead. The author therefore adopts a two‑level strategy: first, each tile independently performs self‑labeling to obtain provisional labels; second, a global consolidation phase merges labels across tile boundaries using a parallel union‑find with path compression, which converges in O(log P) steps where P is the number of tiles. This hierarchical approach balances local memory reuse with a modest amount of inter‑tile communication.

The paper also treats the Wolff single‑cluster algorithm, which builds one cluster at a time via a BFS‑like growth process. Here the author again uses tile‑based data structures, but only the frontier of the growing cluster is updated each iteration, dramatically reducing memory traffic. Synchronization is limited to warp‑level barriers, and the same global label‑merging routine is reused to integrate the newly grown cluster into the lattice.

Benchmark results demonstrate speed‑ups of two to three orders of magnitude compared with a single‑threaded CPU implementation for lattice sizes up to L = 2^{12}. Even at the critical temperature—where clusters percolate across the whole system and the labeling step becomes most demanding—the GPU implementation retains its advantage. The paper quantifies how performance scales with tile size B, number of threads per site k, and the hardware parameters (number of multiprocessors, cores per multiprocessor). It shows that for large lattices the activation step scales as O(L²) with a small constant, while the labeling step’s dominant cost is the global merge, which grows only logarithmically with system size.

In the discussion, the author emphasizes that the presented techniques are not limited to spin‑model simulations. The same GPU‑friendly labeling pipeline can be applied to image segmentation, percolation studies, and network‑analysis tasks where connected‑component labeling is a bottleneck. Future work is suggested in the direction of multi‑GPU scaling, extending the algorithms to irregular graphs, and integrating higher‑quality random‑number generators without sacrificing performance.

Overall, the paper provides a thorough analysis of the algorithmic choices, memory‑access patterns, and synchronization strategies required to make non‑local cluster identification efficient on GPUs, and it validates the approach with extensive performance measurements on contemporary hardware.