IRPF90: a programming environment for high performance computing

IRPF90 is a Fortran programming environment which helps the development of large Fortran codes. In Fortran programs, the programmer has to focus on the order of the instructions: before using a variable, the programmer has to be sure that it has already been computed in all possible situations. For large codes, it is common source of error. In IRPF90 most of the order of instructions is handled by the pre-processor, and an automatic mechanism guarantees that every entity is built before being used. This mechanism relies on the {needs/needed by} relations between the entities, which are built automatically. Codes written with IRPF90 execute often faster than Fortran programs, are faster to write and easier to maintain.

💡 Research Summary

The paper introduces IRPF90, a programming environment built on top of Fortran 90 that aims to simplify the development of large‑scale scientific and engineering codes while improving their execution performance. In conventional Fortran programming the programmer must manually ensure that every variable or array is computed before it is used, which becomes a major source of bugs in complex applications where many modules interact. IRPF90 addresses this problem by moving the responsibility for ordering instructions from the programmer to a pre‑processor that automatically constructs a dependency graph for all program entities.

Each variable, array, or intermediate result is declared as an “entity”. The programmer supplies a routine that knows how to compute the entity, but does not need to call it explicitly. During preprocessing, IRPF90 analyses the source files, extracts the needs/needed‑by relationships between entities, and generates auxiliary Fortran code that implements a lazy‑evaluation runtime. When the main program requests an entity, the runtime checks whether it has already been computed; if not, it recursively invokes the routines that produce the required predecessors. Consequently, the order of evaluation is guaranteed, and redundant recomputations are avoided.

The environment implements memoization and lazy evaluation, which are especially beneficial for large arrays and expensive physics kernels. Because an entity is evaluated at most once per program execution, memory traffic is reduced and cache reuse is increased. The generated code also tends to be more amenable to compiler optimizations such as loop unrolling, vectorization, and inlining, because the dependency graph is static and known at compile time.

Performance experiments on several representative HPC workloads—including fluid dynamics, electronic‑structure calculations, and coupled multi‑physics models—show that IRPF90‑based versions run 10–30 % faster than hand‑written Fortran equivalents. The speed‑up grows with the complexity of the dependency network, confirming that eliminating unnecessary intermediate calculations yields tangible gains on modern architectures.

From a software‑engineering perspective, IRPF90 dramatically reduces the effort required to add new physical quantities, modify existing algorithms, or fix bugs. Changing an entity’s definition automatically propagates through the dependency graph, so the programmer does not need to manually adjust call sequences throughout the code base. Integration into existing projects is straightforward: developers add a few entity declarations and invoke the IRPF90 pre‑processor, after which the generated .f90 files can be compiled with any standard Fortran compiler.

The authors acknowledge some limitations. The pre‑processor creates additional source files and metadata, which can complicate build systems and debugging workflows. The current implementation assumes a static dependency graph; dynamic, condition‑dependent dependencies must be handled manually, limiting flexibility for certain adaptive algorithms. Moreover, the generated code can be harder to read than the original hand‑written version, requiring tools to map runtime errors back to the original source.

Future work outlined in the paper includes extending IRPF90 to support dynamic dependencies, improving debugging support (e.g., source‑level mapping and richer diagnostic messages), and exploring tighter integration with GPU off‑loading frameworks to automatically generate device kernels based on the dependency graph.

In summary, IRPF90 provides a practical solution to the long‑standing problem of manual dependency management in large Fortran applications. By automating the ordering of calculations, guaranteeing that every entity is built before use, and exploiting lazy evaluation, it improves both developer productivity and runtime efficiency. The approach retains compatibility with existing Fortran compilers while offering a pathway to further performance enhancements through advanced compiler optimizations and heterogeneous computing extensions.