Romain Pereira
Romain Pereira has a total of 14 co-authors. Here are the top co-authors by number of shared publications:
Thierry Gautier
3 shared publications- Adrien Roussel
CEA, LIHPC, F-91297, France
2 shared publications Brice Videau
2 shared publications- Patrick Carribault
CEA, LIHPC, F-91297, France
2 shared publications Pierre-Etienne Polet
2 shared publicationsSwann Perarnau
2 shared publications
Latest Publications
- Open Access
- 23 March 2026
- Published by Elsevier in SSRN Electronic Journal
XKRT: a Runtime System for Macro-Dataflow Programming on Multi-Devices Architectures
Exascale supercomputers and AI factories integrate multiple heterogeneous processing units and memories, all interconnected in a non-uniform network. Parallel programming models in production systems still mostly require manual memory management and synchronizations---a practice that is error-prone, nonportable, and increasingly difficult on modern high-performance compute nodes. This paper introduces XKRT: a macro-dataflow and tasking runtime system for automating memory management alongside parallel execution. It provides portable abstraction for C, C++, Julia and partial support for OpenMP. It offers(i) low-level building blocks for manual threads, tasks, memory, and accelerators management portably across all HPC GPU vendors, (ii) higher-level blocks to automatically manage memory and synchronize over accessed regions of memory and(iii) a threading engine ensuring the progression of concurrent and heterogeneous operations (file I/O, GPU commands, etc.).We evaluate XKRT across 7 different GPUs from 3 vendors, demonstrating around $1\mu s$ scheduling overheads per task. We illustrate XKRT's capability to assist parallel programming with OpenMP support, drop-in interfaces for asynchronous I/O, multi-GPU stencil, and support for the XKBlas API---a composable multi-GPU BLAS library. Results show 6x speedup against GH200 C2C protocol, illustrating benefits of enriched macro-dataflow programming.- 23 March 2026
- Published by Elsevier in SSRN Electronic Journal
Open AccessXKRT: a Runtime System for Macro-Dataflow Programming on Multi-Devices Architectures
Exascale supercomputers and AI factories integrate multiple heterogeneous processing units and memories, all interconnected in a non-uniform network. Parallel programming models in production systems still mostly require manual memory management and synchronizations---a practice that is error-prone, nonportable, and increasingly difficult on modern high-performance compute nodes. This paper introduces XKRT: a macro-dataflow and tasking runtime system for automating memory management alongside parallel execution. It provides portable abstraction for C, C++, Julia and partial support for OpenMP. It offers(i) low-level building blocks for manual threads, tasks, memory, and accelerators management portably across all HPC GPU vendors, (ii) higher-level blocks to automatically manage memory and synchronize over accessed regions of memory and(iii) a threading engine ensuring the progression of concurrent and heterogeneous operations (file I/O, GPU commands, etc.).We evaluate XKRT across 7 different GPUs from 3 vendors, demonstrating around $1\mu s$ scheduling overheads per task. We illustrate XKRT's capability to assist parallel programming with OpenMP support, drop-in interfaces for asynchronous I/O, multi-GPU stencil, and support for the XKBlas API---a composable multi-GPU BLAS library. Results show 6x speedup against GH200 C2C protocol, illustrating benefits of enriched macro-dataflow programming. - Open Access
- 23 March 2026
- Published by Elsevier in SSRN Electronic Journal
XKRT: a Runtime System for Macro-Dataflow Programming on Multi-Devices Architectures
Exascale supercomputers and AI factories integrate multiple heterogeneous processing units and memories, all interconnected in a non-uniform network. Parallel programming models in production systems still mostly require manual memory management and synchronizations---a practice that is error-prone, nonportable, and increasingly difficult on modern high-performance compute nodes. This paper introduces XKRT: a macro-dataflow and tasking runtime system for automating memory management alongside parallel execution. It provides portable abstraction for C, C++, Julia and partial support for OpenMP. It offers(i) low-level building blocks for manual threads, tasks, memory, and accelerators management portably across all HPC GPU vendors, (ii) higher-level blocks to automatically manage memory and synchronize over accessed regions of memory and(iii) a threading engine ensuring the progression of concurrent and heterogeneous operations (file I/O, GPU commands, etc.).We evaluate XKRT across 7 different GPUs from 3 vendors, demonstrating around $1\mu s$ scheduling overheads per task. We illustrate XKRT's capability to assist parallel programming with OpenMP support, drop-in interfaces for asynchronous I/O, multi-GPU stencil, and support for the XKBlas API---a composable multi-GPU BLAS library. Results show 6x speedup against GH200 C2C protocol, illustrating benefits of enriched macro-dataflow programming.- 23 March 2026
- Published by Elsevier in SSRN Electronic Journal
Open AccessXKRT: a Runtime System for Macro-Dataflow Programming on Multi-Devices Architectures
Exascale supercomputers and AI factories integrate multiple heterogeneous processing units and memories, all interconnected in a non-uniform network. Parallel programming models in production systems still mostly require manual memory management and synchronizations---a practice that is error-prone, nonportable, and increasingly difficult on modern high-performance compute nodes. This paper introduces XKRT: a macro-dataflow and tasking runtime system for automating memory management alongside parallel execution. It provides portable abstraction for C, C++, Julia and partial support for OpenMP. It offers(i) low-level building blocks for manual threads, tasks, memory, and accelerators management portably across all HPC GPU vendors, (ii) higher-level blocks to automatically manage memory and synchronize over accessed regions of memory and(iii) a threading engine ensuring the progression of concurrent and heterogeneous operations (file I/O, GPU commands, etc.).We evaluate XKRT across 7 different GPUs from 3 vendors, demonstrating around $1\mu s$ scheduling overheads per task. We illustrate XKRT's capability to assist parallel programming with OpenMP support, drop-in interfaces for asynchronous I/O, multi-GPU stencil, and support for the XKBlas API---a composable multi-GPU BLAS library. Results show 6x speedup against GH200 C2C protocol, illustrating benefits of enriched macro-dataflow programming. - 12 June 2025
- Published by Elsevier in Future Generation Computer Systems
- Vol. 174
Measuring and interpreting performances of HPC applications with dependent tasks
- 12 June 2025
- Published by Elsevier in Future Generation Computer Systems
- Vol. 174
Measuring and interpreting performances of HPC applications with dependent tasks
- Open Access
- 11 January 2024
- Published by Association for Computing Machinery (ACM)
- p. 7-16
An Overview on Mixing MPI and OpenMP Dependent Tasking on A64FX
The adoption of ARM processor architectures is on the rise in the HPC ecosystem. Fugaku supercomputer is a homogeneous ARM-based machine, and is one among the most powerful machine in the world. In the programming world, dependent task-based programming models are gaining tractions due to their many advantages: dynamic load balancing, implicit expression of communication/computation overlap, early-bird communication posting,...MPI and OpenMP are two widespreads programming standards that make possible task-based programming at a distributed memory level. Despite its many advantages, mixed-use of the standard programming models using dependent tasks is still under-evaluated on large-scale machines. In this paper, we provide an overview on mixing OpenMP dependent tasking model with MPI with the state-of-the-art software stack (GCC-13, Clang17, MPC-OMP). We provide the level of performances to expect by porting applications to such mixed-use of the standard on the Fugaku supercomputers, using two benchmarks (Cholesky, HPCCG) and a proxy-application (LULESH). We show that software stack, resource binding and communication progression mechanisms are factors that have a significant impact on performance. On distributed applications, performances reaches up to 80% of effiency for task-based applications like HPCCG. We also point-out a few areas of improvements in OpenMP runtimes.
- 11 January 2024
- Published by Association for Computing Machinery (ACM)
- p. 7-16
Open AccessAn Overview on Mixing MPI and OpenMP Dependent Tasking on A64FX
The adoption of ARM processor architectures is on the rise in the HPC ecosystem. Fugaku supercomputer is a homogeneous ARM-based machine, and is one among the most powerful machine in the world. In the programming world, dependent task-based programming models are gaining tractions due to their many advantages: dynamic load balancing, implicit expression of communication/computation overlap, early-bird communication posting,...MPI and OpenMP are two widespreads programming standards that make possible task-based programming at a distributed memory level. Despite its many advantages, mixed-use of the standard programming models using dependent tasks is still under-evaluated on large-scale machines. In this paper, we provide an overview on mixing OpenMP dependent tasking model with MPI with the state-of-the-art software stack (GCC-13, Clang17, MPC-OMP). We provide the level of performances to expect by porting applications to such mixed-use of the standard on the Fugaku supercomputers, using two benchmarks (Cholesky, HPCCG) and a proxy-application (LULESH). We show that software stack, resource binding and communication progression mechanisms are factors that have a significant impact on performance. On distributed applications, performances reaches up to 80% of effiency for task-based applications like HPCCG. We also point-out a few areas of improvements in OpenMP runtimes.
- Open Access
- 7 August 2023
- Published by Association for Computing Machinery (ACM)
- p. 163-172
Investigating Dependency Graph Discovery Impact on Task-based MPI+OpenMP Applications Performances
The architecture of supercomputers is evolving to expose massive parallelism. MPI and OpenMP are widely used in application codes on the largest supercomputers in the world. The community primarily focused on composing MPI with OpenMP before its version 3.0 introduced task-based programming. Recent advances in OpenMP task model and its interoperability with MPI enabled fine model composition and seamless support for asynchrony. Yet, OpenMP tasking overheads limit the gain of task-based applications over their historical loop parallelization (parallel for construct). This paper identifies the OpenMP task dependency graph discovery speed as a limiting factor in the performance of task-based applications. We study its impact on intra and inter-node performances over two benchmarks (Cholesky, HPCG) and a proxy-application (LULESH). We evaluate the performance impacts of several discovery optimizations, and introduce a persistent task dependency graph reducing overheads by a factor up to 15 at run-time. We measure 2x speedup over parallel for versions weak scaled to 16K cores, due to improved cache memory use and communication overlap, enabled by task refinement and depth-first scheduling.
- 7 August 2023
- Published by Association for Computing Machinery (ACM)
- p. 163-172
Open AccessInvestigating Dependency Graph Discovery Impact on Task-based MPI+OpenMP Applications Performances
The architecture of supercomputers is evolving to expose massive parallelism. MPI and OpenMP are widely used in application codes on the largest supercomputers in the world. The community primarily focused on composing MPI with OpenMP before its version 3.0 introduced task-based programming. Recent advances in OpenMP task model and its interoperability with MPI enabled fine model composition and seamless support for asynchrony. Yet, OpenMP tasking overheads limit the gain of task-based applications over their historical loop parallelization (parallel for construct). This paper identifies the OpenMP task dependency graph discovery speed as a limiting factor in the performance of task-based applications. We study its impact on intra and inter-node performances over two benchmarks (Cholesky, HPCG) and a proxy-application (LULESH). We evaluate the performance impacts of several discovery optimizations, and introduce a persistent task dependency graph reducing overheads by a factor up to 15 at run-time. We measure 2x speedup over parallel for versions weak scaled to 16K cores, due to improved cache memory use and communication overlap, enabled by task refinement and depth-first scheduling.