4 Typical Study based on SimGrid
5 ------------------------------
9 <object data="graphical-toc.svg" width="100%" type="image/svg+xml"></object>
12 Any SimGrid study entails the following components:
14 - The studied **Application**. This can be either a distributed
15 algorithm described in our simple APIs, or a full featured real
16 parallel application using for example the MPI interface
17 :ref:`(more info) <application>`.
19 - The **Simulated Platform**. This is a description of a given
20 distributed system (machines, links, disks, clusters, etc). Most of
21 the platform files are written in XML althrough a Lua interface is
22 under development. SimGrid makes it easy to augment the Simulated
23 Platform with a Dynamic Scenario where for example the links are
24 slowed down (because of external usage) or the machines fail. You
25 have even support to specify the applicative workload that you want
26 to feed to your application
27 :ref:`(more info) <platform>`.
29 - The application's **Deployment Description**. In SimGrid
30 terminology, the application is an inert set of source files and
31 binaries. To make it run, you have to describe how your application
32 should be deployed on the simulated platform. You need to specify
33 which process is mapped on which machine, along with their parameters
34 :ref:`(more info) <scenario>`.
36 - The **Platform Models**. They describe how the simulated platform
37 reacts to the actions of the application. For example, they compute
38 the time taken by a given communication on the simulated platform.
39 These models are already included in SimGrid, and you only need to
40 pick one and maybe tweak its configuration to get your results
41 :ref:`(more info) <models>`.
43 These components are put together to run a **simulation**, that is an
44 experiment or a probe. The result of one or many simulation provides
45 an **outcome** (logs, visualization, or statistical analysis) that help
46 answering the **question** targeted by this study.
48 Here are some questions on which SimGrid is particularly relevant:
50 - **Compare an Application to another**. This is the classical use
51 case for scientists, who use SimGrid to test how the solution that
52 they contribute to compares to the existing solutions from the
55 - **Design the best [Simulated] Platform for a given Application.**
56 Tweaking the platform file is much easier than building a new real
57 platform for testing purpose. SimGrid also allows for the co-design
58 of the platform and the application by modifying both of them.
60 - **Debug Real Applications**. With real systems, is sometimes
61 difficult to reproduce the exact run leading to the bug that you
62 are tracking. With SimGrid, you are *clairvoyant* about your
63 *reproducible experiments*: you can explore every part of the
64 system, and your probe will not change the simulated state. It also
65 makes it easy to mock some parts of the real system that are not
68 Depending on the context, you may see some parts of this process as
69 less important, but you should pay close attention if you want to be
70 confident in the results coming out of your simulations. In
71 particular, you should not blindly trust your results but always
72 strive to double-check them. Likewise, you should question the realism
73 of your input configuration, and we even encourage you to doubt (and
74 check) the provided performance models.
76 To ease such questioning, you really should logically separate these
77 parts in your experimental setup. It is seen as a very bad practice to
78 merge the application, the platform, and the deployment all together.
79 SimGrid is versatile and your mileage may vary, but you should start
80 with your Application specified as a C++ or Java program, using one of
81 the provided XML platform file, and with your deployment in a separate
84 SimGrid Execution Modes
85 -----------------------
87 Depending on the intended study, SimGrid can be run in several execution modes.
89 **Simulation Mode**. This is the most common execution mode, where you want
90 to study how your application behaves on the simulated platform under
91 the experimental scenario.
93 In this mode, SimGrid can provide information about the time taken by
94 your application, the amount of energy dissipated by the platform to
95 run your application, and the detailed usage of each resource.
97 **Model-Checking Mode**. This can be seen as a sort of exhaustive
98 testing mode, where every possible outcome of your application is
99 explored. In some sense, this mode tests your application for all
100 possible platforms that you could imagine (and more).
102 You just provide the application and its deployment (amount of
103 processes and parameters), and the model-checker will literally
104 explore all possible outcomes by testing all possible message
105 interleavings: if at some point a given process can either receive the
106 message A first or the message B depending on the platform
107 characteristics, the model-checker will explore the scenario where A
108 arrives first, and then rewind to the same point to explore the
109 scenario where B arrives first.
111 This is a very powerful mode, where you can evaluate the correction of
112 your application. It can verify either **safety properties** (asserts)
113 or **liveless properties** stating for example that if a given event
114 occurs, then another given event will occur in a finite amount of
115 steps. This mode is not only usable with the abstract algorithms
116 developed on top of the SimGrid APIs, but also with real MPI
117 applications (to some extent).
119 The main limit of Model Checking lays in the huge amount of scenarios
120 to explore. SimGrid tries to explore only non-redundant scenarios
121 thanks to classical reduction techniques (such as DPOR and stateful
122 exploration) but the exploration may well never finish if you don't
123 carefully adapt your application to this mode.
125 A classical trap is that the Model Checker can only verify whether
126 your application fits the provided properties, which is useless if you
127 have a bug in your property. Remember also that one way for your
128 application to never violate a given assert is to not start at all
129 because of a stupid bug.
131 Another limit of this mode is that it does not use the performance
132 models of the simulation mode. Time becomes discrete: You can say for
133 example that the application took 42 steps to run, but there is no way
134 to know how much time it took or the amount of watts that were dissipated.
136 Finally, the model checker only explores the interleavings of
137 computations and communications. Other factors such as thread
138 execution interleaving are not considered by the SimGrid model
141 The model checker may well miss existing issues, as it computes the
142 possible outcomes *from a given initial situation*. There is no way to
143 prove the correction of your application in all generality with this
146 **Benchmark Recording Mode**. During debug sessions, continuous
147 integration testing, and other similar use cases, you are often only
148 interested in the control flow. If your application apply filters to
149 huge images split in small blocks, the filtered image is probably not
150 what you are interested in. You are probably looking for a way to run
151 each computation kernel only once, save on disk the time it takes and
152 some other metadata. This code block can then be skipped in simulation
153 and replaced by a synthetic block using the cached information. The
154 simulated platform will take this block into account without requesting
155 the real hosting machine to benchmark it.
160 This framework is by no means the perfect holly grail able to solve
161 every problem on earth.
163 **SimGrid scope is limited to distributed systems.** Real-time
164 multi-threaded systems are out of scope. You could probably tweak
165 SimGrid for such studies (or the framework could possibly be extended
166 in this direction), but another framework specifically targeting such a
167 use case would probably be more suited.
169 **There is currently no support for wireless networks**.
170 The framework could certainly be improved in this direction, but this
171 still has to be done.
173 **There is no perfect model, only models adapted to your study.**
174 The SimGrid models target fast and large studies yet requesting
175 realistic results. In particular, our models abstract away parameters
176 and phenomena that are often irrelevant to the realism in our
179 SimGrid is simply not intended to any study that would mandate the
180 abstracted phenomenon. Here are some **studies that you should not do
183 - Studying the effect of L3 vs. L2 cache effects on your application
184 - Comparing kernel schedulers and policies
185 - Comparing variants of TCP
186 - Exploring pathological cases where TCP breaks down, resulting in
188 - Studying security aspects of your application, in presence of
191 SimGrid Success Stories
192 -----------------------
194 SimGrid was cited in over 1,500 scientific papers (according to Google
196 `over 200 publications <https://simgrid.org/Usages.html>`_
197 (written by about 300 individuals) use SimGrid as a scientific
198 instrument to conduct their experimental evaluation. These
199 numbers do not include the articles contributing to SimGrid.
200 This instrument was used in many research communities, such as
201 `High-Performance Computing <https://hal.inria.fr/inria-00580599/>`_,
202 `Cloud Computing <http://dx.doi.org/10.1109/CLOUD.2015.125>`_,
203 `Workflow Scheduling <http://dl.acm.org/citation.cfm?id=2310096.2310195>`_,
204 `Big Data <https://hal.inria.fr/hal-01199200/>`_ and
205 `MapReduce <http://dx.doi.org/10.1109/WSCAD-SSC.2012.18>`_,
206 `Data Grid <http://ieeexplore.ieee.org/document/7515695/>`_,
207 `Volunteer Computing <http://www.sciencedirect.com/science/article/pii/S1569190X17301028>`_,
208 `Peer-to-Peer Computing <https://hal.archives-ouvertes.fr/hal-01152469/>`_,
209 `Network Architecture <http://dx.doi.org/10.1109/TPDS.2016.2613043>`_,
210 `Fog Computing <http://ieeexplore.ieee.org/document/7946412/>`_, or
211 `Batch Scheduling <https://hal.archives-ouvertes.fr/hal-01333471>`_
212 `(more info) <https://simgrid.org/Usages.html>`_.
214 If your platform description is accurate enough (see
215 `here <http://hal.inria.fr/hal-00907887>`_ or
216 `there <https://hal.inria.fr/hal-01523608>`_),
217 SimGrid can provide high-quality performance predictions. For example,
218 we determined the speedup achieved by the Tibidabo ARM-based
219 cluster before its construction
220 (`paper <http://hal.inria.fr/hal-00919507>`_). In this case,
221 some differences between the prediction and the real timings were due to
222 misconfiguration or other problems with the real platform. To some extent,
223 SimGrid could even be used to debug the real platform :)
225 SimGrid is also used to debug, improve, and tune several large
227 `BigDFT <http://bigdft.org>`_ (a massively parallel code
228 computing the electronic structure of chemical elements developped by
229 the CEA), `StarPU <http://starpu.gforge.inria.fr/>`_ (a
230 Unified Runtime System for Heterogeneous Multicore Architectures
231 developped by Inria Bordeaux) and
232 `TomP2P <https://tomp2p.net/dev/simgrid/>`_ (a high performance
233 key-value pair storage library developed at University of Zurich).
234 Some of these applications enjoy large user communities themselves.
236 .. LocalWords: SimGrid
