From Fork-Join to Asynchronous Tasks: Parallelizing Tiled Cholesky Decomposition with OpenMP and HPX

2026-06-10

AI Summary

This study addresses the performance bottleneck in tiled Cholesky decomposition under non-uniform workloads caused by implicit synchronization barriers inherent in the fork-join execution model. The authors introduce Cholesky-Bench, a benchmark to systematically evaluate four parallelization strategies—classical fork-join, loop-fused fork-join, synchronous tasks, and asynchronous tasks based on explicit data dependencies—implemented using both OpenMP and HPX on a dual-socket 128-core AMD Zen 2 system. For the first time, they quantitatively compare the practical benefits of Asynchronous Many-Task (AMT) runtimes against optimized fork-join models on irregular kernels, reveal the impact of compiler optimizations on task overhead, and propose an effective optimization that eliminates redundant synchronization. Experimental results show that HPX achieves 15%–30% higher performance than OpenMP at optimal tile sizes, with asynchronous HPX tasks outperforming their OpenMP counterparts by 26%, reducing task overhead by 3.8×, and yielding an additional 7%–14% speedup through redundant synchronization removal.

Abstract

Fork-join parallelism, popularized by OpenMP, remains the dominant model for shared-memory parallel programming, but its implicit synchronization barriers can penalize algorithms with inhomogeneous workloads. Asynchronous many-task (AMT) runtimes sidestep these barriers by expressing work as a dependency graph of fine-grained tasks. Yet, the actual performance benefit over a carefully written fork-join baseline is rarely quantified. In this work, we introduce Cholesky-Bench and use it to revisit the tiled Cholesky decomposition, a canonical irregular kernel, comparing four parallelization variants of the right-looking algorithm across two runtimes: the OpenMP implementations shipped with GCC and LLVM, and the HPX AMT runtime. The variants span classical fork-join, a collapsed fork-join that exposes additional inner-loop parallelism, synchronous tasking, and asynchronous tasking with explicit data dependencies. We benchmark all eight combinations on a dual-socket 128-core AMD Zen 2 node across multiple tile sizes and problem sizes. Our results show that across all variants, HPX outperforms OpenMP at the optimal tile size by 15%-30%. Specifically, asynchronous HPX tasks are up to 26% faster than their OpenMP counterparts, and exhibit roughly 3.8x smaller task overhead. Furthermore, the collapsed fork-join variants close most of the gap to synchronous tasking. Removing redundant synchronization barriers yields an additional improvement of 7% (OpenMP) to 14% (HPX). A GCC-versus-LLVM comparison further reveals compiler-specific differences in fork-join scheduling and task-creation overheads.

Problem

• fork-join parallelism
• asynchronous many-task runtime
• tiled Cholesky decomposition
• irregular workload
• synchronization overhead

Innovation

• asynchronous many-task (AMT)
• fork-join parallelism
• tiled Cholesky decomposition
• task overhead
• synchronization barriers