Some constructs and features are still missing, but we can probably
add them on demand. If you already used MPI before, SMPI should sound
very familiar to you: Use smpicc instead of mpicc, and smpirun instead
-of mpirun. The main difference is that smpirun takes a :ref:`virtual
+of mpirun. The main difference is that smpirun takes a :ref:`simulated
platform <platform>` as an extra parameter.
For **further scalability**, you may modify your code to speed up your
# -- Project information -----------------------------------------------------
project = u'SimGrid'
-copyright = u'2018, The SimGrid Team'
+copyright = u'2002-2018, The SimGrid Team'
author = u'The SimGrid Team'
# The short X.Y version
borderopacity="1.0"
inkscape:pageopacity="0.0"
inkscape:pageshadow="2"
- inkscape:zoom="0.49497475"
- inkscape:cx="-267.7826"
- inkscape:cy="12.793361"
+ inkscape:zoom="1.979899"
+ inkscape:cx="196.07267"
+ inkscape:cy="183.99119"
inkscape:document-units="mm"
inkscape:current-layer="layer1"
showgrid="true"
sodipodi:nodetypes="cccccccc" />
<a
xlink:href="platform.html"
- transform="translate(-0.37797619,-16.630952)"
- id="a6154">
+ id="a6154"
+ transform="translate(-0.37797619,-16.630952)">
<text
id="text1024"
y="87.523804"
y="87.523804"
x="90.802567"
id="tspan1022"
- sodipodi:role="line">Virtual </tspan><tspan
+ sodipodi:role="line">Simulated </tspan><tspan
style="font-size:7.76111126px;text-align:center;text-anchor:middle;stroke-width:0.26458332px"
y="94.795403"
x="89.567154"
</a>
<a
xlink:href="scenario.html#configuring-simgrid"
- transform="translate(-0.52916667)"
- id="a6149">
+ id="a6149"
+ transform="translate(-0.52916667)">
<text
xml:space="preserve"
style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:5.29166698px;line-height:6.61458349px;font-family:'Amiri Quran Colored';-inkscape-font-specification:'Amiri Quran Colored';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
Describing your Application <application.rst>
The S4U Interface <app_s4u.rst>
The SMPI Interface <app_smpi.rst>
- Describing the
Virtual Platform <platform.rst>
+ Describing the
Simulated Platform <platform.rst>
Describing the Experimental Scenario <scenario.rst>
Configuring SimGrid <scenar_config.rst>
The SimGrid Models <models.rst>
:caption: API Reference:
API <api/library_root.rst>
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`search`
parallel application using for example the MPI interface
:ref:`(more info) <application>`.
- - The **Virtual Platform**. This is a description of a given
+ - 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
- under development. SimGrid makes it easy to augment the Virtual
+ 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
- The application's **Deployment Description**. In SimGrid
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 virtual platform. You need to specify
+ should be deployed on the simulated platform. You need to specify
which process is mapped on which machine, along with their parameters
:ref:`(more info) <scenario>`.
- - The **Platform Models**. They describe how the virtual platform
+ - The **Platform Models**. They describe how the simulated platform
reacts to the actions of the application. For example, they compute
- the time taken by a given communication on the virtual platform.
+ the time taken by a given communication on the simulated platform.
These models are already included in SimGrid, and you only need to
pick one and maybe tweak its configuration to get your results
:ref:`(more info) <models>`.
they contribute to compares to the existing solutions from the
literature.
- - **Design the best Virtual Platform for a given Application.**
+ - **Design the best [Simulated] Platform for a given Application.**
Tweaking the platform file is much easier than building a new real
platform for testing purpose. SimGrid also allows for the co-design
of the platform and the application by modifying both of them.
Depending on the intended study, SimGrid can be run in several execution modes.
**Simulation Mode**. This is the most common execution mode, where you want
-to study how your application behaves on the virtual platform under
+to study how your application behaves on the simulated platform under
the experimental scenario.
In this mode, SimGrid can provide information about the time taken by
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
and replaced by a synthetic block using the cached information. The
-virtual platform will take this block into account without requesting
+simulated platform will take this block into account without requesting
the real hosting machine to benchmark it.
SimGrid Limits
<br/>
<br/>
-Describing your Virtual Platform
-================================
+Describing your Simulated Platform
+==================================
simulation: SimGrid is a library, not a program. So you need to define
your own ``main()`` function as follows. This function is in charge of
creating a SimGrid simulation engine (on line 3), register the actor
-functions to the engine (on lines 7 and 8), load the virtual platform
+functions to the engine (on lines 7 and 8), load the simulated platform
from its description file (on line 11), map actors onto that platform
(on line 12) and run the simulation until its completion on line 15.
Platform File
.............
-Platform files define the virtual platform on which the provided
+Platform files define the simulated platform on which the provided
application will take place. In contains one or several **Network
Zone** |api_s4u_NetZone|_ that contain both |Host|_ and |Link|_
Resources, as well as routing information.
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
-------------
``mpiff``, or with ``smpicxx`` instead of ``mpicxx``. Then, the only
difference between the classical ``mpirun`` and the new ``smpirun`` is
that it requires a new parameter ``-platform`` with a file describing
-the virtual platform on which your application shall run.
+the simulated platform on which your application shall run.
Internally, all ranks of your application are executed as threads of a
single unix process. That's not a problem if your application has
------------------------
As a SMPI user, you are supposed to provide a description of your
-virtual platform, that is mostly a set of simulated hosts and network
+simulated platform, that is mostly a set of simulated hosts and network
links with some performance characteristics. SimGrid provides a plenty
of :ref:`documentation <platform>` and examples (in the
`examples/platforms <https://framagit.org/simgrid/simgrid/tree/master/examples/platforms>`_
/*! take a vector s4u::CommPtr and return the rank of the first finished one (or -1 if none is done). */
static int test_any(std::vector<CommPtr> * comms);
- Activity* start() override;
- Activity* wait() override;
- Activity* wait_for(double timeout) override;
+ Comm* start() override;
+ Comm* wait() override;
+ Comm* wait_for(double timeout) override;
bool test() override;
/** Start the comm, and ignore its result. It can be completely forgotten after that. */
- Activity* detach();
+ Comm* detach();
/** Start the comm, and ignore its result. It can be completely forgotten after that. */
- Activity* detach(void (*clean_function)(void*))
+ Comm* detach(void (*clean_function)(void*))
{
clean_fun_ = clean_function;
return detach();
}
/** Sets the maximal communication rate (in byte/sec). Must be done before start */
- Activity* set_rate(double rate);
+ Comm* set_rate(double rate);
/** Specify the data to send.
*
* you can send a short buffer in your simulator, that represents a very large message
* in the simulated world, or the opposite.
*/
- Activity* set_src_data(void* buff);
+ Comm* set_src_data(void* buff);
/** Specify the size of the data to send. Not to be mixed with @ref Activity::set_remaining()
*
* That's the size of the data to actually copy in the simulator (ie, the data passed with Activity::set_src_data()).
* you can send a short buffer in your simulator, that represents a very large message
* in the simulated world, or the opposite.
*/
- Activity* set_src_data_size(size_t size);
+ Comm* set_src_data_size(size_t size);
/** Specify the data to send and its size. Don't mix the size with @ref Activity::set_remaining()
*
* This is way will get actually copied over to the receiver.
* you can send a short buffer in your simulator, that represents a very large message
* in the simulated world, or the opposite.
*/
- Activity* set_src_data(void* buff, size_t size);
+ Comm* set_src_data(void* buff, size_t size);
/** Specify where to receive the data.
*
* That's a buffer where the sent data will be copied */
- Activity* set_dst_data(void** buff);
+ Comm* set_dst_data(void** buff);
/** Specify the buffer in which the data should be received
*
* That's a buffer where the sent data will be copied */
- Activity* set_dst_data(void** buff, size_t size);
+ Comm* set_dst_data(void** buff, size_t size);
/** Retrieve the size of the received data. Not to be mixed with @ref Activity::set_remaining() */
size_t get_dst_data_size();
- Activity* cancel() override;
+ Comm* cancel() override;
/** Retrieve the mailbox on which this comm acts */
MailboxPtr get_mailbox();
static simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_start;
static simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_completion;
- Activity* start() override;
- Activity* wait() override;
- Activity* wait_for(double timeout) override;
- Activity* cancel() override;
+ Exec* start() override;
+ Exec* wait() override;
+ Exec* wait_for(double timeout) override;
+ Exec* cancel() override;
bool test() override;
ExecPtr set_priority(double priority);
~Io() = default;
- Activity* start() override;
- Activity* wait() override;
- Activity* wait_for(double timeout) override;
- Activity* cancel() override;
+ Io* start() override;
+ Io* wait() override;
+ Io* wait_for(double timeout) override;
+ Io* cancel() override;
bool test() override;
double get_remaining() override;
comm->wait();
}
-Activity* Comm::set_rate(double rate)
+Comm* Comm::set_rate(double rate)
{
xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
__FUNCTION__);
return this;
}
-Activity* Comm::set_src_data(void* buff)
+Comm* Comm::set_src_data(void* buff)
{
xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
__FUNCTION__);
src_buff_ = buff;
return this;
}
-Activity* Comm::set_src_data_size(size_t size)
+Comm* Comm::set_src_data_size(size_t size)
{
xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
__FUNCTION__);
src_buff_size_ = size;
return this;
}
-Activity* Comm::set_src_data(void* buff, size_t size)
+Comm* Comm::set_src_data(void* buff, size_t size)
{
xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
__FUNCTION__);
src_buff_size_ = size;
return this;
}
-Activity* Comm::set_dst_data(void** buff)
+Comm* Comm::set_dst_data(void** buff)
{
xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
__FUNCTION__);
xbt_assert(state_ == State::FINISHED, "You cannot use %s before your communication terminated", __FUNCTION__);
return dst_buff_size_;
}
-Activity* Comm::set_dst_data(void** buff, size_t size)
+Comm* Comm::set_dst_data(void** buff, size_t size)
{
xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
__FUNCTION__);
return this;
}
-Activity* Comm::start()
+Comm* Comm::start()
{
xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
__FUNCTION__);
}
/** @brief Block the calling actor until the communication is finished */
-Activity* Comm::wait()
+Comm* Comm::wait()
{
return this->wait_for(-1);
}
*
* @param timeout the amount of seconds to wait for the comm termination.
* Negative values denote infinite wait times. 0 as a timeout returns immediately. */
-Activity* Comm::wait_for(double timeout)
+Comm* Comm::wait_for(double timeout)
{
switch (state_) {
case State::FINISHED:
return res;
}
-Activity* Comm::detach()
+Comm* Comm::detach()
{
xbt_assert(state_ == State::INITED, "You cannot use %s() once your communication started (not implemented)",
__FUNCTION__);
return start();
}
-Activity* Comm::cancel()
+Comm* Comm::cancel()
{
simgrid::simix::simcall([this] { dynamic_cast<kernel::activity::CommImpl*>(pimpl_.get())->cancel(); });
state_ = State::CANCELED;
simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Exec::on_start;
simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Exec::on_completion;
-Activity* Exec::start()
+Exec* Exec::start()
{
pimpl_ = simcall_execution_start(name_, tracing_category_, flops_amount_, 1. / priority_, bound_, host_);
state_ = State::STARTED;
return this;
}
-Activity* Exec::cancel()
+Exec* Exec::cancel()
{
simgrid::simix::simcall([this] { dynamic_cast<kernel::activity::ExecImpl*>(pimpl_.get())->cancel(); });
state_ = State::CANCELED;
return this;
}
-Activity* Exec::wait()
+Exec* Exec::wait()
{
if (state_ == State::INITED)
start();
return this;
}
-Activity* Exec::wait_for(double timeout)
+Exec* Exec::wait_for(double timeout)
{
THROW_UNIMPLEMENTED;
return this;
namespace simgrid {
namespace s4u {
-Activity* Io::start()
+Io* Io::start()
{
Activity::set_remaining(size_);
pimpl_ = simix::simcall([this] {
return this;
}
-Activity* Io::cancel()
+Io* Io::cancel()
{
simgrid::simix::simcall([this] { dynamic_cast<kernel::activity::IoImpl*>(pimpl_.get())->cancel(); });
state_ = State::CANCELED;
return this;
}
-Activity* Io::wait()
+Io* Io::wait()
{
simcall_io_wait(pimpl_);
state_ = State::FINISHED;
return this;
}
-Activity* Io::wait_for(double timeout)
+Io* Io::wait_for(double timeout)
{
THROW_UNIMPLEMENTED;
return this;
