Add WakeupTreeIterator and WakeupTree skeletons

Add more docmentation for get_first_sdpor_initial()

A very important function at the center of SDPOR
was missing significant context that would help
a reader understand what exactly was going on
with the function. What makes the situation tricky
is the fact that the pseudocode's implementation
is blended into several lines and computed "on the
fly" rather than fully.

Add more documentation to ClockVector/Execution

Add unit tests for ClockVector

Fix MANIFEST.in

We should note that the Execution that's a part of
both ODPOR and SDPOR is now contained in DFSExplorer
even in stateless execution. This will likely eventually
be true also for ODPOR; hence, the ODPOR sources
have been added to the SRC_MC_STATELESS portion as
needed

Integrate SDPOR into `model-check/reduction` flag

SDPOR and ODPOR can be used as part of the
DFSExplorer (ODPOR should integrate with some
minor details in the DFS implementation, but that's
for a later PR). This commit replaces the simple
`with_dpor` boolean flag used to control the
reduction with the more precise `ReductionMode`
that is newly extracted from within `DFSExplorer`
and is instead made "public"

Add more documentation to essential SDPOR methods

Modify tesh suite expectations with changes to dependencies

Fix ObjectAccess dependency check

The ObjectAccess transition should defer
dependency computation to the ActorJoin action.
Previously, it only decided dependency by
simply checking if the `other` transition
were simply another object access on the
same object

Fix subtlety with SDPOR/ODPOR initials

Computing initials for SDPOR/ODPOR requires
extending a search with respect to
a prefix of an execution. Previously, events
added to the extension were referred to by
their location within the larger execution
from which the prefix was taken. The problem
is that the new events need to be referred
to by their position relative to the
*extension* of the prefix; otherwise,
asking about "happens-before" in the extension
while using their handles in the full execution
will give incorrect results

Fix two off-by-one errors with clock vectors

Two errors were identified with managing clock
vectors in the Execution class. The index
assigned to the new transition was previously
`size() + 1` when it should have read `size()`.
Furthermore, the loop for checking "happens-between"
events excluded event 0. Both issues are now resolved
and a test with a race at the beginning was added
as verification

Mark `ActorJoin` dependent with `target_`

The `ActorJoin` transition was previously
labeled as independent with all other
transitions, including those of the actor
upon which the join acted. However, this
assumption was faulty: the join action is
instead dependent with ANY transition executed
by the actor joined upon, as the action
BECOMES enabled only as soon as the last action
run by the actor is executed.

Prevent adding outgoing transition for top-most state

The outgoing transition for the top-most
state of the state stack in the DFSExplorer refers
to that which was taken as part of the last
trace explored by the algorithm. Thus, only the
sequence of transitions leading up to, but
not including, the last state must be included
when reconstructing the Exploration for SDPOR.

Add workaround for subtlety with state regeneration

Regeneration of the Execution inside DFSExplorer
should be as simple as choosing the prefix relative
to the appropriate backtracking point. However,
it did not appear to function so simple. After
a good amount of debugging, it appears that
the stack contents can change unexpectedly so
(e.g. a transition "in the middle" of the stack
seemingly switches arbitrarily). Until we can
pinpoint the true cause here, we simple resort
to rebuilding the execution based off the new
stack each time we decide to backtrack. The
downside is that all clock vectors have to be
recomputed after each backtrack. For now,
this is something that's OK to live with,
especially considering that this certainly
won't be a bottle neck in performance

Add first tests for "happens-before"

The happens-before relation is used
extensively by SDPOR and ODPOR during
their computations for determining what
executions should be searched next. This
commit introduces the first round of tests
for the happens-before relation on
artificially constructed executions

Move SDPOR core computation into a method

The core component of SDPOR involves selecting
an "initial" for a hypothetical computation
extending from a prefix of the current execution
that results in the reversal of the reversible
race SDPOR detected. This comomit moves that
computation as much as possible into the
`Execution` class itself to make the SDPOR
implementation easier to read

Add tentatively-working SDPOR implementation

This commit introduces SDPOR into SimGrid
(well, mostly). The current implementation
will be improved upon by cleaning up some
of the code that was added to improve
its testability

Add initial outline of SDPOR implementation

The SDPOR algorithm is nearing an implementation
into SimGrid (sans a few technical details and
code clean ups that will be nice to add). The
algorithm largely builds off the existing
infrastructure of DFSExplorer fortunately.

Add Execution concept without ExecutionViews

The Execution is the key concept in ODPOR
and SDPOR for generating new traces. Executions
for the basis off of which new search paths are
created

Remove sdpor folder in favor of odpor only

Add `Execution` to represent series of transitions

The Execution class represents a series of transitions
taken by a process. An execution importantly also encodes
the happens-before relation among the series of steps
represented. The eventual implementation will leverage
clock vectors to compute the relation between events.
A more refined happens-before relation is left for
as a future (complicated) exercise...

Add class for eventual "happens-before" computations

Computing the "happens-before" relation over
a sequence of executions is an important step
in determining whether or not DPOR (and SDPOR
alike) needs to add a backtracking point.
This commit introduces the "ClockVector"
class which acts effectively as a light
wrapping around an `unordered_map` mapping
actor ids to integer values.

The essential component of the ClockVector
class is that its contents are "implicit"
in the sense that actors for which no
value is explicitly contained in the map
are assigned to the value `0` by default.
This allows clock vectors to be flexible
enough to support the creation of new
actors and the enabling/disabling of old
actors as they come and go.

add two more utility functions to the Operation plugin

Fix make distcheck

MC: Kill the now useless code State::get_recipe

Merge branch 'master' of framagit.org:simgrid/simgrid

DFS MC: Restore from system states even if we have to run some transitions out of it

This makes the model-check/checkpoint a bit more efficient by
increasing the amount of cases where we can reuse taken checkpoints.

It is still awfully slow because checkpoints are. The next step is to
implement model-check/checkpoint with forks.

Merge branch 'dag-lab' into 'master'

Add dag scheduling lab to docs

See merge request simgrid/simgrid!150

Merge branch 'changelog-operation-plugin' into 'master'

Add plugins operation and battery to changelog

See merge request simgrid/simgrid!149

Use forwarding references with std::forward (sonar).

(hope I got it right this time)

Use a std::vector as an underlying container for backtrack_points, so that maximal_subsets_iterator can have a noexcept move constructor by default.

Use a static variable for empty_set, and allow default noexcept move constructor.

add dag scheduling lab

Plug memory leak.

Use pointer-to-const for parameter (sonar).

Fix sonar bug: attribute access on a value that can be 'None'.

Misc Sonar issues.

* declare functions "const"
* use pointer-to-const or reference-to-const
* use structured bindings
* extract assignment from expression
* mark constructors "explicit"
* pass large object parameters by reference-to-const
* use default implementation constructor
* explicitly capture required variables in lambdas

mess up with operations
+ chainable setters
+ getters
+ boost instrusive pointers

Rename Link::get_usage() to Link::get_load() for consistency with Host::

add plugins operation and battery

further simplify this example

One use less of get_recipe() that will soon die

Factorize more code between DFSExplo and LivenessExplo, and UDPOR

Kill useless empty function.

Missing "override".

Simplify expression.

Fix use-after-free observed with the s4u-operation examples.

Cosmetics (sonar).

Define each identifier in a dedicated statement (sonar).

Revert "Run mc-*-liveness tests serial, and hope to pass on CI."

This reverts commit 881507dc9fbeba0c63112dd0058d9c591b67419e.

In fact, it was just the CI infrastructure that was unusually slow these days.

Whitespace cleanup (codefactor.io).

Lazily compute the recipe of a state, on need only

This will be useful when leveraging intermediate states during
backtracks. In that case, we need to compute partial recipes, up to
the advanced restaure point.

More automatic memory mgmt in MC

MC: give each state an incoming transition too

Using the parent's outgoing transition is not reliable anymore now
that we don't always explore the tree in order, but rather following
the exploration strategies.

Fix comment [no-ci]

Run mc-*-liveness tests serial, and hope to pass on CI.

Fix comment.

There is no need to declare the default constructors here.

Fix build error: exception specification of explicitly
defaulted move constructor does not match the calculated one.

Merge branch 'operation-plugin' into 'master'

Operation plugin

See merge request simgrid/simgrid!145

Merge branch 'udpor-phase7' into 'master'

Phase 7 of UDPOR Integration: Add specialized `ex(C)` computation for `Comm*` transitions

See merge request simgrid/simgrid!144

sonar fixes

- Undefined return value (that would happen on a platform without any host)
- Local variable shadowing
- Automatic memory management
- const, explicit, etc.

Let resource profiles finish their initialization by themselves and kill presolve

No need to presolve the models to finish their initialization nowadays

I think that this was a leftover of the good old C times.

Only fire on_platform_created after creating the platform, not after loading the deployment

Add a target to recompile all ns3 tests (and only them)

rename create to init. add init with name only. add setters

Make sure that we never have a 0 transition at the end of the stack

Also send the disabled transitions over: UDPOR needs it

More informative message on system error

More defensive programing style

add missing '&' causing temporary value to be modified

rename on_start/on_end functions call to on_this_start/on_this_end. add on_start_cb and on_end_cb

Trust the config system to check that only valid values are used

Disable coverage on circleci.

It seems that it is not used and it slows down the tests.

[ci-skip]

Make this example valgrind-clean

Further cosmetics in that example, adding a helper function to s4u on the way

simplify the example now that host can be set to serial

Use host->set_concurrency_limit(1) in an example where it makes sense

Document a bit the MC changes

Allow to set a concurrency limit on disks and hosts

Inline Exploration::system_error.

Remove useless specialized exceptions from simgrid::mc.

Use an exception on Exploration::system_exit().

The goal is to use RAII to free the memory on exit, and get cleaner valgrind reports.

Sonar...

missing virtual destructor

fix distcheck

missing lib

clang-format

add prog_ns3 to manifest

add operation examples

several updates to plugin operation

add operation to plugin doc

add operation to manifest

fix bad type comparison

add operation plugin

Assignment operators should return non-"const" references (sonar).

Also enfore C++ "rule-of-three".

Mark functions as "const" (sonar).

Use std::string (sonar).

Misc sonar issues.