Fortran interface layer of the framework for developing particle simulator FDPS

Numerical simulations based on particle methods have been widely used in various fields including astrophysics. To date, simulation softwares have been developed by individual researchers or research groups in each field, with a huge amount of time and effort, even though numerical algorithms used are very similar. To improve the situation, we have developed a framework, called FDPS, which enables researchers to easily develop massively parallel particle simulation codes for arbitrary particle methods. Until version 3.0, FDPS have provided API only for C++ programing language. This limitation comes from the fact that FDPS is developed using the template feature in C++, which is essential to support arbitrary data types of particle. However, there are many researchers who use Fortran to develop their codes. Thus, the previous versions of FDPS require such people to invest much time to learn C++. This is inefficient. To cope with this problem, we newly developed a Fortran interface layer in FDPS, which provides API for Fortran. In order to support arbitrary data types of particle in Fortran, we design the Fortran interface layer as follows. Based on a given derived data type in Fortran representing particle, a Python script provided by us automatically generates a library that manipulates the C++ core part of FDPS. This library is seen as a Fortran module providing API of FDPS from the Fortran side and uses C programs internally to interoperate Fortran with C++. In this way, we have overcome several technical issues when emulating `template’ in Fortran. By using the Fortran interface, users can develop all parts of their codes in Fortran. We show that the overhead of the Fortran interface part is sufficiently small and a code written in Fortran shows a performance practically identical to the one written in C++.

💡 Research Summary

This paper presents the design, implementation, and evaluation of a Fortran interface layer for the FDPS (Framework for Developing Particle Simulators), a framework designed to simplify the development of large-scale parallel particle simulation codes.

The core problem addressed is that FDPS, prior to version 4.0, provided an Application Programming Interface (API) exclusively for C++. This was because FDPS heavily relies on C++ template metaprogramming to generically support arbitrary user-defined particle data types without sacrificing performance. This posed a significant barrier to the many computational scientists in fields like astrophysics and fluid dynamics who primarily use Fortran for legacy, performance, or preference reasons.

The paper first reviews the architecture of the FDPS core. FDPS provides templated C++ classes (e.g., ParticleSystem, TreeForForce) that handle complex tasks essential for distributed-memory parallel simulations: domain decomposition, particle migration between processes, and the efficient computation of particle-particle interactions using tree algorithms. To use FDPS, a C++ user must define several specific classes representing their particle data, which are then passed as template parameters to the FDPS classes.

The novel contribution is the Fortran interface, which allows users to write complete simulation codes in Fortran while leveraging the optimized C++ core of FDPS. The key technical challenge was emulating C++ templates in Fortran, which lacks such a feature. The solution is an elegant meta-programming approach centered around a Python script.

Here is how it works: A user defines their particle data as a Fortran derived type. A provided Python script parses this Fortran source code to understand the structure of the particle type (e.g., identifying which member represents the position vector). Based on this analysis, the script automatically generates a glue layer consisting of two parts: 1) A set of C functions that act as intermediaries, knowing how to convert the Fortran derived type into the corresponding C++ classes expected by the FDPS core, and 2) A Fortran module that wraps these C functions, presenting to the user a pure Fortran API that mirrors the functionality of the original C++ API. The generated Fortran module uses the standard ISO_C_BINDING feature to call the C functions, which in turn use extern "C" to call into the templated C++ library of FDPS. This multi-layer design cleanly bridges the language gap.

From the user’s perspective, the process is simple: define a particle type, run the Python script to generate the custom library, and then use the generated Fortran module in their code. They can then call subroutines like psys%exchange_particle(dinfo) entirely in Fortran.

The paper rigorously evaluates the performance overhead of this interface. Using a standard gravitational N-body simulation as a benchmark, the authors compare a code written directly in C++ against a code written in Fortran using the new interface. The results demonstrate that the overhead introduced by the Fortran interface layer is negligible. The performance of the Fortran code is practically identical to that of the native C++ code, proving the efficiency of the auto-generated glue code.

In conclusion, the Fortran interface layer successfully extends the accessibility of the high-performance FDPS framework to the Fortran community. It removes the need for Fortran programmers to learn C++ or rewrite existing codes, thereby promoting code reuse and lowering the development barrier for sophisticated parallel particle simulations across scientific disciplines. The implementation strategy, using a parsing and code-generation script, serves as a robust model for providing Fortran bindings to complex templated C++ libraries.