add boolean state to resources and protect set_core_count

fix pip builds

mc: rename Inspector to Observer

Simplify mc::api a bit

No need to expose a call to test whether there is a deadlock and a
call to react to deadlocks. Have the first call react by itself to
this situation.

cosmetics

Try to use more common PAPI events for testing.

Also fix the grep RE to not match the command line at the beginning of the file.

Don't crash on empty PAPI event set.

Cosmetics

use CRTP dor resources

remove model from Link constructors

Add a test for PAPI
next step : try to activate it on jenkins (for coverage, obviously)

PAPI tracing was broken with latest instr changes.
Expected because it's not tested.

Modernize simcall mutex_unlock.

Make SimcallInspector::dot_label and to_string pure virtual again.

It was wronly removed in commit 99b0a6c6788a22a446be3519233dd524a44f1ffd.

Fix mem leak.

Pointer to const.

std::runtime error takes a const&.

These tests were missing mpi_finalize call (hence some leaks).

change message a bit

mpi_comm_self was cleaned after mpi finalization during actor deletion, which was annoying (after leaks check).
Have it done at MPI_Finalize level.

Add simple example using smpi_execute_* calls inside MPI code to simulate computation.
This could double as a basic MPI example, as we are missing one, I think.

add errhandlers support for mpi_comm_world
As this communicator is actually shared, every process was overriding the errhandler, leading to using the same for every process, and leaking the others.

add leak checking for info and errhandlers

Rename mc_base.h -> .hpp (it's C++ only anyway).

Const for methods.

Cosmetic rename.

get_actor_string -> get_actor_dot_label
get_actor_string2 -> get_actor_string

Simplify namespaces

cleanups

cosmetics

add core_count setter

Auto + std::make_unique.

Uncomment.

Reduce code duplication.

Protect against buffer overflow.

Make Transition::textual a std::string.

Restore Rvalue references for xbt::Exception.

This was lost in commit 1361e008419329de33e4c92a6ad96621d40a9c40
and I don't remember any reason for that.

Exceptions are always built with temporaries, an d moving them should avoid
unnecessary copies.

Uncomment debug message.

Make field private (fixme--).

Use std::copy.

Type bool for boolean values.

Remove some useless nested code blocks.

Using C++ strings.

Use xbt::string for MC hostnames.

Kill useless function.

Use defined type alias.

Fix code generation (broken call to inspector_->is_pending), and reindent.

fix ns3

Consider Link latency as an optional parameter

more fluent version

Rollback a little in programmatic description of disks
- add Required fields (w.r.t. the DTD) to the create_disk method
- leave the setters to enable changes of mind or dynamic stuff between
create and seal (TODO: add a state and some asserts)
- Resources always have a name so add it in the ctor

Fix usage string.

Deprecated simcall_mc_random.

Maybe this can be dropped immediately?.

Make global variables 'const'.

A few less global variables.

Don't require MC dependencies when building w/o MC

Fix non-MC builds

Fix make distcheck :-(

Missing file

remove a workaround for a bug removed in previous commit

Inspector::to_string() was sometimes called for simcalls w/o inspectors.

Set the textual representation of a transition before executing it

This way it will correctly be set if the App aborts or fails during that execution.

Also, don't use the execution path that is reserved to simcalls with
observers `mc_model_checker->simcall_to_string()` in any case.
Prefer the path that works with old simcalls too `Api::request_to_string()`

Split inspector::is_pending() in two logical parts

- get_max_consider() returns how many times this simcall should be considered.
- prepare() does what needs to be done for the simcall to be fired in user space

This removes the RPC from MC to App to get this information:

 - The value of get_max_consider() is copied in the simcall structure
   when the AppSide prepares to wait for new instructions from the MC.
 - prepare() was already called by handle_simcall() on AppSide, to
   obey trace replays.

Less RPC is faster and less eror prone.

Not sure why to_string is sometimes called when there is no inspector, but survive this bug

Rename ActorState::consider() and State::add_interleaved_set() as {ActorState,State}::mark_todo()

Fix build on clang

objectification of MC simcall achieved -- many tests still failing

* MC_RANDOM is now a regular simcall, made observable by its SimcallInspector

  - remove it from simcall.in and remove all relevant elements

  - Other simcalls that are visible from MC (ie, that are generated by
    simcall.py and are handled in MC with big switch cases) are not
    modified at all, even if the patch reindent them since this execution
    path is now in a new conditionnal.

* SimcallInspectors are used everywhere where a specific handling was made for MC_RANDOM

  - In MC_state_choose_request_for_process, we get the next value to
    be picked by MC_random (or the next comm to be picked by waitany)
    depending on the amount of times we consider this simcall (ie, on the
    amount of decision forks we did on that transition while exploring the
    state space.
      This operation was not named before, it's now called is_pending()
    because it returns whether we should do another decision fork from
    that transition. Maybe is_branching() would be a better name.
      Or consider() since its parameter is times_considered, and there
    is one call location where its return value is ignored (when we
    replay all transitions on the path leading to the state we want to
    restore). But there is already a mc::ActorState::consider() where
    the Checker express interest in a given simcall.

  - The two other generic methods of SimcallInspectors are to_string()
    to get a textual representation of the transtion (eg to display the
    backtrace leading to the property violation), and dot_label() to
    get a label that can be used in dot(1). This is useful to get a
    visual representation of the state space.

  - There is a visible() method too, but I guess it's useless: Only
    visible simcall will be given an inspector. Or it will be more
    complex, because differing model checking algorithms will be
    interested in differing sets of simcalls (so visible() should be
    Checker-dependend). Leave it as is for now.

  - RandomSimcall is also implementing a get_value() method that
    allows its implementation. At the end of the day, the connexion
    between the actor side (out of the kernel) and the model-checker side
    is made with this code:

    auto observer = new simgrid::mc::RandomSimcall(SIMIX_process_self(), min, max);
    return simgrid::kernel::actor::simcall([observer] { return observer->get_value(); }, observer);

    The RandomSimcall object is really making the link between the two worlds.

  - When we will convert the other simcalls, something will be needed
    to handle transition dependency. Since MC_RANDOM is never dependent
    with anything, this is left unhandled in SimcallInspector for now.
    One problem at a time.

* SimcallInspectors live in the AppSide while these information are
  needed in the ModelChecker side. So the network protocol was
  extended to allow the Modelchecker to get this information thru RPC.

  This is not satisfactory because it probably slows things down, even
  if it's hard to say for sure because many tests just deadlock with it.
  When the AppSide is dead, you'd better not ask for a RPC to collect
  information about the simcalls that lead to the issue.

  I extended the State::Transition object (that is used to both replay
  a trace leading to a state I want to restore and to display the
  backtrace that lead to a violation) to include the textual
  representation of the transitions, to not do a RPC to the dead
  application on violation.

  But when the application abort(), I seem to have a stack corruption
  on the app side or something. And debugging the verified application
  is made very difficult by the Dwarf inspector that prevents the
  verification from starting if the subprocess is not compiled in one
  segment only (valgrind violates this rule). Plus valgrind has a
  subprocess itself, probably defeating the checkpoint/restore
  mechanism. Maybe I should try the Sanitizers.

* A better approach (if we fail to fix the curreny design) could be to
  pre-compute on AppSide all information that can be extracted from
  the inspectors, and copy it over to the CheckerSide once per
  scheduling round. That would speed things up, and ensure that there
  is no RPC after the death of the application. That should be done in
  place of MC_process_refresh_simix_actor_dynar() that copies some
  (less useful) information over.

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

Extend xbt_stringify_args up to 25 arguments

Welcome to modernity

extend example with another disk

allow for programmatic creation of a disk

typo

Need at least ns-3.28.

Declare function 'static' (and fix picky builders).

Update ASan suppressions for clang.

Fix make distcheck

ns3: Fix build when compile warnings are enabled

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

Merge branch 'master' into 'master'

Add option to delay wifi zone start time

See merge request simgrid/simgrid!47

missing override

Make progress towards a programmatic creation of disks

see what can be done with method chaining in disk creation

Change way Resources are created: Empty ctor and setters

Remove some cruft

AS->Zone

a bit more method chaining in the internals

Reduce scope for variable.

add wifi zone option to delay nodes start time

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

[sonar] Variable 'j' is not part of the loop control.

[sonar] Merge 'if' statements.

On failure, try again with longer sleep duration.

Use access modifier to disallow direct deletion. Remove superfluous boolean.

Define getter/setter for Exception::value.

Drop unused 'value' argument from THROW/THROWF.

[smpi] Make Group::range{incl,excl} simpler.

[smpi] Use a std::unique_ptr for f2c_lookup_.

[smpi] Prefer range-based for loop.

[smpi] Unused #define.

Define members and constructors in subclasses, where they belong.

Update .gitignore.