🔭 astrophysics

Accelerating radio astronomy imaging with RICK: a step towards SKA-Mid and SKA-Low

This paper presents RICK 2.0, a portable and scalable radio imaging code that leverages the HeFFTe library to overcome previous communication bottlenecks and deliver high-performance imaging on diverse HPC architectures, including GPUs, in preparation for the SKA era.

Original authors: Giovanni Lacopo, Emanuele De Rubeis, Claudio Gheller, Giuliano Taffoni, Luca Tornatore

Published 2026-01-28

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Giovanni Lacopo, Emanuele De Rubeis, Claudio Gheller, Giuliano Taffoni, Luca Tornatore

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: The Radio Telescope Data Flood

Imagine radio telescopes like MeerKAT and LOFAR as giant, super-sensitive ears listening to the universe. These "ears" are getting so powerful that they are drowning in data. The future Square Kilometre Array (SKA) will produce data so fast it would fill a library of books every second.

The problem isn't just storing this data; it's imaging it. Turning raw radio signals into a picture of the sky is like trying to assemble a billion-piece puzzle while the pieces are constantly changing shape. If the computer program doing the assembly is too slow, the data gets deleted before the picture is finished, and we lose the science forever.

The Old Problem: The Traffic Jam

The authors previously built a tool called RICK to assemble these pictures. However, in earlier versions, the tool hit a massive traffic jam.

Imagine a team of 100 workers (computers) trying to build a wall. In the old version, every time a worker finished a small section, they had to stop, run to the center of the room, and show their entire blueprint to everyone else before they could continue. As the team grew larger, the time spent running to the center and showing blueprints took up 96% of the total work time. The workers spent almost no time actually building the wall.

The New Solution: RICK 2.0

The paper introduces RICK 2.0, a major upgrade designed to fix this traffic jam and make the process portable (able to run on different types of supercomputers).

Here is how they fixed it, using three main strategies:

1. Smart Sorting (The "Bucket Sort")

In the old system, data was handed out in the order it arrived (like a conveyor belt), which meant some workers got huge piles of work while others got almost nothing.

The Fix: RICK 2.0 uses a "bucket sort" method. Before the work begins, the system looks at the data and sorts it into buckets based on where it belongs on the final map.
The Analogy: Instead of handing out random puzzle pieces, the system sorts the pieces by color and shape first. It then gives each worker a bucket of pieces that matches their specific section of the wall. This ensures everyone has a fair amount of work to do.

2. The "Ghost Zone" Strategy

Because the data isn't spread out evenly (some parts of the sky are crowded with stars, others are empty), the workers need to know the edges of their neighbors' work to avoid gaps.

The Fix: The system gives each worker a slightly larger area than they strictly need, including a "ghost zone" of their neighbor's data.
The Analogy: Imagine painting a fence. Instead of just painting your own 10 feet, you paint 12 feet, overlapping slightly with your neighbor's section. This way, when you put the sections together, there are no ugly gaps or mismatched lines.

3. The Super-Translator (HeFFTe Library)

The hardest part of the math is a step called the Fast Fourier Transform (FFT), which turns raw signals into an image. It's like translating a secret code into a picture.

The Fix: The authors stopped trying to build their own translator and instead adopted a new, universal tool called HeFFTe.
The Analogy: Previous versions of RICK were like a translator who only spoke English and could only work in one specific room. The new HeFFTe library is a universal translator that works in any room (CPU or GPU) and speaks any language. It is incredibly fast, especially when using GPUs (specialized chips usually used for video games and AI).

The Results: Speed and Scale

The authors tested this new system on real data from two different telescopes:

MeerKAT (a precursor to the middle-frequency SKA).
LOFAR (a precursor to the low-frequency SKA).

What they found:

Communication is no longer the boss: In the old version, 96% of the time was wasted talking to other computers. In RICK 2.0, that time is drastically reduced. The computers spend most of their time actually working.
GPUs are supercharged: When using Graphics Processing Units (GPUs), the new system is 10 to 40 times faster than the old CPU-only versions for the most difficult math steps.
It scales: The system works well whether you use a few computers or hundreds. The old system would crash or slow down if you added too many computers; the new one gets faster as you add more.

The Bottom Line

RICK 2.0 is a new, faster, and smarter way to turn radio telescope signals into images. By reorganizing how data is sorted and using a powerful new math library, the authors have removed the "traffic jam" that was slowing down radio astronomy. This prepares the field for the massive data deluge expected from the future Square Kilometre Array, ensuring that scientists can actually see the pictures hidden in the data before it disappears.

Technical Summary: Accelerating Radio Astronomy Imaging with RICK 2.0

Problem Statement
Modern radio interferometers, including precursors to the Square Kilometre Array (SKA) such as MeerKAT, LOFAR, and ASKAP, generate data volumes reaching petabytes annually. Processing this data for interferometric imaging presents severe computational challenges. Existing pipelines often struggle with scalability, particularly regarding the Message Passing Interface (MPI) communication overheads required for distributed parallelism. Previous versions of the Radio Imaging Code Kernels (RICK) demonstrated that while GPU acceleration offered speedups, the communication overhead—specifically the necessity to communicate the entire data grid during the gridding step—consumed up to 96% of the runtime in large-scale, multi-node configurations. This bottleneck prevented effective scaling as the number of computing nodes and image pixel resolutions increased, threatening the feasibility of "real-time" processing required for future SKA operations.

Methodology
The authors present RICK 2.0, a refactored version of the imaging pipeline designed to minimize communication overhead and ensure portability across diverse High-Performance Computing (HPC) architectures. The core methodological shifts include:

Non-Uniform Domain Decomposition: Unlike the previous version which used uniform slab decomposition, RICK 2.0 implements a non-uniform domain decomposition based on a one-dimensional Gaussian distribution along the $v$ -axis of the Fourier grid. This approach accounts for the non-uniform density of visibility data (which is denser in the center of the $u-v$ plane). By assigning smaller slabs to central regions and larger slabs to external regions, the workload is balanced across MPI processes, reducing the need for excessive data redistribution.
Data Redistribution via Bucket Sorting: Visibilities are assigned to specific MPI ranks based on their $v$ -coordinates using a bucket sort algorithm. This ensures that data locality is maintained throughout the pipeline, allowing subsequent steps to proceed without communicating the entire grid.
HeFFTe Library Integration: To support the new non-uniform grid decomposition, the authors replaced the previous FFT implementations (FFTW and cuFFTMP) with the HeFFTe library. HeFFTe supports non-uniform one, two, and three-dimensional decompositions and offers portability across CPU and GPU architectures (NVIDIA, AMD, Intel) via backend wrappers (FFTW, cuFFT, rocFFT, oneMKL).
Parallel I/O: The implementation utilizes MPI-I/O for both reading measurement sets and writing output images. This replaces previous file handling methods that relied on sequential writes or shared windows, improving scalability and portability across different filesystem types.
Ghost Regions: To handle boundary conditions during gridding, "ghost regions" are included in the data assignment, extending the local domain by half the convolution kernel dimension.

Key Contributions

Communication Overhead Reduction: The primary contribution is the architectural change that eliminates the need to communicate the entire grid. By localizing data to MPI ranks through non-uniform decomposition and bucket sorting, the communication impact is drastically reduced, enabling the code to scale effectively with large numbers of nodes.
Portable GPU Acceleration: The integration of HeFFTe allows RICK 2.0 to run efficiently on heterogeneous systems, including multi-core CPUs and various GPU architectures, without requiring architecture-specific code rewrites.
Validation on Real Data: The pipeline was validated using real observational data from MeerKAT (SKA-Mid precursor) and LOFAR (SKA-Low precursor), producing "dirty" images that confirm the correctness of the implementation.

Results
The authors conducted strong scaling tests on the LEONARDO supercomputer (Tier-0 EuroHPC system) using MeerKAT (48 GB) and LOFAR (363 GB) datasets.

Scaling Performance: In previous versions, communication time increased with the number of nodes, eventually dominating the runtime. In RICK 2.0, communication time scales linearly (or superlinearly) with the number of Compute Units (CUs).
Speedup Factors:
- Small Tests (MeerKAT, 8192² pixels): On 8 CUs, the GPU configuration was approximately 3.2 times faster than the MPI-only CPU configuration and 3.3 times faster than the MPI+OpenMP CPU configuration. The phase correction step showed even higher gains, with GPUs being up to 32.3 times faster than MPI+OpenMP on 8 CUs.
- Large Tests (LOFAR, 65536² pixels, 256 CUs): The GPU configuration achieved a total runtime speedup of approximately 2x compared to the CPU-only configuration. More specifically, the GPU configuration showed a ~11.2x speedup in gridding, a ~19x speedup in FFT, and a ~42.8x speedup in phase correction compared to the CPU-only run.
Communication Time: In the large-scale LOFAR test, communication time (visibility redistribution) was reduced to approximately 10 minutes, a significant improvement over the hours required in previous implementations for similar scales.

Significance
The paper claims that RICK 2.0 represents a critical step toward meeting the computational demands of the SKA era. By resolving the critical scaling limitations identified in prior work (where communication overhead consumed up to 96% of runtime), the new architecture provides a scalable and efficient imaging solution. The successful validation on both SKA-Mid and SKA-Low precursor data demonstrates the code's readiness for next-generation radio astronomy challenges. The authors note that while I/O operations may become the next bottleneck, the current implementation successfully addresses the primary computational and communication barriers, paving the way for large-scale operational use in radio astronomy. The adoption of portable, high-performance libraries like HeFFTe is highlighted as a strategic advantage that extends beyond radio imaging to other fields in astrophysics and cosmology relying on distributed Fourier transforms.