docs/source/Introduction.rst

   1 .. _intro_concepts:
   2
   3 Introduction
   4 ============
   5
   6 .. raw:: html
   7
   8    <object data="graphical-toc.svg" type="image/svg+xml"></object>
   9    <br/>
  10    <br/>
  11
  12 What is SimGrid
  13 ---------------
  14
  15 SimGrid is a framework for developing simulators of distributed application executions on distributed platforms. It can
  16 be used to prototype, evaluate and compare relevant platform configurations, system designs, and algorithmic approaches.
  17
  18 What SimGrid allows you to do
  19 ----------------------------
  20
  21 Here are some objectives for which SimGrid is particularly relevant and has been used extensively:
  22
  23  - **Compare designs**. This is a classical use case for researchers/developers, who use SimGrid to assess how their contributed solution (a platform, system, application, and/or algorithm design) compares to existing solutions from the literature.
  24
  25  - **Design the best [Simulated] Platform for a given Application.** Modifying a platform file use to drive simulations is much easier than building
  26    real-world platforms for testing purposes. SimGrid also allows for the co-design of the platform and the application, as both can be modified with little work.
  27
  28  - **Debug Real Applications**. With real systems it is often difficult to reproduce the exact run that would lead to a bug that is being tracked.
  29    With SimGrid, you are *clairvoyant* about your *reproducible experiments*: you can explore every part of the
  30    system, and your exploration will not change the simulated state. It also makes it easy to mock or abstract away parts of the real system that
  31    are not under study.
  32
  33  - **Formally assess an algorithm**. Inspired by model checking, SimGrid provides an execution mode that does not
  34    quantify an application's performance behavior, but that instead explores all causally possible outcomes of the application so as to evaluate application correctness. This exhaustive
  35    search is ideal for finding bugs that are difficult to trigger experimentally. But because it is exhaustive, there is a limit to the scale of the applications for which it can be used.
  36
  37  Anatomy of a project that uses SimGrid
  38 ---------------------------------------
  39
  40 Any project that uses SimGrid as its simulation framework comprises the following components:
  41
  42  - An **application**. An application consists of one or more process that can either implement distributed algorithms described using a simple API (either in C++, Python or
  43    C) or be part of a full-featured real  parallel application implemented with, for example, the MPI standard :ref:`(more info) <application>`.
  44
  45  - A **simulated platform**. This is a description (in either XML or C++) of a distributed system's hardware (machines, links,
  46    disks, clusters, etc). SimGrid makes it straightforward to augment the simulated platform with dynamic behaviors where, for example, the
  47    links are slowed down (because of external usage) or the machines fail :ref:`(more info) <platform>`.
  48
  49  - An application's **deployment description**. To simulate the execution
  50  of the application on the platform, they way in which the application is
  51  deployed on the platform must be described.  This is done by specifying
  52  which process is mapped onto which machine :ref:`(more
  53    info) <scenario>`.
  54
  55  - **Platform models**. SimGrid implements models that describe how the simulated platform reacts to the simulated activities performed my
  56   application processes.  SimGrid provides a range of documented models,
  57   which the user can select and configure for their particular use case.  A
  58   big selling point of SimGrid, which sets it apart from its competitors,
  59   is that it can accurately model the network contention that results from
  60   concurrent communications. :ref:`(more info) <models>`.
  61
  62
  63 The above components are put together to run a **simulation experiment**
  64 that produces **outcomes** (logs, visualization, statistics) that help
  65 answer the user's research and development **question**. The outcomes
  66 typically include a timeline of the application execution and information
  67 about its energy consumption.
  68
  69
  70 We work hard to make SimGrid easy to use, but you should not blindly trust your results and always strive to validate
  71 the simulation outcomes. Assessing the realism of these outcomes will lead you to better :ref:`calibrate the models <models_calibration>`,
  72 which is the best way to achieved high simulation accuracy. Please refer to the section :ref:`howto_science`.
  73
  74 Using SimGrid in practice
  75 -------------------------
  76
  77 SimGrid is versatile and can be used in many ways, but the most typical setup is to specify your algorithm as a C++ or Python
  78 program using our API, along with one of the provided XML platform files as shown in the **first tutorial** on
  79 :ref:`usecase_simalgo`. If your application is already written in MPI, then you are in luck because SimGrid comes with MPI support,
  80 as explained in our **second tutorial** on :ref:`usecase_smpi`. The **third tutorial** is on
  81 :ref:`usecase_modelchecking`. Docker images are provided to run these tutorials without installing any software, other than Docker, on your machine.
  82
  83 SimGrid comes with :ref:`many examples <s4u_examples>`, so that you can quick-start your simulator by
  84 assembling and modifying some of the provided examples (see :ref:`this section <setup_your_own>` on how to get your own project
  85 to compile with SimGrid). An extensive documentation is available from the left menu bar. If you want to get an idea of how
  86 SimGrid works you can read about its :ref:`design goals <design>`.
  87
  88 SimGrid Success Stories
  89 -----------------------
  90
  91 SimGrid was cited in over 3,000 scientific papers (according to Google
  92 Scholar). Among them,
  93 `over 500 publications <https://simgrid.org/usages.html>`_
  94 (written by hundreds of individuals) use SimGrid as a scientific
  95 instrument to conduct experimental evaluations. These
  96 numbers do not include those articles that directly contribute to SimGrid itself.
  97 SimGrid was used in many research communities, such as
  98 `High-Performance Computing <https://hal.inria.fr/inria-00580599/>`_,
  99 `Cloud Computing <http://dx.doi.org/10.1109/CLOUD.2015.125>`_,
 100 `Workflow Scheduling <http://dl.acm.org/citation.cfm?id=2310096.2310195>`_,
 101 `Big Data <https://hal.inria.fr/hal-01199200/>`_ and
 102 `MapReduce <http://dx.doi.org/10.1109/WSCAD-SSC.2012.18>`_,
 103 `Data Grid <http://ieeexplore.ieee.org/document/7515695/>`_,
 104 `Volunteer Computing <http://www.sciencedirect.com/science/article/pii/S1569190X17301028>`_,
 105 `Peer-to-Peer Computing <https://hal.archives-ouvertes.fr/hal-01152469/>`_,
 106 `Network Architecture <http://dx.doi.org/10.1109/TPDS.2016.2613043>`_,
 107 `Fog Computing <http://ieeexplore.ieee.org/document/7946412/>`_, or
 108 `Batch Scheduling <https://hal.archives-ouvertes.fr/hal-01333471>`_.
 109
 110 If your platform description is accurate enough (see
 111 `here <http://hal.inria.fr/hal-00907887>`_ or
 112 `there <https://hal.inria.fr/hal-01523608>`_),
 113 SimGrid can provide high-quality performance predictions. For example,
 114 we determined the speedup achieved by the Tibidabo ARM-based
 115 cluster before its construction
 116 (`paper <http://hal.inria.fr/hal-00919507>`_). Some
 117 differences between the simulated and the real timings were observed, and
 118 turned out to be due to
 119 misconfigurations in the real platform!
 120 SimGrid can thus even be used to debug a real platform :)
 121
 122 SimGrid is also used to debug, improve, and tune several large
 123 applications.
 124 `BigDFT <http://bigdft.org>`_ (a massively parallel code
 125 for computing the electronic structure of chemical elements developed by
 126 the CEA), `StarPU <http://starpu.gforge.inria.fr/>`_ (a
 127 Unified Runtime System for Heterogeneous Multicore Architectures
 128 developed by Inria Bordeaux), and
 129 `TomP2P <https://tomp2p.net/dev/simgrid/>`_ (a high-performance
 130 key-value pair storage library developed at the University of Zurich).
 131 Some of these applications enjoy large user communities themselves.
 132
 133 SimGrid Limits
 134 --------------
 135
 136 SimGrid is by no means the holy grail that is able to solve every conceivable simulation problem.
 137
 138 **SimGrid's scope is limited to distributed systems.** Real-time
 139 multi-threaded systems are out of this scope. You could probably use and/or
 140 extend SimGrid for this purpose, but another framework that specifically
 141 targets this use case would probably be more suitable.
 142
 143 **There is currently no support for 5G or LoRa networks**.
 144 SimGrid could certainly be extended with models for these networks, but this
 145 yet to be done.
 146
 147 **There is no perfect model, only models adapted to your purposes.** SimGrid's
 148 models were designed to make it possible to run fast and accurate
 149 simulations of large systems. As a result, the models abstract away many
 150 parameters and phenomena that are often irrelevant for most use cases in the
 151 field. This means that SimGrid cannot be used to study any phenomenon that our
 152 model do not capture.  Here are some **phenomena that you currently cannot study with
 153 SimGrid**:
 154
 155  - Studying the effect of L3 vs. L2 cache effects on your application;
 156  - Comparing kernel schedulers and policies;
 157  - Comparing variants of TCP;
 158  - Exploring pathological cases where TCP breaks down, resulting in
 159    abnormal executions;
 160  - Studying security aspects of your application, in the presence of
 161    malicious agents.
 162
 163
 164 ..  LocalWords:  SimGrid