# SimSDP, a Rapid Prototyping tool for Radio Astronomy: From NenuFAR Experiments to SKAO-Scale Simulation

Ophélie Renaud, Nicolas Gac, François Orieux, Cedric Dumez-Viou

► To cite this version:

Ophélie Renaud, Nicolas Gac, François Orieux, Cedric Dumez-Viou. SimSDP, a Rapid Prototyping tool for Radio Astronomy: From NenuFAR Experiments to SKAO-Scale Simulation. SiPS 2025 - 38th IEEE Workshop on Signal Processing Systems, Nov 2025, Hong Kong, China. pp.1-5. hal-05260888

HAL Id: hal-05260888

https://hal.science/hal-05260888v1

Submitted on 15 Sep 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
# SimSDP, a Rapid Prototyping tool for Radio Astronomy: From NenuFAR Experiments to SKAO-Scale Simulation

Ophélie Renaud*†, Nicolas Gac*, François Orieux‡, Cédric Viou§

*SATIE, Université Paris-Saclay, ENS Paris-Saclay, CNRS, 91 190, Gif-sur-Yvette, France. first.last@ens-paris-saclay.fr

†IRISA, ENS Rennes, CNRS, France. first.last@irisa.fr

‡L2S, Université Paris-Saclay, CNRS, CentraleSupélec, 91 190, Gif-sur-Yvette, France. first.last@l2s.centralesupelec.fr

§ORN, Observatoire de Paris, Université PSL, Univ Orléans, CNRS, 18 330 Nançay, France. first.last@obs-nancay.fr

***Abstract***—SimSDP is a rapid prototyping tool designed to provide early estimates of the computation times and energy consumption of SKAO's future SDP processor pipeline. This paper extends a previous proof-of-concept by: (1) exploring further parallelism through dataflow modeling of spectral parallelism with joint or distributed deconvolution, (2) simulating pipeline behavior on multi-core multi-node CPU architectures for multi-scale data, (3) deploying parametric prototype pipelines using real-world data from the NenuFAR instrument. Experimental results show that SimSDP effectively supports design-space exploration by simulating three radio-interferometric imaging algorithms on HPC systems, with simulation uncertainty below 10%.

***Index Terms***—Radio interferometry, SKAO, NenuFAR, Simulation, HPC, Rapid prototyping

## I. INTRODUCTION

Radio telescopes, essential instruments for observing celestial phenomena, are increasingly aiming for real-time processing, i.e., the ability to analyze data as quickly as it is acquired. Infrastructures such as the SKAO, with their large number of antennas spread over vast areas, generate massive volumes of data. This data needs to be processed efficiently by High-Performance Computing (HPC) systems, which can comprise tens of thousands of nodes, equipped with multicore processors. In this context, pathfinder instruments such as NenuFAR, which is designed to explore both the scientific and technical challenges of the SKAO, play a crucial role. NenuFAR provides valuable datasets and serves as a testbed for algorithmic and architectural developments that will later be scaled up to the 1 or 2 magnitude order of SKAO systems. The SKAO radio-interferometric imaging process will be carried out by the Science Data Processor (SDP). These imaging algorithms, which are constantly evolving to meet the needs of researchers, nevertheless share recurring structures, as demonstrated by the [17] study. These algorithms are generally characterized by a series of iterations that produce a so-called *dirty* image of the sky, containing instrumental artifacts, followed by a series of minor loops that aim to reduce the image artifacts through an iterative deconvolution algorithm. Optimizing algorithms before they are deployed on these complex infrastructures is

essential to ensure efficient operation. Tools such as Dask [12], Daliuge [18], and PREESM [10], enable the deployment of such applications by exploiting the dataflow model, where the application is represented as a graph, to expose and exploit the intrinsic parallelism of the algorithms. The graph consists of nodes, called actors, representing computations, interconnected by edges representing buffers in First In First Out (FIFO). Although these tools enable rapid deployment, they are not designed to simulate the behavior of complex architectures accurately. Simulator of the Science Data Processor (SimSDP) enables the simulation of hierarchical, multi-node, multi-core architectures, and constitutes a first step toward supporting heterogeneous HPC systems. The accuracy of these simulations relies on a reliable estimation of the execution times of the actors in the dataflow graph as a function of the target architecture and algorithmic parameters [17]. However, to validate the reliability of the simulations, it is necessary to compare the performance of the prototypes with the simulations obtained, which is time-consuming given the number of possible configurations.

In this paper, we propose a methodology to facilitate algorithmic exploration in radio-interferometric imaging and architectural exploration of systems, with three main contributions.

* **Modeling distributed and centralized deconvolution for spectral parallelism** on radio-interferometric imaging pipelines, to better exploit system resources HPC.

* **Multinode-multicore parametric prototyping** using real data from NenuFAR to evaluate pipeline variants on diverse hardware configurations, thereby validating the accuracy of the simulations.

* **Advanced simulation of architectures** exploiting SimSDP to extend simulation to SKAO-scale multi-node, multi-core environments.

Section II presents the radio-interferometric imaging background. Section III describes the operation of the simulator SimSDP and the shared and distributed memory parallelization scheme we have implemented. The section IV presents experimental results obtained with SimSDP on HPC systems. Finally, section V concludes this document.

<footnote>This work was supported by DARK-ERA (ANR-20-CE46-0001-01).</footnote>
## II. RADIO-INTERFEROMETRY IMAGING FORMALISM AND MODELING FRAMEWORK

Radio interferometric imaging uses interferometers to measure visibilities, which are samples of the sky obtained from pairs of antennas. These visibilities $V(u, v)$ are described by Radio Interferometer Measurement Equation (RIME) [13] as

$$V(u, v) = G_{uv} \int \left[ D_{uv}(l, m) \frac{1}{\sqrt{1 - l^2 - m^2}} I(l, m) e^{-2\pi i (ul + vm + w(\sqrt{1-l^2-m^2}-1))} \right] dl dm \quad (1)$$

where $G_{uv}$ represents direction-independent instrumental effects, $D_{uv}$ represents direction-dependent instrumental effects, $(u, v)$ denote continuous spatial coordinates in the uv plane, $(l, m)$ are coordinates on the celestial sphere, $w$ is the line-of-sight coordinate and $I(l, m)$ corresponds to the true intensity of the sky, assuming unpolarized emission.

Thus, to transform these visibilities into an image of the sky, imaging algorithms generally use two main steps: a major loop and a minor loop. The [17] study proposed a generic, modular dataflow-based model for these steps, enabling algorithms to be structured in elementary blocks and to take advantage of the parallelism of modern architectures. The major loop manages the transformation of visibilities into a dirty image of the sky via operations equivalent to gridding and degridding. The gridding consists in projecting the visibilities onto a regular grid in the uv plane to facilitate the application of Fast Fourier Transform (FFT) to generate a dirty image. The degridding performs the adjoint operation projecting the Fourier coefficients derived from the FFT onto the continuous coordinates of the measurements in the uv plane. The main parameters are defined as follows: the number of visibilities ($n_v$), the image grid size ($n_g$), the number of frequency channels ($n_f$), the sizes of the degridding and gridding kernels ($n_D$ and $n_G$), and the number of minor cycles ($n_m$). Based on these parameters, the modular [17] model comprises three algorithmic versions for the major loop, adapted to different contexts. These algorithms offer a compromise between accuracy and performance, with the following complexities valid if we consider a single $n_f$:

1) **Direct Fourier Transform (DFT)**: Accurate, but time-consuming calculations, with a complexity of $O(2n_v n_g^2)$.

2) **FFT with convolution**: Fast method thanks to the grid, at the cost of a slight loss of precision, with a complexity of $O(2n_g^2 \log_2 n_g^2 + n_v(n_g^2 + n_D^2))$.

3) **Grid-to-Grid (G2G)** [7]: Hybrid algorithm designed to optimize accuracy while maintaining good performance, with a complexity of $O(2n_g^2 \log_2 n_g^2 + n_v(n_g^2 + n_D^2))$. Here, $n_v$ represents the reduced number of non-redundant visibilities used in gridding and degridding steps. This reduction, along with a subtraction performed in image space rather than in visibility space, often makes the algorithm faster in practice.

The minor loop is used to clean the image dirty of artifacts introduced by instrumentation. Among the algorithms avail-

able, CLEAN by J.A. Högbom [4] is the most commonly used. This algorithm first identifies the dominant sources in the image dirty, then models these sources while removing artifacts associated with the instrumental response (PSF). Finally, the image is iteratively updated until it converges to an ideal artifact-free version. The complexity of CLEAN is $O(n_g^2 \cdot n_m)$, where a convolution of $n_g^2$ PSF is performed.

Several software frameworks such as Common Astronomy Software Applications (CASA) [15], DDFacet [14], and WSClean [9] implement variants of the algorithms described above, often with additional optimizations, support for direction-dependent effects, and distributed execution. These tools are widely used in operational pipelines but their internal structures are complex and not easily captured by formal models.

In this work, we focus on DFT, FFT and G2G pipelines already formalized in the SimSDP modeling framework and aim to pave the way for modeling more pipelines. In this article, we seek to reveal the algorithmic factors limiting scaling. Three main parameters emerge from the arithmetic complexity of these algorithms: the number of visibilities $n_v$, the grid size $n_g$ and the number of minor cycles $n_m$.

## III. SIMSDP: A TOOL FOR MULTI-NODE SIMULATION

### A. Multinode and Multicore Parallelism

MeasurementSets (MSs) are an astronomy data format that stores visibilities along with instrument metadata [16]. These datasets are often huge, and processing them efficiently, in terms of memory and computation, requires distributing the workload across multiple HPC nodes. A naive multi-node parallelization approach distributes independent observations across nodes, thereby increasing the overall image production throughput. However, this strategy does not reduce the latency for producing a single image. For large datasets, generating a single image may take several hours or even days. In addition, storing a full observation on a single node can exceed local storage and memory capacities, reinforcing the need for distributed, low-latency solutions that operate within a single image. In this work, we consider the data model as a spectral cube, with dimensions corresponding to frequency, right ascension, and declination. This cube representation, common in radio interferometry, enables data partitioning along the spectral axis, which is well-suited for parallel processing. Some deconvolution algorithms, such as Multi-Frequency Synthesis (MSF) CLEAN [11] or joint Cube CLEAN, exploit spectral correlations between frequency channels to improve the reconstruction quality. These approaches typically require access to the full spectral cube. Such a solution is implemented in DDFacet [8] deployed on the LOFAR radio-telescope. In contrast, algorithms like Högbom CLEAN [4] or multi-scale CLEAN [2] operate independently on each frequency channel, allowing for fully parallel pipelines without global data merging. In this paper, we simulate and prototype both approaches. Within each HPC node, we further exploit parallelism by distributing visibilities across multiple processing cores, as proposed in [17].
<figure><img src="image_2.png" /><figcaption>Fig. 1: Simplified view of two parallelization strategies: (a) independent frequency-channel pipelines distributed across nodes; (b) collaborative gridding and degridding per node, followed by centralized deconvolution.</figcaption></figure>

## B. SimSDP operation

SimSDP, based on PREESM [10] and SimGrid [1], relies on three main steps:

* Node-level partitioning: The data flow graph of radio-interferometry imaging pipelines is divided into sub-graphs, each subgraph being assigned to a specific node in the HPC system.

* Partitioning at thread level: Within each node, tasks are distributed between the available computing cores via list scheduling techniques.

* Workload simulation: This simulation takes into account not only inter-node communication via MPI, but also intra-node synchronization managed by Pthread. This makes it possible to model interactions between nodes as well as parallel execution on cores of the same node.

SimSDP employs the Parameterized and Interfaced Syn-chronous Dataflow (PiSDF) semantic model [3] as a dataflow graph, where parameters are $n_v$, $n_g$, and $n_m$. This allows to represent FIFOs size and actors’ timing with expressions for more flexible representation of the pipelines. We integrate moldable parameters [5], which consist of assigning a range of values for key parameters to facilitate the parametric exploration in the simulation.

## C. Enhanced rapid prototyping via parameterization

SimSDP automatically generates MPI code for inter-node communication and uses Pthread to manage synchronization at the processing core level. To facilitate execution exploration, we extend this prototype with the parameters $n_v$, $n_g$, and $n_m$ as function arguments. As a result, we generate one executable prototype for each combination of pipeline type (DFT, FFT, G2G) and CLEAN strategy (joint or distributed).

Two main MPI implementations are generated depending on the deconvolution strategy as illustrated in Figure 1. In the fully distributed scenario, each MPI process independently handles a specific frequency channel, without requiring inter-process communication aside from synchronization barriers.

<table><caption>TABLE I: Summary of NenuFAR MSs used in the real-data experiments</caption><thead><tr><th>MeasurementSet</th><th>n<sub>v</sub></th><th>n<sub>s</sub></th><th>n<sub>f</sub></th><th>size</th></tr></thead><tbody><tr><td>SB155</td><td>1.18 &times; 10<sup>7</sup></td><td>1</td><td>64</td><td>37.2 GB</td></tr><tr><td>SB155.rebin</td><td>1.48 &times; 10<sup>6</sup></td><td>1</td><td>8</td><td>1.5 GB</td></tr></tbody></table>

The CLEAN process is performed locally within each process, enabling straightforward data-parallel scaling. In the joint deconvolution scenario, gridding and degridding are still executed independently by each node, but the intermediate results are gathered by a master node using MPI communication primitives for centralized CLEAN. This setup introduces MPI communication overhead, but enables spectral correlation exploitation for improved image fidelity.

To facilitate deployment on HPC systems, each prototype is compiled into a standalone executable and encapsulated within a container using *Singularity*, a containerization technology designed for high-performance computing environments [6]. This ensures reproducibility and eases integration with workload managers. The *Singularity* images are publicly available<fnref n="1" />.

# IV. EXPERIMENTAL RESULTS

The SimSDP simulator was used both to simulate pipeline deployment and to automatically generate parallel code (MPI and Pthread) for three radio-interferometric imaging pipelines: G2G, DFT, and FFT. Each pipeline was evaluated using two CLEAN strategies: joint CLEAN and disjoint CLEAN.

A total of 336 (i.e., $8n_v \times 7n_g \times 6n_m$) configurations per pipeline type and CLEAN strategy (i.e., 2016 configurations in total) were explored through parameter variation as follows:

* $n_v \in \{10^4, 10^5, 10^6, 10^7, 10^8, 10^9, 10^{10}, 10^{11}\}$,

* $n_g \in \{2^9, 2^{10}, 2^{11}, 2^{12}, 2^{13}, 2^{14}, 2^{15}\}$,

* $n_m \in \{1, 10, 10^2, 10^3, 10^4, 10^5\}$.

The generated prototypes were also executed on real Nenu-FAR<fnref n="2" /> MSs, summarized in Table I and deployed on the Ruche Mesocentre cluster, where the number of architecture nodes used is the number of channel frequencies $n_f$. Due to memory constraints, $n_v$ was limited to $10^7$, $n_g$ to $2^{12}$, and $n_m$ to $10^3$, resulting in 80 executions per pipeline and CLEAN strategy (i.e., 480 configurations in total).

Other algorithmic parameters were fixed across all experiments: number of major cycles set to 5, number of gridding/degridding kernels to 17, and oversampling factor to 16.

## A. Execution on real-dataset from NenuFAR

Figures 2a and 2b present the latency obtained when deploying the prototype implementations on 8 architecture nodes, each processing one frequency channel $n_f$ of the rebinned NenuFAR MS described in Table I. Measured latencies are shown with solid lines, and the corresponding simulated latencies are shown with dashed lines for $n_m = 1$ and

<footnote n="1">¹https://github.com/Ophelie-Renaud/simsdp-generic-imaging-pipeline/</footnote>

<footnote n="2">²https://nenufar OBS-nancay.fr/en/homepage-en/</footnote>
<figure><img src="image_3.png" /><figcaption>Fig. 2: Comparison of measured latency from SimSDP prototypes and simulated latency according to the number of visibilities ($n_m = 1$)</figcaption></figure>

<table><caption>TABLE II: Relative error between SimSDP simulations and prototype execution.</caption><thead><tr><th>Pipeline</th><th>Err.(%)<br>joint CLEAN</th><th>Err.(%)<br>distributed CLEAN</th></tr></thead><tbody><tr><td>DFT</td><td>5.55</td><td>7.27</td></tr><tr><td>FFT</td><td>2.88</td><td>6.02</td></tr><tr><td>G2G</td><td>6.98</td><td>6.22</td></tr></tbody></table>

$n_g = 2^{11}$. These settings isolate the core computational cost of the gridding and degridding steps.

Figure 2a displays results for the disjoint CLEAN strategy, while Figure 2b corresponds to the joint CLEAN strategy. Across all tested scenarios, the FFT-based pipeline consistently outperforms the DFT-based one. Due to its global synchronization step, the joint CLEAN strategy induces slightly higher latency than disjoint CLEAN. This is particularly evident for larger $n_f$ values, where the central CLEAN process must wait for all frequency channels to complete their local grinding.

Table II reports the relative error between simulated and measured latencies for the deployment of the three pipelines using both joint and disjoint CLEAN strategies. Each MS name indicates the corresponding observation frequency. In practice, astronomers often rebin MeasurementSets to reduce data volume, compressing along time and frequency axes when high resolution is not required for image reconstruction. However, since our objective is to evaluate the scalability of pipeline execution, we include both original and rebinned versions of the datasets in order to provide a more complete and realistic assessment of system performance. Across all pipelines and CLEAN strategies, the error remains below 10%, validating the reliability of the model.

## B. Multi-scale simulation

Figure 2c shows the simulated latencies obtained with SimSDP from the nenuFAR-scale reported as prototype area to the SKAO scale pipelines configurations. Note that running

the 80 configuration of prototype implementations requires approximately 10 hours per pipeline, while the same number of simulations took only 20 minutes. This massive reduction in computation time enables rapid exploration of the design space while maintaining acceptable accuracy.

## V. CONCLUSION

This paper presents SimSDP, a model-based simulation and code generation framework designed to explore the deployment of radio-interferometric imaging pipelines on parallel architectures. We demonstrated that SimSDP can capture and exploit spectral parallelism, simulate execution behavior on multi-core and multi-node CPU platforms, and automatically generate MPI/Pthread prototypes. Experimental results indicate that the latency estimations provided by SimSDP maintain an average uncertainty of less than 10%, making it a practical tool for early design-space exploration. Future directions include extending the simulation and deployment support to GPU-based architectures, both single and multi-GPU, and integrating more complex imaging frameworks such as DDFacet or CASA, where task parallelism, memory hierarchy, and hybrid CPU/GPU scheduling introduce additional challenges.

## VI. ACKNOWLEDGMENTS

This paper is based on data from the NenuFAR radio-telescope. NenuFAR was developed with support from personnel and funding from: Observatoire Radioastronomique de Nançay, CNRS-INSU, Observatoire de Paris-PSL, Université d'Orléans, Observatoire des Sciences de l'Univers en région Centre, Région Centre-Val de Loire, DIM-ACAV and DIM-ACAV+ of Région Île de France, ANR. The Nançay Radio Observatory is operated by the Paris Observatory with CNRS. We acknowledge the Nançay Data Center for data reduction and storage. This work also benefited from computational resources from the Mésocentre of Université Paris-Saclay supported by CNRS and Région Île-de-France<fnref n="3" />.

<footnote n="3">³https://mesocentre.universite-paris-saclay.fr/</footnote>
REFERENCES

[1] H. Casanova and al. Versatile, scalable, and accurate simulation of distributed applications and platforms. *JPDC*, 2014.

[2] Tim J. Cornwell. Multiscale clean deconvolution of radio synthesis images. *IEEE Journal of Selected Topics in Signal Processing*, 2(5):793–801, October 2008.

[3] K. Desnos and al. Pimm: Parameterized and interfaced dataflow meta-model for mpsocs runtime reconfiguration. *SAMOS*, 2013.

[4] J. A. Hogbom. Aperture Synthesis with a Non-Regular Distribution of Interferometer Baselines. *Astron. Astro.*, 1974.

[5] Alexandre Honorat, Thomas Bourgoin, Hugo Miomandre, Karol Desnos, Daniel Menard, and Jean-François Nezan. Influence of Dataflow Graph Moldable Parameters on Optimization Criteria. In *DASIP 2022 - Workshop on Design and Architectures for Signal and Image Processing*, volume 13425 of *Lecture Notes in Computer Science*, pages 83–95, Budapest, Hungary, June 2022. Springer International Publishing.

[6] Gregory M. Kurtzer, Vanessa Sochat, and Michael W. Bauer. Singularity: Scientific containers for mobility of compute. *PLOS ONE*, 12(5):1–20, 05 2017.

[7] N. Monnier and al. Fast grid to grid interpolation for radio interferometric imaging. *Astron. Comput.*, 2023.

[8] Nicolas Monnier, David Guibert, Cyril Tasse, Nicolas Gac, François Orieux, Erwan Raffin, Oleg M. Smirnov, and Benjamin V. Hugo. Multicore multi-node parallelization of the radio interferometric imaging pipeline ddfacet. In *2022 IEEE Workshop on Signal Processing Systems (SiPS)*, pages 1–6, 2022.

[9] A. R. Offringa and al. wsclean: an implementation of a fast, generic wide-field imager for radio astronomy. *Monthly Notices of the Royal Astronomical Society*, 444(1):606–619, August 2014.

[10] M. Pelcat and al. Preesm: A dataflow-based rapid prototyping framework for simplifying multicore dsp programming. *EDERC*, 2014.

[11] Rau, U. and Cornwell, T. J. A multi-scale multi-frequency deconvolution algorithm for synthesis imaging in radio interferometry. A&A, 532:A71, 2011.

[12] Matthew Rocklin. Dask: Parallel computation with blocked algorithms and task scheduling, 2015.

[13] O. Smirnov. Revisiting the radio interferometer measurement equation. i. a full-sky jones formalism. *Astron. Astro.*, 2011.

[14] C. Tasse, B. Hugo, M. Mirmont, O. Smirnov, M. Atemkeng, L. Bester, M. J. Hardcastle, R. Lakhoo, S. Perkins, and T. Shimwell. Faceting for direction-dependent spectral deconvolution. *Astronomy & Astrophysics*, 611:A87, March 2018.

[15] The CASA Team, Ben Bean, and al. Casa, the common astronomy software applications for radio astronomy. *Publications of the Astronomical Society of the Pacific*, 134(1041):114501, November 2022.

[16] G.N.J. van Diepen. Casacore table data system and its use in the measurementset. *Astronomy and Computing*, 12:174–180, 2015.

[17] Sunrise Wang and al. An initial framework for prototyping radio-interferometric imaging pipelines. *DASIP*, 2024.

[18] Chen Wu and al. Daliuge: A graph execution framework for harnessing the astronomical data deluge. *Astron. Comput.*, 2017.