For non-Windows systems (Linux, macOS, or FreeBSD), head to `Jenkins <https://ci.inria.fr/simgrid/job/SimGrid>`_.
In the build history, pick the last green (or at least yellow) build that is not blinking (i.e., not currently under
-build). In the list, pick a system that is close to yours, and click on the ball in the Debug row. The build artefact
+build). In the list, pick a system that is close to yours, and click on the ball in the Debug row. The build artifact
will appear at the top of the resulting page.
For Windows, head to `AppVeyor <https://ci.appveyor.com/project/simgrid/simgrid>`_.
-Click on the artefact link on the right, and grab your file. If the latest build failed, there will be no artefact. Then
+Click on the artifact link on the right, and grab your file. If the latest build failed, there will be no artifact. Then
you will need to first click on "History" at the top and look for the last successful build.
Binary Java Troubleshooting
us. It seems that g++ 5.0 or higher is required nowadays (because of
boost). SimGrid compiles well with `clang` or `icc` too.
Python 3.
- SimGrid should build without Python, that is only needed by our regresion test suite.
+ SimGrid should build without Python. That is only needed by our regression test suite.
cmake (v3.5).
``ccmake`` provides a nicer graphical interface compared to ``cmake``.
Press ``t`` in ``ccmake`` if you need to see absolutely all
- configuration options (e.g., if your python installation is not standard).
+ configuration options (e.g., if your Python installation is not standard).
boost (at least v1.48, v1.59 recommended)
- On Debian / Ubuntu: ``apt install libboost-dev libboost-context-dev``
- On macOS with homebrew: ``brew install boost``
Build Configuration
^^^^^^^^^^^^^^^^^^^
-This section is about **compile-time options**, that are very
+This section is about **compile-time options**, which are very
different from :ref:`run-time options <options>`. Compile-time options
fall into two categories. **SimGrid-specific options** define which part
of the framework to compile while **Generic options** are provided by
Our build system often gets mixed up if you change something on
your machine after the build configuration. For example, if
SimGrid fails to detect your fortran compiler, it is not enough to
- install a fortran compiler. You also need to clean every Cmake
+ install a fortran compiler. You also need to delete all Cmake
files, such as ``CMakeCache.txt``. Since Cmake also generates some
files in the tree, you may need to wipe out your complete tree and
start with a fresh one when you install new dependencies.
Generic build-time options
""""""""""""""""""""""""""
-These options specify for example the path to various system elements
-(Python path, compiler to use, etc). In most case, CMake automatically
-discovers the right value for these ones, but you can set them
-manually on need. Notable such variables include ``CC`` and ``CXX``,
-defining respectively the paths to the C and C++ compilers, ``CFLAGS``
-and ``CXXFLAGS`` respectively specifying extra options to pass to the C
-and C++ compilers, or ``PYTHON_EXECUTABLE`` specifying the path to the
-python executable.
+These options specify, for example, the path to various system elements (Python
+path, compiler to use, etc). In most case, CMake automatically discovers the
+right value for these elements, but you can set them manually as needed.
+Notably, such variables include ``CC`` and ``CXX``, defining the paths to the C
+and C++ compilers; ``CFLAGS`` and ``CXXFLAGS`` specifying extra options to pass
+to the C and C++ compilers; and ``PYTHON_EXECUTABLE`` specifying the path to the
+Python executable.
The best way to discover the exact name of the option that you need to
change is to press ``t`` in the ``ccmake`` graphical interface, as all
interface for that, or you can use environment variables, or you can
prefer the ``-D`` flag of ``cmake``.
-For example, you can change the compilers with environment variables
-by issuing these commands before launching cmake:
+For example, you can change the compilers by issuing these commands to set some
+environment variables before launching cmake:
.. code-block:: shell
export CXX=g++-5.1
The same can be done by passing ``-D`` parameters to cmake, as follows.
-Note that the ending dot is mandatory (see :ref:`install_cmake_outsrc`).
+Note that the dot at the end is mandatory (see :ref:`install_cmake_outsrc`).
.. code-block:: shell
"""""""""""""""""""""""""""
Here is the list of all SimGrid-specific compile-time options (the
-default choice is in uppercase).
+default choice is in upper case).
CMAKE_INSTALL_PREFIX (path)
Where to install SimGrid (/opt/simgrid, /usr/local, or elsewhere).
enable_compile_optimizations (ON/off)
- Request the compiler to produce efficient code. You probably want to
- activate this option, unless you plan modify SimGrid itself:
- efficient code takes more time to compile, and appears mangled to debuggers.
+ Ask the compiler to produce efficient code. You probably want to
+ leave this option activated, unless you plan to modify SimGrid itself:
+ efficient code takes more time to compile, and appears mangled to some debuggers.
enable_compile_warnings (on/OFF)
- Request the compiler to issue error messages whenever the source
+ Ask the compiler to issue error messages whenever the source
code is not perfectly clean. If you are a SimGrid developer, you
have to activate this option to enforce the code quality. As a
regular user, this option is of little use.
enable_debug (ON/off)
- Disabling this option discards all log messages of gravity
+ Disabling this option discards all log messages of severity
debug or below at compile time (see @ref XBT_log). The resulting
code is faster than if you discard these messages at
runtime. However, it obviously becomes impossible to get any debug
Generates the java bindings of SimGrid.
enable_jedule (on/OFF)
- Produces execution traces from SimDag simulations, that can then be visualized with the
+ Produces execution traces from SimDag simulations, which can then be visualized with the
Jedule external tool.
enable_lua (on/OFF)
enable_lto (ON/off)
Enables the *Link Time Optimization* in the C++ compiler.
- This feature really speeds up the produced code, but it is fragile
+ This feature really speeds up the code produced, but it is fragile
with older gcc versions.
enable_maintainer_mode (on/OFF)
Activates the ns-3 bindings. See section :ref:`model_ns3`.
enable_smpi (ON/off)
- Allows to run MPI code on top of SimGrid.
+ Allows one to run MPI code on top of SimGrid.
enable_smpi_ISP_testsuite (on/OFF)
Adds many extra tests for the model-checker module.
Python-specific instructions
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Recompiling the python bindings from the source should be as easy as:
+Recompiling the Python bindings from the source should be as easy as:
.. code-block:: shell
- The **Simulated Platform**. This is a description of a given
distributed system (machines, links, disks, clusters, etc). Most of
- the platform files are written in XML althrough a Lua interface is
+ the platform files are written in XML although a Lua interface is
under development. SimGrid makes it easy to augment the Simulated
Platform with a Dynamic Scenario where for example the links are
slowed down (because of external usage) or the machines fail. You
- have even support to specify the applicative workload that you want
+ even have support to specify the applicative workload that you want
to feed to your application
:ref:`(more info) <platform>`.
terminology, the application is an inert set of source files and
binaries. To make it run, you have to describe how your application
should be deployed on the simulated platform. You need to specify
- which process is mapped on which machine, along with their parameters
+ which process is mapped onto which machine, along with their parameters
:ref:`(more info) <scenario>`.
- The **Platform Models**. They describe how the simulated platform
explored. In some sense, this mode tests your application for all
possible platforms that you could imagine (and more).
-You just provide the application and its deployment (amount of
+You just provide the application and its deployment (number of
processes and parameters), and the model-checker will literally
explore all possible outcomes by testing all possible message
interleavings: if at some point a given process can either receive the
arrives first, and then rewind to the same point to explore the
scenario where B arrives first.
-This is a very powerful mode, where you can evaluate the correction of
+This is a very powerful mode, where you can evaluate the correctness of
your application. It can verify either **safety properties** (asserts)
-or **liveless properties** stating for example that if a given event
+or **liveness properties** stating for example that if a given event
occurs, then another given event will occur in a finite amount of
steps. This mode is not only usable with the abstract algorithms
developed on top of the SimGrid APIs, but also with real MPI
applications (to some extent).
-The main limit of Model Checking lays in the huge amount of scenarios
+The main limit of Model Checking lies in the huge amount of scenarios
to explore. SimGrid tries to explore only non-redundant scenarios
thanks to classical reduction techniques (such as DPOR and stateful
exploration) but the exploration may well never finish if you don't
carefully adapt your application to this mode.
A classical trap is that the Model Checker can only verify whether
-your application fits the provided properties, which is useless if you
+your application fits the properties provided, which is useless if you
have a bug in your property. Remember also that one way for your
-application to never violate a given assert is to not start at all
+application to never violate a given assert is to not start at all,
because of a stupid bug.
Another limit of this mode is that it does not use the performance
The model checker may well miss existing issues, as it computes the
possible outcomes *from a given initial situation*. There is no way to
-prove the correction of your application in all generality with this
+prove the correctness of your application in full generality with this
tool.
**Benchmark Recording Mode**. During debug sessions, continuous
integration testing, and other similar use cases, you are often only
-interested in the control flow. If your application apply filters to
-huge images split in small blocks, the filtered image is probably not
+interested in the control flow. If your application applies filters to
+huge images split into small blocks, the filtered image is probably not
what you are interested in. You are probably looking for a way to run
-each computation kernel only once, save on disk the time it takes and
-some other metadata. This code block can then be skipped in simulation
+each computational kernel only once, and record the time it takes to cache it.
+This code block can then be skipped in simulation
and replaced by a synthetic block using the cached information. The
simulated platform will take this block into account without requesting
-the real hosting machine to benchmark it.
+the actual hosting machine to benchmark it.
SimGrid Limits
--------------
-This framework is by no means the perfect holly grail able to solve
-every problem on earth.
+This framework is by no means the holly grail, able to solve
+every problem on Earth.
**SimGrid scope is limited to distributed systems.** Real-time
-multi-threaded systems are out of scope. You could probably tweak
+multi-threaded systems are out of this scope. You could probably tweak
SimGrid for such studies (or the framework could possibly be extended
in this direction), but another framework specifically targeting such a
use case would probably be more suited.
The framework could certainly be improved in this direction, but this
still has to be done.
-**There is no perfect model, only models adapted to your study.**
-The SimGrid models target fast and large studies yet requesting
-realistic results. In particular, our models abstract away parameters
-and phenomena that are often irrelevant to the realism in our
-context.
+**There is no perfect model, only models adapted to your study.** The SimGrid
+models target fast and large studies, and yet they target realistic results. In
+particular, our models abstract away parameters and phenomena that are often
+irrelevant to reality in our context.
-SimGrid is simply not intended to any study that would mandate the
-abstracted phenomenon. Here are some **studies that you should not do
-with SimGrid**:
+SimGrid is obviously not intended for a study of any phenomenon that our
+abstraction removes. Here are some **studies that you should not do with
+SimGrid**:
- Studying the effect of L3 vs. L2 cache effects on your application
- Comparing kernel schedulers and policies
cluster before its construction
(`paper <http://hal.inria.fr/hal-00919507>`_). In this case,
some differences between the prediction and the real timings were due to
-misconfiguration or other problems with the real platform. To some extent,
+misconfigurations with the real platform. To some extent,
SimGrid could even be used to debug the real platform :)
SimGrid is also used to debug, improve, and tune several large
Unified Runtime System for Heterogeneous Multicore Architectures
developped by Inria Bordeaux) and
`TomP2P <https://tomp2p.net/dev/simgrid/>`_ (a high performance
-key-value pair storage library developed at University of Zurich).
+key-value pair storage library developed at the University of Zurich).
Some of these applications enjoy large user communities themselves.
.. LocalWords: SimGrid
SimGrid is a Free Software distributed under the LGPL-2.1 license. You are
welcome to use, study, share and improve it, provided that your version are as
-free as ours. SimGrid is developed since 20 years by a vivid community of users
+free as ours. SimGrid is developed since 20 years by a lively community of users
and researchers from several groups, initially in France and in the U.S.A. It
-benefited of many funding from various research bodies. We hope that you will
+is steadily funded by several research bodies. We hope that you will
come and join us!
SimGrid is a powerful tool, and this documentation will help you taking the best
`on FramaGit <https://framagit.org/simgrid/simgrid/issues>`_
-.. TODO
-..
-.. The webpage should be made light, graphical and nice looking.
-
.. toctree::
:hidden:
:maxdepth: 1
