Simulating MPI Applications
===========================
-.. warning:: This document is still in early stage. You can try to
- take this tutorial, but should not be surprised if things fall short.
- It will be completed for the next release, v3.22, released by the end
- of 2018.
-
Discover SMPI
-------------
Simple Example with 3 hosts
...........................
-At the most basic level, you can describe your simulated platform as a
-graph of hosts and network links. For instance:
+Imagine you want to describe a little platform with three hosts,
+interconnected as follows:
.. image:: /tuto_smpi/3hosts.png
:align: center
+This can be done with the following platform file, that considers the
+simulated platform as a graph of hosts and network links.
+
.. literalinclude:: /tuto_smpi/3hosts.xml
:language: xml
-Note the way in which hosts, links, and routes are defined in
-this XML. All hosts are defined with a speed (in Gflops), and links
-with a latency (in us) and bandwidth (in MBytes per second). Other
-units are possible and written as expected. Routes specify the list of
-links encountered from one route to another. Routes are symmetrical by
-default.
+The elements basic elements (with :ref:`pf_tag_host` and
+:ref:`pf_tag_link`) are described first, and then the routes between
+any pair of hosts are explicitely given with :ref:`pf_tag_route`. Any
+host must be given a computational speed (in flops) while links must
+be given a latency (in seconds) and a bandwidth (in bytes per
+second). Note that you can write 1Gflops instead of 1000000000flops,
+and similar. Last point: :ref:`pf_tag_route`s are symmetrical by
+default (but this can be changed).
Cluster with a Crossbar
.......................
when you log out of the container, so don't edit the other files!
All needed dependencies are already installed in this container
-(SimGrid, the C/C++/Fortran compilers, make, pajeng and R). Vite being
+(SimGrid, the C/C++/Fortran compilers, make, pajeng, R and pajengr). Vite being
only optional in this tutorial, it is not installed to reduce the
image size.
sudo apt install simgrid pajeng make gcc g++ gfortran vite
+For R analysis of the produced traces, you may want to install R,
+and the `pajengr<https://github.com/schnorr/pajengr#installation/>`_ package.
+
+.. code-block:: shell
+
+ sudo apt install r-base r-cran-devtools cmake flex bison
+ Rscript -e "library(devtools); install_github('schnorr/pajengr');"
+
To take this tutorial, you will also need the platform files from the
previous section as well as the source code of the NAS Parallel
Benchmarks. Just clone `this repository
Feel free to tweak the content of the XML platform file and the
program to see the effect on the simulated execution time. It may be
easier to compare the executions with the extra option
-``--cfg=smpi/display_timing:yes``. Note that the simulation accounts
+``--cfg=smpi/display-timing:yes``. Note that the simulation accounts
for realistic network protocol effects and MPI implementation
effects. As a result, you may see "unexpected behavior" like in the
real world (e.g., sending a message 1 byte larger may lead to
.. code-block:: shell
smpirun -np 4 -platform ../cluster_backbone.xml -trace --cfg=tracing/filename:lu.S.4.trace bin/lu.S.4
- pj_dump --ignore-incomplete-links lu.S.4.trace | grep State > lu.S.4.state.csv
You can then produce a Gantt Chart with the following R chunk. You can
either copy/paste it in a R session, or `turn it into a Rscript executable
.. code-block:: R
+ library(pajengr)
library(ggplot2)
# Read the data
- df_state = read.csv("lu.S.4.state.csv", header=F, strip.white=T)
+ df_state = pajeng_read("lu.S.4.trace")
names(df_state) = c("Type", "Rank", "Container", "Start", "End", "Duration", "Level", "State");
df_state = df_state[!(names(df_state) %in% c("Type","Container","Level"))]
df_state$Rank = as.numeric(gsub("rank-","",df_state$Rank))
This produces a file called ``Rplots.pdf`` with the following
content. You can find more visualization examples `online
-<http://simgrid.gforge.inria.fr/contrib/R_visualization.html>`_.
+<https://simgrid.org/contrib/R_visualization.html>`_.
.. image:: /tuto_smpi/img/lu.S.4.png
:align: center
The commands should be separated and executed by some CI to make sure
the documentation is up-to-date.
-Lab 3: Execution Sampling on EP
+Lab 3: Execution Sampling on Matrix Multiplication example
-------------------------------
The second method to speed up simulations is to sample the computation
simulation accuracy. Furthermore there should not be any MPI calls
inside such parts of the code.
-Use the EP benchmark, class B, 16 processes.
+Use for this part the `gemm_mpi.c
+<https://gitlab.com/PRACE-4IP/CodeVault/raw/master/hpc_kernel_samples/dense_linear_algebra/gemm/mpi/src/gemm_mpi.cpp>`_
+example, which is provided by the `PRACE Codevault repository
+<http://www.prace-ri.eu/prace-codevault/>`_.
+
+The computing part of this example is the matrix multiplication routine
+
+.. literalinclude:: /tuto_smpi/gemm_mpi.cpp
+ :language: c
+ :lines: 4-19
+
+
+.. code-block:: shell
+
+ $ smpicc -O3 gemm_mpi.cpp -o gemm
+ $ time smpirun -np 16 -platform cluster_crossbar.xml -hostfile cluster_hostfile --cfg=smpi/display-timing:yes --cfg=smpi/running-power:1000000000 ./gemm
+
+This should end quite quickly, as the size of each matrix is only 1000x1000.
+But what happens if we want to simulate larger runs ?
+Replace the size by 2000, 3000, and try again.
+
+The simulation time increases a lot, while there are no more MPI calls performed, only computation.
+
+The ``--cfg=smpi/display-timing`` option gives more details about execution,
+and advises to use sampling if the time spent in computing loops seems too high.
+
+The ``--cfg=smpi/running-power:1000000000`` option sets the speed of the processor used for
+running the simulation. Here we say that its speed is the same as one of the
+processors we are simulation (1Gf), so that 1 second of computation is injected
+as 1 second in the simulation.
+
+.. code-block:: shell
+
+ [5.568556] [smpi_kernel/INFO] Simulated time: 5.56856 seconds.
+
+ The simulation took 24.9403 seconds (after parsing and platform setup)
+ 24.0764 seconds were actual computation of the application
+ [5.568556] [smpi_kernel/INFO] More than 75% of the time was spent inside the application code.
+ You may want to use sampling functions or trace replay to reduce this.
+
+So in our case (size 3000) the simulation ran for 25 seconds, and simulated time was 5.57s at the end.
+Computation by itself took 24 seconds, and can quickly grow with larger sizes
+(as computation is really performed, there will be variability between similar runs).
+
+SMPI provides sampling macros in order to accelerate simulation by sampling iterations
+of large computation loops, and skip computation after a certain amount of iterations,
+or when the sampling is stable enough.
+
+The two macros only slightly differ :
+
+- ``SMPI_SAMPLE_GLOBAL`` : specified number of samples is produced by all processors
+- ``SMPI_SAMPLE_LOCAL`` : each process executes a specified number of iterations
+
+So if the size of the computed part varies between processes (imbalance),
+it's safer to use the LOCAL one.
+
+To use one of them, replacing the external for loop of the multiply routine:
+
+.. code-block:: c
+
+ for (int i = istart; i <= iend; ++i)
+
+by:
+
+.. code-block:: c
+
+ SMPI_SAMPLE_GLOBAL(int i = istart, i <= iend, ++i, 10, 0.005)
+
+First three parameters are the ones from the loop, while the two last ones are for sampling.
+They mean that at most 10 iterations will be performed, and that sampling phase can be exited
+earlier if a certain stability is reached after less samples.
+
+Now run the code again with various sizes and parameters and check the time taken for the
+simulation, as well as the resulting simulated time.
+
+.. code-block:: shell
+
+ [5.575691] [smpi_kernel/INFO] Simulated time: 5.57569 seconds.
+ The simulation took 1.23698 seconds (after parsing and platform setup)
+ 0.0319454 seconds were actual computation of the application
+
+In this case the simulation only took 1.2 seconds, while the simulated time
+stayed almost identical.
+
+Obviously the results of the computation will be altered as most of it is skipped,
+so these macros cannot be used when results are critical for the application behavior
+(convergence estimation for instance will be wrong on some codes).
+
+
+Lab 4: Memory folding on large allocations
+-------------------------------
+
+Another issue that can be encountered when simulation with SMPI is lack of memory.
+Indeed we are executing all MPI processes on a single node, which can lead to crashes.
+We will use the DT benchmark of the NAS suite to illustrate how to avoid such issues.
+
+With 85 processes and class C, the DT simulated benchmark will try to allocate 35GB of memory
+, which may not be available on the node your are using.
+
+To avoid this we can simply replace the largest calls to malloc and free by calls
+to ``SMPI_SHARED_MALLOC`` and ``SMPI_SHARED_FREE``.
+This means that all processes will share one single instance of this buffer.
+As for sampling, results will be altered, and it shouldn't be used for control structures.
+
+For DT example, there are three different calls to malloc in the file, and one of them is for a needed structure.
+Find it and replace the two other ones by SMPI_SHARED_MALLOC (there is only one free to replace for both of them).
+
+Once done, you can now run
+
+.. code-block:: shell
+
+ $ make dt NPROCS=85 CLASS=C
+ (compilation logs)
+ $ smpirun -np 85 -platform ../cluster_backbone.xml bin/dt.C.x BH
+ (execution logs)
+
+And simulation should finish without swapping/crashing (Ignore the warning about the return value).
-.. todo:: write this section, and the following ones.
+If control structures are also problematic, you can use ``SMPI_PARTIAL_SHARED_MALLOC(size, offsets, offsetscount)``
+macro, which will shared only specific parts of the structure between processes,
+and use specific memory for the important parts.
+It can be freed afterwards with SMPI_SHARED_FREE.
Further Readings
----------------
