option. For example, ``--cfg=plugin:help`` will give you the list
of plugins available in your installation of SimGrid.
+- **bmf/max-iterations:** :ref:`cfg=bmf/max-iterations`
+- **bmf/precision:** :ref:`cfg=bmf/precision`
+
- **contexts/factory:** :ref:`cfg=contexts/factory`
- **contexts/guard-size:** :ref:`cfg=contexts/guard-size`
- **contexts/nthreads:** :ref:`cfg=contexts/nthreads`
end, you have two host models: The default one allows aggregation of
an existing CPU model with an existing network model, but does not
allow parallel tasks because these beasts need some collaboration
- between the network and CPU model. That is why, ptask_07 is used by
- default when using SimDag.
+ between the network and CPU model.
- **default:** Default host model. Currently, CPU:Cas01 and
network:LV08 (with cross traffic enabled)
.. todo: make 'compound' the default host model.
+.. _options_model_solver:
+
+Solver
+......
+
+The different models rely on a linear inequalities solver to share
+the underlying resources. SimGrid allows you to change the solver, but
+be cautious, **don't change it unless you are 100% sure**.
+
+ - items ``cpu/solver``, ``network/solver``, ``disk/solver`` and ``host/solver``
+ allow you to change the solver for each model:
+
+ - **maxmin:** The default solver for all models except ptask. Provides a
+ max-min fairness allocation.
+ - **fairbottleneck:** The default solver for ptasks. Extends max-min to
+ allow heterogeneous resources.
+ - **bmf:** More realistic solver for heterogeneous resource sharing.
+ Implements BMF (Bottleneck max fairness) fairness. To be used with
+ parallel tasks instead of fair-bottleneck.
+
.. _options_model_optim:
Optimization Level
..................
-The network and CPU models that are based on lmm_solve (that
+The network and CPU models that are based on linear inequalities solver (that
is, all our analytical models) accept specific optimization
configurations.
the dependency induced by the backbone), but through a complicated
and slow pattern that follows the actual dependencies.
+.. _cfg=bmf/precision:
.. _cfg=maxmin/precision:
.. _cfg=surf/precision:
Numerical Precision
...................
-**Option** ``maxmin/precision`` **Default:** 0.00001 (in flops or bytes) |br|
-**Option** ``surf/precision`` **Default:** 0.00001 (in seconds)
+**Option** ``maxmin/precision`` **Default:** 1e-5 (in flops or bytes) |br|
+**Option** ``surf/precision`` **Default:** 1e-9 (in seconds) |br|
+**Option** ``bmf/precision`` **Default:** 1e-12 (no unit)
The analytical models handle a lot of floating point values. It is
possible to change the epsilon used to update and compare them through
on highly constrained scenarios, but the simulation speed suffers of this
setting on regular (less constrained) scenarios so it is off by default.
+.. _cfg=bmf/max-iterations:
+
+BMF settings
+............
+
+**Option** ``bmf/max-iterations`` **Default:** 1000
+
+It may happen in some settings that the BMF solver fails to converge to
+a solution, so there is a hard limit on the amount of iteration count to
+avoid infinite loops.
+
.. _options_model_network:
Configuring the Network Model
even if that paper does only describe models for myrinet and ethernet.
You can see in Fig 2 some results for Infiniband, for example. This model
may be outdated by now for modern infiniband, anyway, so a new
-validation would be good.
+validation would be good.
The three paramaters are defined as follows:
To determine the penalty for a communication, two values need to be calculated. First, the penalty caused by the conflict in transmission, noted ps.
-- if ∆s (i) = 1 then ps = 1.
+- if ∆s (i) = 1 then ps = 1.
- if ∆s (i) ≥ 2 and ∆e (i) ≥ 3 then ps = ∆s (i) × βs × γr
-- else, ps = ∆s (i) × βs
+- else, ps = ∆s (i) × βs
Then, the penalty caused by the conflict in reception (noted pe) should be computed as follows:
- if ∆e (i) = 1 then pe = 1
-- else, pe = Φ (e) × βe × Ω (s, e)
+- else, pe = Φ (e) × βe × Ω (s, e)
Finally, the penalty associated with the communication is:
p = max (ps ∈ s, pe)
Configuring loopback link
^^^^^^^^^^^^^^^^^^^^^^^^^
-Several network model provide an implicit loopback link to account for local
+Several network model provide an implicit loopback link to account for local
communication on a host. By default it has a 10GBps bandwidth and a null latency.
-This can be changed with ``network/loopback-lat`` and ``network/loopback-bw``
+This can be changed with ``network/loopback-lat`` and ``network/loopback-bw``
items.
.. _cfg=smpi/async-small-thresh:
8192 (in KiB), while our Chord simulation works with stacks as small
as 16 KiB, for example. You can ensure that some actors have a specific
size by simply changing the value of this configuration item before
-creating these actors. The :cpp:func:`simgrid::s4u::Engine::set_config`
+creating these actors. The :cpp:func:`simgrid::s4u::Engine::set_config`
functions are handy for that.
This *setting is ignored* when using the thread factory (because there
-----------------------
The :ref:`tracing subsystem <outcome_vizu>` can be configured in
-several different ways depending on the used interface (S4U, SMPI, SimDag)
+several different ways depending on the used interface (S4U, SMPI)
and the kind of traces that needs to be obtained. See the
:ref:`Tracing Configuration Options subsection
<tracing_tracing_options>` for a full description of each
you never used the tracing API.
-- Any SimGrid-based simulator (MSG, SimDag, SMPI, ...) and raw traces:
+- Any SimGrid-based simulator (MSG, SMPI, ...) and raw traces:
.. code-block:: none
tells it to trace host and link utilization (without any
categorization).
-- MSG or SimDag-based simulator and categorized traces (you need to
- declare categories and classify your tasks according to them)
+- MSG-based simulator and categorized traces (you need to
+ declare categories and classify your tasks according to them)
.. code-block:: none
assignment). In practice, change the calls for malloc() and free() into
SMPI_SHARED_MALLOC() and SMPI_SHARED_FREE().
-SMPI provides two algorithms for this feature. The first one, called
+SMPI provides two algorithms for this feature. The first one, called
``local``, allocates one block per call to SMPI_SHARED_MALLOC()
(each call site gets its own block) ,and this block is shared
among all MPI ranks. This is implemented with the shm_* functions
the execution and get a backtrace with a debugger.
It is also possible to set the breakpoint from inside the debugger, by
-writing in global variable simgrid::simix::breakpoint. For example,
+writing in global variable simgrid::kernel::cfg_breakpoint. For example,
with gdb:
.. code-block:: none
- set variable simgrid::simix::breakpoint = 3.1416
+ set variable simgrid::kernel::cfg_breakpoint = 3.1416
.. _cfg=debug/verbose-exit:
If you want to have spaces in your log format, you should protect it. Otherwise, SimGrid will consider that this is a space-separated list of several parameters. But you should
-also protect it from the shell that also splits command line arguments on spaces. At the end, you should use something such as ``--log="'root.fmt:%l: [%p/%c]: %m%n'"``.
-Another option is to use the ``%e`` directive for spaces, as in ``--log=root.fmt:%l:%e[%p/%c]:%e%m%n``.
+also protect it from the shell that also splits command line arguments on spaces. At the end, you should use something such as ``--log="'root.fmt:%l: [%p/%c]: %m%n'"``.
+Another option is to use the ``%e`` directive for spaces, as in ``--log=root.fmt:%l:%e[%p/%c]:%e%m%n``.
Category appender
.................
