generalize previous change to other MPI predefined globals.
Except MPI_COMM_WORLD because of its specificities (has to be a variable)

sonar is right here

change the way MPI datatypes are declared.
Our previous solution did not let everything seen as const, and it was preventing some codes to compile (initializer element is not constant).
This allows to compile  https://github.com/open-mpi/mpi-test-suite.git without changint the code (will be added in proxy apps) in tst_types.c
todo : other types (op and co)

debug message --

Use flags to handle cancellation instead of a tri-state int

Change handling of MPI_PROC_NULL as a src or a dest.
We used to just skip the requests, but it was not possible to set status->MPI_SOURCE later in this case.

That was a stupid optimization.
Processes can be reordered, so count is not a guarantee here at all.

Regenerate.

Kill superfluous macros.

Zero-initialize struct to avoid valgrind warnings.

Inline trivial function.

Update .mailmap.

At most one resource allocation per statement (sonar).

MC: untangle dependencies

MC: more symmetry between WAITANY and TESTANY in dependency

No idea why TESTANY was doing specific cases on the first iteration,
nor even why it worked this way. But it was preventing the next commit
from occurring.

MC: untangle the dependency code a tiny bit

MC: inline a function, kill a file

Add multiple unimplemented calls in smpi.h
List gathered from mpi4py configuration tool

Implement MPI_Aint_add and MPI_Aint_diff

"Implement" MPI_Type_get_extent_x, MPI_Type_get_true_extent_x, and MPI_Status_set_elements_x

doc: add an hint on platform calibration, and various fixes

simgrid-mc also needs debugging symbols, so let's hint about it

doc: fix a borken link

Add a section presenting an overview of SimGrid design goals

clang ... override ... again

Remove constraint from LinkImpl ctor

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.