Official homepage: www.allinea.com/products/map
Allinea/ARM MAP is a profiler for C/C++, Fortran and Python. It helps you to analyze where your code spends its CPU time, to identify MPI communication, as well as memory usage and I/O performance. Allinea-MAP gives you a collective result over all cores, which makes it easier to identify the major bottlenecks in your code.
For details, we refer to the official User Manual
Please contact if you have any questions or problems.
1. Adding Debug information
To get the most benefit from the performance profiler, you should compile your code including debugging information. To do so, you have to add the compiler flag
-g. Only this way you can exactly see where the time is being spend in your code. The flag
-g typically does not slow down the executable in most cases, but increases the size of the program as it contains additional debugging symbols.
2. Optimization Flags
To optimize your code with the Allinea-MAP profiler, you should compile your program with optimization flags, e.g.
-O2. If you do not include your standard optimization flags, you may try to optimize parts of your code, that can already be optimized by the compiler.
3. Linking your program
For the basic use of Allinea-MAP, you do not need to link any extra library to your executable. Allinea-MAP will automatically link its required libraries at runtime. Sometimes, this automatic procedure causes problems. Particularly for parallel programs, you should read the section How to run Allinea-MAP for Parallel Codes.
Load the Allinea-MAP module corresponding to the version that you want to use, e.g.,
module load allinea-MAP/20.0.3
To interactively profile a serial code with Allinea-MAP, start your application as following:
It will launch the graphical user interface to profile your application.
Allinea-MAP can also be started in a non-interactive mode, which is used e.g. within a slurm batch script:
map --profile ./your_executable
Allinea-MAP writes a
*.map file to disk, that contains the profiling data. You can view the map-file as following:
A map-file will also be created when using the interactive graphical user interface.
To profile a parallel code, Allinea-MAP needs to access MPI. You should load the parallel environment that was used to compile your code. If you do not remember the build-environment that was used to compile the code, or if it is unknown to you, you can check how it was build on Tetralith/Sigma as following:
dumptag will tell you, how the executable was built. For example, to see how the executable
OpenFOAM was built (we omit loading the OpenFOAM module for brievety):
gives the output
NSC tags --------------------------------- Build date 190912 Build time 164115 Built with MPI impi 2018_3_222__eb Linked with intel 2018b__eb Tag version 6 ------------------------------------------
Here we see, that the build-environment
intel 2018b__eb was used. Accordingly, we load the following module in this case:
module load buildenv-intel/2018b-eb
Now, we have loaded the required modules, e.g.
module load allinea-MAP/20.0.3 module load buildenv-intel/2018b-eb
To profile your parallel code, start your application as following:
Interactive mode, with GUI
map mpiexec.hydra ./your_parallel_executable
Non-interactive mode, without GUI
map --profile mpiexec.hydra ./your_parallel_executable
Profiling of parallel codes should be done on a compute node, either interactively or in a slurm batch script. In a slurm batch script you always have to use the option:
map --profile, such that the GUI will not be started.
Note: It is important to use
mpiexec.hydra but not
mpiexec.hydra -bootstrap slurm The latter leads to problems with the Allinea sampler.