FPM and MPIRUN Explained for High-Performance Computing

High-performance computing often depends on two separate but connected activities: building scientific software and running it across many processors. In many Fortran-based HPC projects, FPM, the Fortran Package Manager, helps organize, compile, test, and manage code. MPIRUN, meanwhile, launches parallel programs that use the Message Passing Interface, allowing work to be distributed across cores, nodes, and clusters.

TLDR: FPM helps developers build and manage Fortran projects in a structured, repeatable way. MPIRUN starts MPI-enabled applications and controls how many processes run and where they run. In HPC workflows, FPM may prepare the executable, while MPIRUN executes it at scale across a computing system. Together, they support cleaner development and more efficient parallel execution.

What FPM Means in HPC

In the context of modern Fortran development, FPM usually refers to the Fortran Package Manager. It provides a standard project layout and a command-line interface for compiling applications, running tests, and handling dependencies. For research groups and engineering teams, this reduces the need for large, custom build scripts that are difficult to maintain.

Traditional HPC Fortran projects often rely on Makefiles, CMake configurations, or site-specific scripts. These tools are powerful, but they can become complex when a codebase grows. FPM offers a more direct approach: a project contains source files, a configuration file, and optional test or example directories. The package manager then understands how to build the project consistently.

A typical FPM project includes a file named fpm.toml. This file defines the package name, version, dependencies, executables, libraries, and tests. Instead of manually listing every compilation command, the project maintainer describes the package, while FPM handles much of the build logic.

Common FPM Tasks

FPM is especially useful during development because it supports a small set of clear commands. These commands help programmers move from source code to executable programs with less friction.

• fpm build: compiles the project and creates libraries or executables.
• fpm run: builds the project if needed and runs the selected executable.
• fpm test: builds and runs test programs, helping verify correctness.
• fpm new: creates a new project with a standard directory structure.
• Dependency management: allows projects to reference other Fortran packages.

For HPC teams, repeatability is one of FPM’s biggest advantages. When a project follows a known structure, a new team member or a continuous integration system can build it more easily. This is valuable in scientific computing, where results must often be reproduced months or years later.

What MPIRUN Does

MPIRUN is a command used to start programs that are written with MPI, the Message Passing Interface. MPI is a standard model for parallel programming in distributed-memory systems. It allows multiple processes to communicate by sending and receiving messages. This is essential when a calculation is too large for a single processor or even a single machine.

Different MPI implementations provide similar launch commands. Systems may use mpirun, mpiexec, or scheduler-specific wrappers. Open MPI, MPICH, Intel MPI, and other MPI distributions all provide tools for launching parallel applications, though their options may vary slightly.

A simple command may look like this:

mpirun -np 16 ./simulation

In this example, -np 16 requests 16 MPI processes, and ./simulation is the executable to run. Each process starts the same program, but the program uses MPI calls to determine its rank, communicate with other processes, and divide the workload.

How MPIRUN Works Across Nodes

On a workstation, mpirun may launch several processes on the same machine. On a cluster, it can launch processes across multiple compute nodes. The exact behavior depends on the MPI implementation, cluster configuration, and job scheduler. In managed HPC environments, users often submit jobs through systems such as Slurm, PBS, or LSF, and mpirun works within the allocated resources.

For example, a Slurm job script may request several nodes and then call mpirun or srun to start the application. The scheduler decides which nodes are assigned, while the MPI launcher starts the requested number of processes within that allocation. This separation prevents users from accidentally launching jobs on unassigned resources.

How FPM and MPIRUN Fit Together

FPM and MPIRUN solve different problems, but they often appear in the same workflow. FPM is primarily a build and project management tool. MPIRUN is primarily an execution and process launch tool. A common HPC workflow may involve using FPM to compile an MPI-enabled Fortran program, then using MPIRUN to run the produced executable in parallel.

For example, an MPI-based Fortran project may be built with:

fpm build

After the executable is created, it may be launched with:

mpirun -np 64 ./build/gfortran_debug/app/my_solver

The exact executable path depends on the compiler, build profile, and FPM project settings. In production environments, teams may create scripts that locate the executable automatically or copy it into a run directory alongside input files.

Compiler and MPI Considerations

MPI programs are usually compiled with wrapper compilers such as mpifort, mpicc, or mpiCC. For Fortran projects, mpifort is commonly used because it automatically includes the correct MPI libraries and compiler flags. When FPM builds an MPI application, it may need to be configured so that the Fortran compiler is the MPI wrapper.

For instance, an environment may set:

FPM_FC=mpifort

This tells FPM to use mpifort as the Fortran compiler. The result is an executable linked correctly against the MPI library. Without this step, the build may fail because MPI modules or symbols cannot be found.

Best Practices for HPC Use

To use FPM and MPIRUN effectively, HPC projects benefit from a few practical habits:

1. Keep builds reproducible: record compiler versions, MPI implementations, and FPM settings.
2. Use tests early: run fpm test before launching large jobs.
3. Match MPI environments: build and run with the same MPI implementation whenever possible.
4. Respect scheduler rules: launch MPI jobs only within allocated cluster resources.
5. Scale gradually: test with a small number of processes before moving to hundreds or thousands.

Performance tuning also matters. A program that runs correctly with four processes may not scale efficiently to 4,000. Communication patterns, memory layout, file I/O, and network topology can all affect results. MPIRUN starts the processes, but application design determines how well they cooperate.

Why They Matter

FPM and MPIRUN represent two important layers of HPC productivity. FPM improves the daily experience of developing Fortran software by making builds and tests more manageable. MPIRUN enables that software to use the power of parallel hardware. When used together, they help scientific teams move from code development to large-scale execution with fewer manual steps and fewer configuration errors.

For organizations that depend on simulations, modeling, numerical solvers, or data-intensive research, this combination supports both software quality and computational scale. FPM does not replace MPI, and MPIRUN does not replace a build system. Instead, each tool handles a distinct part of the HPC lifecycle.

FAQ

• What does FPM stand for in this context?
  It stands for Fortran Package Manager, a tool for building, testing, and managing Fortran projects.
• What does MPIRUN do?
  MPIRUN launches MPI programs across multiple processes, often on multiple cores or compute nodes.
• Can FPM run MPI programs directly?
  FPM can run executables, but large MPI jobs are usually launched with mpirun, mpiexec, or a scheduler command.
• Does every Fortran HPC project need FPM?
  No. Some projects use Make, CMake, or custom systems. FPM is useful when a simpler, standardized Fortran workflow is preferred.
• Is mpirun the same as mpiexec?
  They are closely related and often behave similarly, but details depend on the MPI implementation and cluster environment.
• Why is mpifort important?
  mpifort is an MPI Fortran compiler wrapper that supplies the correct include paths, modules, and libraries needed for MPI programs.