teshsuite/s4u/comm-fault-scenarios/comm-fault-scenarios.cpp

   1 /* Copyright (c) 2010-2022. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 /* This example validates the behaviour in presence of node and link fault.
   7  * Each test scenario consists in one host/actor (named sender) sending one message to another host/actor.
   8  * The space to cover is quite large, since we consider:
   9  * * communication types (eager, rendez-vous, one-sided=detached)
  10  * * use type (synchronous, asynchronous, init)
  11  * * fault type (sender node, link, receiver node)
  12  * * any legal permutation of the scenario steps
  13  *
  14  * This program also presents a way to simulate applications that are resilient to links and node faults.
  15  * Essentially, it catches exceptions related to communications and it clears the mailboxes when one of the nodes gets
  16  * turned off. However, this model would suppose that there would be 2 mailboxes for each pair of nodes, which is
  17  * probably unacceptable.
  18  *
  19  */
  20
  21 #include <algorithm>
  22 #include <random>
  23 #include <simgrid/kernel/ProfileBuilder.hpp>
  24 #include <simgrid/s4u.hpp>
  25 #include <sstream>
  26 #include <time.h>
  27 #include <vector>
  28
  29 namespace sg4 = simgrid::s4u;
  30 namespace pr  = simgrid::kernel::profile;
  31
  32 XBT_LOG_NEW_DEFAULT_CATEGORY(comm_fault_scenarios, "Messages specific for this s4u example");
  33
  34 /*************************************************************************************************/
  35
  36 // Constants for platform configuration
  37 constexpr double HostComputePower = 1e9;  // FLOPs
  38 constexpr double LinkBandwidth    = 1e9;  // Bytes/second
  39 constexpr double LinkLatency      = 1e-6; // Seconds
  40
  41 // Constants for application behaviour
  42 constexpr auto MsgSize = static_cast<uint64_t>(LinkBandwidth / 2);
  43
  44 /*************************************************************************************************/
  45
  46 XBT_DECLARE_ENUM_CLASS(CommType, EAGER_SYNC, EAGER_ASYNC, EAGER_INIT, RDV_SYNC, RDV_ASYNC, RDV_INIT, ONESIDE_SYNC,
  47                        ONESIDE_ASYNC
  48                        // ONESIDE_INIT is equivalent to ONESIDE_ASYNC
  49 );
  50
  51 XBT_DECLARE_ENUM_CLASS(Action, SLEEP, PUT, GET, START, WAIT, DIE, END);
  52
  53 struct Step {
  54   XBT_DECLARE_ENUM_CLASS(Type, STATE, ACTION);
  55   XBT_DECLARE_ENUM_CLASS(Entity, LNK, SND, RCV);
  56
  57   double rel_time; // Time relative to Scenario startTime
  58   Type type;
  59   Entity entity;
  60   Action action_type;
  61   bool new_state;
  62 };
  63
  64 struct Scenario {
  65   CommType type;
  66   double start_time;
  67   double duration;
  68   Action snd_expected;
  69   Action rcv_expected;
  70   std::vector<Step> steps;
  71   int index;
  72 };
  73
  74 static std::string to_string(const Scenario& s)
  75 {
  76   std::stringstream ss;
  77   ss << "#" << s.index << "[" << s.start_time << "s," << s.start_time + s.duration << "s[: (" << to_c_str(s.type);
  78   ss << ") Expected: S:" << to_c_str(s.snd_expected) << " R:" << to_c_str(s.rcv_expected) << " Steps: ";
  79   for (const Step& step : s.steps) {
  80     ss << "+" << step.rel_time << "s:" << Step::to_c_str(step.entity);
  81
  82     if (step.type == Step::Type::STATE) {
  83       ss << "->";
  84       if (step.new_state)
  85         ss << "ON";
  86       else
  87         ss << "OFF";
  88     } else {
  89       ss << "." << to_c_str(step.action_type);
  90     }
  91     ss << " ";
  92   }
  93   return ss.str();
  94 }
  95
  96 struct MBoxes {
  97   sg4::Mailbox* eager;
  98   sg4::Mailbox* rdv;
  99 };
 100
 101 struct ScenarioContext {
 102   int index;
 103   int active;
 104   double start_time;
 105   std::stringstream sender_profile;
 106   std::stringstream receiver_profile;
 107   std::stringstream link_profile;
 108   std::vector<int> active_indices;
 109   std::vector<Scenario> scenarios;
 110 };
 111
 112 class SendAgent {
 113   static int run_;
 114   static size_t scenario_;
 115   int id_;
 116   sg4::Host* other_host_;
 117   const MBoxes& mbox_;
 118   const ScenarioContext& ctx_;
 119
 120   sg4::CommPtr do_put(CommType type, double& send_value)
 121   {
 122     switch (type) {
 123       case CommType::EAGER_SYNC:
 124         mbox_.eager->put(&send_value, MsgSize);
 125         return nullptr;
 126       case CommType::EAGER_ASYNC:
 127         return mbox_.eager->put_async(&send_value, MsgSize);
 128       case CommType::EAGER_INIT:
 129         return mbox_.eager->put_init(&send_value, MsgSize);
 130       case CommType::RDV_SYNC:
 131         mbox_.rdv->put(&send_value, MsgSize);
 132         return nullptr;
 133       case CommType::RDV_ASYNC:
 134         return mbox_.rdv->put_async(&send_value, MsgSize);
 135       case CommType::RDV_INIT:
 136         return mbox_.rdv->put_init(&send_value, MsgSize);
 137       case CommType::ONESIDE_SYNC:
 138         sg4::Comm::sendto(sg4::this_actor::get_host(), other_host_, MsgSize);
 139         return nullptr;
 140       case CommType::ONESIDE_ASYNC:
 141         return sg4::Comm::sendto_async(sg4::this_actor::get_host(), other_host_, MsgSize);
 142       default:
 143         break;
 144     }
 145     DIE_IMPOSSIBLE;
 146   }
 147
 148   void send_message(const Scenario& s)
 149   {
 150     std::string scenario_string = to_string(s);
 151     XBT_DEBUG("Will try: %s", scenario_string.c_str());
 152     double send_value;
 153     sg4::CommPtr comm = nullptr;
 154     Action expected   = s.snd_expected;
 155     double end_time   = s.start_time + s.duration;
 156     send_value        = end_time;
 157     size_t step_index = 0;
 158     sg4::this_actor::sleep_until(s.start_time);
 159     // Make sure we have a clean slate
 160     xbt_assert(not mbox_.eager->listen(), "Eager mailbox should be empty when starting a test");
 161     xbt_assert(not mbox_.rdv->listen(), "RDV mailbox should be empty when starting a test");
 162     for (; step_index < s.steps.size(); step_index++) {
 163       const Step& step = s.steps[step_index];
 164       if (step.entity != Step::Entity::SND || step.type != Step::Type::ACTION)
 165         continue;
 166       try {
 167         sg4::this_actor::sleep_until(s.start_time + step.rel_time);
 168       } catch (const simgrid::Exception& e) {
 169         XBT_DEBUG("During Sleep, failed to send message because of a %s exception (%s)", typeid(e).name(), e.what());
 170         break;
 171       }
 172       // Check if the other host is still OK.
 173       if (not other_host_->is_on())
 174         break;
 175       // Perform the action
 176       try {
 177         switch (step.action_type) {
 178           case Action::PUT:
 179             comm = do_put(s.type, send_value);
 180             break;
 181           case Action::START:
 182             comm->start();
 183             break;
 184           case Action::WAIT:
 185             comm->wait();
 186             break;
 187           default:
 188             xbt_die("Not a valid action for SND");
 189         }
 190       } catch (const simgrid::Exception& e) {
 191         XBT_DEBUG("During %s, failed to send message because of a %s exception (%s)", to_c_str(step.action_type),
 192                   typeid(e).name(), e.what());
 193         break;
 194       }
 195     }
 196     try {
 197       sg4::this_actor::sleep_until(end_time);
 198     } catch (const simgrid::Exception& e) {
 199       XBT_DEBUG("During Sleep, failed to send message because of a %s exception (%s)", typeid(e).name(), e.what());
 200     }
 201     Action outcome = Action::END;
 202     if (step_index < s.steps.size()) {
 203       const Step& step = s.steps[step_index];
 204       assert(step.entity == Step::Entity::SND && step.type == Step::Type::ACTION);
 205       outcome = step.action_type;
 206     }
 207     if (outcome != expected) {
 208       XBT_ERROR("Expected %s but got %s in %s", to_c_str(expected), to_c_str(outcome), scenario_string.c_str());
 209     } else {
 210       XBT_DEBUG("OK: %s", scenario_string.c_str());
 211     }
 212     sg4::this_actor::sleep_until(end_time);
 213     xbt_assert(not mbox_.eager->listen(), "Mailbox should not have ongoing communication!");
 214     xbt_assert(not mbox_.rdv->listen(), "Mailbox should not have ongoing communication!");
 215   }
 216
 217 public:
 218   explicit SendAgent(int id, sg4::Host* other_host, const MBoxes& mbox, const ScenarioContext& ctx)
 219       : id_(id), other_host_(other_host), mbox_(mbox), ctx_(ctx)
 220   {
 221   }
 222
 223   void operator()()
 224   {
 225     run_++;
 226     XBT_DEBUG("Host %i starts run %i and scenario %zu.", id_, run_, scenario_);
 227     while (scenario_ < ctx_.scenarios.size()) {
 228       const Scenario& s = ctx_.scenarios[scenario_];
 229       scenario_++;
 230       send_message(s);
 231     }
 232   }
 233 };
 234
 235 int SendAgent::run_         = 0;
 236 size_t SendAgent::scenario_ = 0;
 237
 238 /*************************************************************************************************/
 239
 240 class ReceiveAgent {
 241   static int run_;
 242   static size_t scenario_;
 243   int id_;
 244   sg4::Host* other_host_;
 245   const MBoxes& mbox_;
 246   const ScenarioContext& ctx_;
 247
 248   sg4::CommPtr do_get(CommType type, double*& receive_ptr) const
 249   {
 250     switch (type) {
 251       case CommType::EAGER_SYNC:
 252         receive_ptr = mbox_.eager->get<double>();
 253         return nullptr;
 254       case CommType::EAGER_ASYNC:
 255         return mbox_.eager->get_async(&receive_ptr);
 256       case CommType::EAGER_INIT:
 257         return mbox_.eager->get_init()->set_dst_data((void**)(&receive_ptr));
 258       case CommType::RDV_SYNC:
 259         receive_ptr = mbox_.rdv->get<double>();
 260         return nullptr;
 261       case CommType::RDV_ASYNC:
 262         return mbox_.rdv->get_async(&receive_ptr);
 263       case CommType::RDV_INIT:
 264         return mbox_.rdv->get_init()->set_dst_data((void**)(&receive_ptr));
 265       case CommType::ONESIDE_SYNC:
 266       case CommType::ONESIDE_ASYNC:
 267         xbt_die("No get in One Sided comunications!");
 268       default:
 269         break;
 270     }
 271     DIE_IMPOSSIBLE;
 272   }
 273
 274   void receive_message(const Scenario& s)
 275   {
 276     sg4::CommPtr comm   = nullptr;
 277     CommType type       = s.type;
 278     Action expected     = s.rcv_expected;
 279     double end_time     = s.start_time + s.duration;
 280     double* receive_ptr = nullptr;
 281     size_t step_index   = 0;
 282     sg4::this_actor::sleep_until(s.start_time);
 283     // Make sure we have a clean slate
 284     xbt_assert(not mbox_.eager->listen(), "Eager mailbox should be empty when starting a test");
 285     xbt_assert(not mbox_.rdv->listen(), "RDV mailbox should be empty when starting a test");
 286     for (; step_index < s.steps.size(); step_index++) {
 287       const Step& step = s.steps[step_index];
 288       if (step.entity != Step::Entity::RCV || step.type != Step::Type::ACTION)
 289         continue;
 290       try {
 291         sg4::this_actor::sleep_until(s.start_time + step.rel_time);
 292       } catch (const simgrid::Exception& e) {
 293         XBT_DEBUG("During Sleep, failed to receive message because of a %s exception (%s)", typeid(e).name(), e.what());
 294         break;
 295       }
 296       // Check if the other host is still OK.
 297       if (not other_host_->is_on())
 298         break;
 299       // Perform the action
 300       try {
 301         switch (step.action_type) {
 302           case Action::GET:
 303             comm = do_get(type, receive_ptr);
 304             break;
 305           case Action::START:
 306             comm->start();
 307             break;
 308           case Action::WAIT:
 309             comm->wait();
 310             break;
 311           default:
 312             xbt_die("Not a valid action for RCV");
 313         }
 314       } catch (const simgrid::Exception& e) {
 315         XBT_DEBUG("During %s, failed to receive message because of a %s exception (%s)", to_c_str(step.action_type),
 316                   typeid(e).name(), e.what());
 317         break;
 318       }
 319     }
 320     try {
 321       sg4::this_actor::sleep_until(end_time - .1);
 322     } catch (const simgrid::Exception& e) {
 323       XBT_DEBUG("During Sleep, failed to send message because of a %s exception (%s)", typeid(e).name(), e.what());
 324     }
 325     Action outcome              = Action::END;
 326     std::string scenario_string = to_string(s);
 327     if (step_index < s.steps.size()) {
 328       const Step& step = s.steps[step_index];
 329       assert(step.entity == Step::Entity::RCV && step.type == Step::Type::ACTION);
 330       outcome = step.action_type;
 331     } else if (s.type != CommType::ONESIDE_SYNC && s.type != CommType::ONESIDE_ASYNC) {
 332       // One sided / detached operations do not actually transfer anything
 333       if (receive_ptr == nullptr) {
 334         XBT_ERROR("Received address is NULL in %s", scenario_string.c_str());
 335       } else if (*receive_ptr != end_time) {
 336         XBT_ERROR("Received value invalid: expected %f but got %f in %s", end_time, *receive_ptr,
 337                   scenario_string.c_str());
 338       }
 339     }
 340     if (outcome != expected) {
 341       XBT_ERROR("Expected %s but got %s in %s", to_c_str(expected), to_c_str(outcome), scenario_string.c_str());
 342     } else {
 343       XBT_DEBUG("OK: %s", scenario_string.c_str());
 344     }
 345     sg4::this_actor::sleep_until(end_time);
 346     xbt_assert(not mbox_.eager->listen(), "Mailbox should not have ongoing communication!");
 347     xbt_assert(not mbox_.rdv->listen(), "Mailbox should not have ongoing communication!");
 348   }
 349
 350 public:
 351   explicit ReceiveAgent(int id, sg4::Host* other_host, const MBoxes& mbox, const ScenarioContext& ctx)
 352       : id_(id), other_host_(other_host), mbox_(mbox), ctx_(ctx)
 353   {
 354   }
 355   void operator()()
 356   {
 357     run_++;
 358     XBT_DEBUG("Host %i starts run %i and scenario %zu.", id_, run_, scenario_);
 359     mbox_.eager->set_receiver(sg4::Actor::self());
 360     while (scenario_ < ctx_.scenarios.size()) {
 361       const Scenario& s = ctx_.scenarios[scenario_];
 362       scenario_++;
 363       receive_message(s);
 364     }
 365   }
 366 };
 367
 368 int ReceiveAgent::run_         = 0;
 369 size_t ReceiveAgent::scenario_ = 0;
 370
 371 static double build_scenarios(ScenarioContext& ctx);
 372
 373 int main(int argc, char* argv[])
 374 {
 375   sg4::Engine e(&argc, argv);
 376   ScenarioContext ctx;
 377   int previous_index = -1;
 378   bool is_range_last = false;
 379   for (int i = 1; i < argc; i++) {
 380     if (not strcmp(argv[i], "-")) {
 381       is_range_last = true;
 382       continue;
 383     }
 384     int index = atoi(argv[i]);
 385     xbt_assert(index > previous_index);
 386     if (is_range_last)
 387       for (int j = previous_index + 1; j <= index; j++)
 388         ctx.active_indices.push_back(j);
 389     else
 390       ctx.active_indices.push_back(index);
 391     is_range_last  = false;
 392     previous_index = index;
 393   }
 394   double end_time = build_scenarios(ctx);
 395   XBT_INFO("Will run for %f seconds", end_time);
 396   MBoxes mbox;
 397   mbox.eager                  = e.mailbox_by_name_or_create("eager");
 398   mbox.rdv                    = e.mailbox_by_name_or_create("rdv");
 399   sg4::NetZone* zone          = sg4::create_full_zone("Top");
 400   pr::Profile* profile_sender = pr::ProfileBuilder::from_string("sender_profile", ctx.sender_profile.str(), 0);
 401   sg4::Host* sender_host = zone->create_host("senderHost", HostComputePower)->set_state_profile(profile_sender)->seal();
 402   pr::Profile* profile_receiver = pr::ProfileBuilder::from_string("receiver_profile", ctx.receiver_profile.str(), 0);
 403   sg4::Host* receiver_host =
 404       zone->create_host("receiverHost", HostComputePower)->set_state_profile(profile_receiver)->seal();
 405   sg4::ActorPtr sender = sg4::Actor::create("sender", sender_host, SendAgent(0, receiver_host, mbox, ctx));
 406   sender->set_auto_restart(true);
 407   sg4::ActorPtr receiver = sg4::Actor::create("receiver", receiver_host, ReceiveAgent(1, sender_host, mbox, ctx));
 408   receiver->set_auto_restart(true);
 409   pr::Profile* profile_link = pr::ProfileBuilder::from_string("link_profile", ctx.link_profile.str(), 0);
 410   sg4::Link const* link =
 411       zone->create_link("link", LinkBandwidth)->set_latency(LinkLatency)->set_state_profile(profile_link)->seal();
 412   zone->add_route(sender_host->get_netpoint(), receiver_host->get_netpoint(), nullptr, nullptr,
 413                   {sg4::LinkInRoute{link}}, false);
 414   zone->seal();
 415
 416   sg4::Host::on_state_change_cb([mbox](sg4::Host const& host) {
 417     XBT_DEBUG("Host %s is now %s", host.get_cname(), host.is_on() ? "ON " : "OFF");
 418     if (not host.is_on()) {
 419       mbox.eager->clear();
 420       mbox.rdv->clear();
 421     }
 422   });
 423
 424   sg4::Link::on_state_change_cb(
 425       [](sg4::Link const& link) { XBT_DEBUG("Link %s is now %s", link.get_cname(), link.is_on() ? "ON " : "OFF"); });
 426
 427   e.run_until(end_time);
 428
 429   // Make sure we have a clean slate
 430   xbt_assert(not mbox.eager->listen(), "Eager mailbox should be empty in the end");
 431   xbt_assert(not mbox.rdv->listen(), "RDV mailbox should be empty in the end");
 432   XBT_INFO("Done.");
 433   return 0;
 434 }
 435
 436 static void prepareScenario(ScenarioContext& ctx, CommType type, double duration, Action sender_expected,
 437                             Action receiver_expected, const std::vector<Step>& steps)
 438 {
 439   if (std::find(ctx.active_indices.begin(), ctx.active_indices.end(), ctx.index) != ctx.active_indices.end()) {
 440     // Update fault profiles
 441     for (const Step& step : steps) {
 442       assert(step.rel_time < duration);
 443       if (step.type != Step::Type::STATE)
 444         continue;
 445       int val = step.new_state ? 1 : 0;
 446       switch (step.entity) {
 447         case Step::Entity::SND:
 448           ctx.sender_profile << ctx.start_time + step.rel_time << " " << val << std::endl;
 449           break;
 450         case Step::Entity::RCV:
 451           ctx.receiver_profile << ctx.start_time + step.rel_time << " " << val << std::endl;
 452           break;
 453         case Step::Entity::LNK:
 454           ctx.link_profile << ctx.start_time + step.rel_time << " " << val << std::endl;
 455           break;
 456         default:
 457           DIE_IMPOSSIBLE;
 458       }
 459     }
 460     ctx.scenarios.push_back({type, ctx.start_time, duration, sender_expected, receiver_expected, steps, ctx.index});
 461     ctx.active++;
 462   }
 463   ctx.index++;
 464   ctx.start_time += duration;
 465 }
 466
 467 /*************************************************************************************************/
 468
 469 // A bunch of dirty macros to help readability (supposedly)
 470 #define MAKE_SCENARIO(type, duration, snd_expected, rcv_expected, steps...)                                            \
 471   prepareScenario(ctx, CommType::type, duration, Action::snd_expected, Action::rcv_expected, {steps})
 472
 473 // Link
 474 static Step loff(double rel_time)
 475 {
 476   return {rel_time, Step::Type::STATE, Step::Entity::LNK, Action::END, false};
 477 }
 478 static Step lon(double rel_time)
 479 {
 480   return {rel_time, Step::Type::STATE, Step::Entity::LNK, Action::END, true};
 481 }
 482 // Sender
 483 static Step soff(double rel_time)
 484 {
 485   return {rel_time, Step::Type::STATE, Step::Entity::SND, Action::END, false};
 486 }
 487 static Step son(double rel_time)
 488 {
 489   return {rel_time, Step::Type::STATE, Step::Entity::SND, Action::END, true};
 490 }
 491 static Step sput(double rel_time)
 492 {
 493   return {rel_time, Step::Type::ACTION, Step::Entity::SND, Action::PUT, false};
 494 }
 495 static Step swait(double rel_time)
 496 {
 497   return {rel_time, Step::Type::ACTION, Step::Entity::SND, Action::WAIT, false};
 498 }
 499 // Receiver
 500 static Step roff(double rel_time)
 501 {
 502   return {rel_time, Step::Type::STATE, Step::Entity::RCV, Action::END, false};
 503 }
 504 static Step ron(double rel_time)
 505 {
 506   return {rel_time, Step::Type::STATE, Step::Entity::RCV, Action::END, true};
 507 }
 508 static Step rget(double rel_time)
 509 {
 510   return {rel_time, Step::Type::ACTION, Step::Entity::RCV, Action::GET, false};
 511 }
 512 static Step rwait(double rel_time)
 513 {
 514   return {rel_time, Step::Type::ACTION, Step::Entity::RCV, Action::WAIT, false};
 515 }
 516
 517 static double build_scenarios(ScenarioContext& ctx)
 518 {
 519   ctx.start_time = 0;
 520   ctx.index      = 0;
 521   ctx.active     = 0;
 522
 523   // EAGER SYNC use cases
 524   // All good
 525   MAKE_SCENARIO(EAGER_SYNC, 1, END, END, sput(.2), rget(.4));
 526   MAKE_SCENARIO(EAGER_SYNC, 1, END, END, rget(.2), sput(.4));
 527   // Receiver off
 528   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, DIE, roff(.1), sput(.2), ron(1));
 529   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, DIE, sput(.2), roff(.3), ron(1));
 530   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, DIE, sput(.2), rget(.4), roff(.5), ron(1));
 531   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, DIE, rget(.2), sput(.4), roff(.5), ron(1));
 532   // Sender off
 533   MAKE_SCENARIO(EAGER_SYNC, 2, DIE, GET, sput(.2), soff(.3), rget(.4), son(1));
 534   MAKE_SCENARIO(EAGER_SYNC, 2, DIE, GET, sput(.2), rget(.4), soff(.5), son(1));
 535   // Link off
 536   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, GET, loff(.1), sput(.2), rget(.4), lon(1));
 537   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, GET, sput(.2), loff(.3), rget(.4), lon(1));
 538   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, GET, sput(.2), rget(.4), loff(.5), lon(1));
 539   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, GET, loff(.1), rget(.2), sput(.4), lon(1));
 540   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, GET, rget(.2), loff(.3), sput(.4), lon(1));
 541   MAKE_SCENARIO(EAGER_SYNC, 2, PUT, GET, rget(.2), sput(.4), loff(.5), lon(1));
 542
 543   // EAGER ASYNC use cases
 544   // All good
 545   MAKE_SCENARIO(EAGER_ASYNC, 2, END, END, sput(.2), swait(.4), rget(.6), rwait(.8));
 546   MAKE_SCENARIO(EAGER_ASYNC, 2, END, END, sput(.2), rget(.4), swait(.6), rwait(.8));
 547   MAKE_SCENARIO(EAGER_ASYNC, 2, END, END, sput(.2), rget(.4), rwait(.6), swait(.8));
 548   MAKE_SCENARIO(EAGER_ASYNC, 2, END, END, rget(.2), sput(.4), swait(.6), rwait(.8));
 549   MAKE_SCENARIO(EAGER_ASYNC, 2, END, END, rget(.2), sput(.4), rwait(.6), swait(.8));
 550   MAKE_SCENARIO(EAGER_ASYNC, 2, END, END, rget(.2), rwait(.4), sput(.6), swait(.8));
 551   // Receiver off
 552   MAKE_SCENARIO(EAGER_ASYNC, 2, PUT, DIE, roff(.1), sput(.2), swait(.4), ron(1));
 553   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, sput(.2), roff(.3), swait(.4), ron(1));
 554   MAKE_SCENARIO(EAGER_ASYNC, 2, PUT, DIE, rget(.2), roff(.3), sput(.4), swait(.6), ron(1));
 555   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, sput(.2), swait(.4), roff(.5), ron(1));
 556   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, sput(.2), rget(.4), roff(.5), swait(.6), ron(1));
 557   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, rget(.2), sput(.4), roff(.5), swait(.6), ron(1));
 558   MAKE_SCENARIO(EAGER_ASYNC, 2, PUT, DIE, rget(.2), rwait(.4), roff(.5), sput(.6), swait(.8), ron(1));
 559   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, sput(.2), swait(.4), rget(.6), roff(.7), ron(1));
 560   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, sput(.2), rget(.4), swait(.6), roff(.7), ron(1));
 561   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, sput(.2), rget(.4), rwait(.6), roff(.7), swait(.8), ron(1));
 562   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, rget(.2), sput(.4), swait(.6), roff(.7), ron(1));
 563   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, rget(.2), sput(.4), rwait(.6), roff(.7), swait(.8), ron(1));
 564   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, DIE, rget(.2), rwait(.4), sput(.6), roff(.7), swait(.8), ron(1));
 565   // Sender off (only cases where sender did put, because otherwise receiver cannot find out there was a fault)
 566   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, GET, sput(.2), soff(.3), rget(.4), rwait(.6), son(1));
 567   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, WAIT, rget(.2), sput(.4), soff(.5), rwait(.6), son(1));
 568   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, WAIT, sput(.2), rget(.4), soff(.5), rwait(.6), son(1));
 569   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, GET, sput(.2), swait(.4), soff(.5), rget(.6), rwait(.8), son(1));
 570   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, WAIT, rget(.2), rwait(.4), sput(.6), soff(.7), son(1));
 571   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, WAIT, rget(.2), sput(.4), rwait(.6), soff(.7), son(1));
 572   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, WAIT, rget(.2), sput(.4), swait(.6), soff(.7), rwait(.8), son(1));
 573   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, WAIT, sput(.2), rget(.4), rwait(.6), soff(.7), son(1));
 574   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, WAIT, sput(.2), rget(.4), swait(.6), soff(.7), rwait(.8), son(1));
 575   MAKE_SCENARIO(EAGER_ASYNC, 2, DIE, WAIT, sput(.2), swait(.4), rget(.6), soff(.7), rwait(.8), son(1));
 576   // Link off
 577   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, loff(.1), sput(.2), swait(.4), rget(.6), rwait(.8), lon(1));
 578   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, loff(.1), sput(.2), rget(.4), swait(.6), rwait(.8), lon(1));
 579   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, loff(.1), sput(.2), rget(.4), rwait(.6), swait(.8), lon(1));
 580   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, loff(.1), rget(.2), sput(.4), swait(.6), rwait(.8), lon(1));
 581   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, loff(.1), rget(.2), sput(.4), rwait(.6), swait(.8), lon(1));
 582   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, loff(.1), rget(.2), rwait(.4), sput(.6), swait(.8), lon(1));
 583   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, sput(.2), loff(.3), swait(.4), rget(.6), rwait(.8), lon(1));
 584   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, sput(.2), loff(.3), rget(.4), swait(.6), rwait(.8), lon(1));
 585   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, sput(.2), loff(.3), rget(.4), rwait(.6), swait(.8), lon(1));
 586   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, rget(.2), loff(.3), sput(.4), swait(.6), rwait(.8), lon(1));
 587   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, rget(.2), loff(.3), sput(.4), rwait(.6), swait(.8), lon(1));
 588   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, rget(.2), loff(.3), rwait(.4), sput(.6), swait(.8), lon(1));
 589   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, sput(.2), swait(.4), loff(.5), rget(.6), rwait(.8), lon(1));
 590   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, sput(.2), rget(.4), loff(.5), swait(.6), rwait(.8), lon(1));
 591   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, sput(.2), rget(.4), loff(.5), rwait(.6), swait(.8), lon(1));
 592   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, rget(.2), sput(.4), loff(.5), swait(.6), rwait(.8), lon(1));
 593   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, rget(.2), sput(.4), loff(.5), rwait(.6), swait(.8), lon(1));
 594   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, rget(.2), rwait(.4), loff(.5), sput(.6), swait(.8), lon(1));
 595   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, sput(.2), swait(.4), rget(.6), loff(.7), rwait(.8), lon(1));
 596   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, sput(.2), rget(.4), swait(.6), loff(.7), rwait(.8), lon(1));
 597   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, sput(.2), rget(.4), rwait(.6), loff(.7), swait(.8), lon(1));
 598   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, rget(.2), sput(.4), swait(.6), loff(.7), rwait(.8), lon(1));
 599   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, rget(.2), sput(.4), rwait(.6), loff(.7), swait(.8), lon(1));
 600   MAKE_SCENARIO(EAGER_ASYNC, 2, WAIT, WAIT, rget(.2), rwait(.4), sput(.6), loff(.7), swait(.8), lon(1));
 601
 602   // RDV SYNC use cases
 603   // All good
 604   MAKE_SCENARIO(RDV_SYNC, 1, END, END, sput(.2), rget(.4));
 605   MAKE_SCENARIO(RDV_SYNC, 1, END, END, rget(.2), sput(.4));
 606   // Receiver off
 607   MAKE_SCENARIO(RDV_SYNC, 2, PUT, DIE, roff(.1), sput(.2), ron(1));
 608   MAKE_SCENARIO(RDV_SYNC, 2, PUT, DIE, sput(.2), roff(.3),
 609                 ron(1)); // Fails because put comm cancellation does not trigger sender exception
 610   MAKE_SCENARIO(RDV_SYNC, 2, PUT, DIE, sput(.2), rget(.4), roff(.5), ron(1));
 611   MAKE_SCENARIO(RDV_SYNC, 2, PUT, DIE, rget(.2), sput(.4), roff(.5), ron(1));
 612   // Sender off
 613   MAKE_SCENARIO(RDV_SYNC, 2, DIE, GET, sput(.2), rget(.4), soff(.5), son(1));
 614   // Link off
 615   MAKE_SCENARIO(RDV_SYNC, 2, PUT, GET, loff(.1), sput(.2), rget(.4), lon(1));
 616   MAKE_SCENARIO(RDV_SYNC, 2, PUT, GET, sput(.2), loff(.3), rget(.4), lon(1));
 617   MAKE_SCENARIO(RDV_SYNC, 2, PUT, GET, sput(.2), rget(.4), loff(.5), lon(1));
 618   MAKE_SCENARIO(RDV_SYNC, 2, PUT, GET, loff(.1), rget(.2), sput(.4), lon(1));
 619   MAKE_SCENARIO(RDV_SYNC, 2, PUT, GET, rget(.2), loff(.3), sput(.4), lon(1));
 620   MAKE_SCENARIO(RDV_SYNC, 2, PUT, GET, rget(.2), sput(.4), loff(.5), lon(1));
 621
 622   // RDV ASYNC use cases
 623   // All good
 624   MAKE_SCENARIO(RDV_ASYNC, 2, END, END, sput(.2), swait(.4), rget(.6), rwait(.8));
 625   MAKE_SCENARIO(RDV_ASYNC, 2, END, END, sput(.2), rget(.4), swait(.6), rwait(.8));
 626   MAKE_SCENARIO(RDV_ASYNC, 2, END, END, sput(.2), rget(.4), rwait(.6), swait(.8));
 627   MAKE_SCENARIO(RDV_ASYNC, 2, END, END, rget(.2), sput(.4), swait(.6), rwait(.8));
 628   MAKE_SCENARIO(RDV_ASYNC, 2, END, END, rget(.2), sput(.4), rwait(.6), swait(.8));
 629   MAKE_SCENARIO(RDV_ASYNC, 2, END, END, rget(.2), rwait(.4), sput(.6), swait(.8));
 630   // Receiver off
 631   MAKE_SCENARIO(RDV_ASYNC, 2, PUT, DIE, roff(.1), sput(.2), swait(.4), ron(1));
 632   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, sput(.2), roff(.3), swait(.4), ron(1));
 633   MAKE_SCENARIO(RDV_ASYNC, 2, PUT, DIE, rget(.2), roff(.3), sput(.4), swait(.6), ron(1));
 634   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, sput(.2), swait(.4), roff(.5),
 635                 ron(1)); // Fails because put comm cancellation does not trigger sender exception
 636   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, sput(.2), rget(.4), roff(.5), swait(.6), ron(1));
 637   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, rget(.2), sput(.4), roff(.5), swait(.6), ron(1));
 638   MAKE_SCENARIO(RDV_ASYNC, 2, PUT, DIE, rget(.2), rwait(.4), roff(.5), sput(.6), swait(.8), ron(1));
 639   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, sput(.2), swait(.4), rget(.6), roff(.7), ron(1));
 640   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, sput(.2), rget(.4), swait(.6), roff(.7), ron(1));
 641   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, sput(.2), rget(.4), rwait(.6), roff(.7), swait(.8), ron(1));
 642   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, rget(.2), sput(.4), swait(.6), roff(.7), ron(1));
 643   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, rget(.2), sput(.4), rwait(.6), roff(.7), swait(.8), ron(1));
 644   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, DIE, rget(.2), rwait(.4), sput(.6), roff(.7), swait(.8), ron(1));
 645   // Sender off (only cases where sender did put, because otherwise receiver cannot find out there was a fault)
 646   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, GET, sput(.2), soff(.3), rget(.4), rwait(.6), son(1));
 647   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, WAIT, rget(.2), sput(.4), soff(.5), rwait(.6), son(1));
 648   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, WAIT, sput(.2), rget(.4), soff(.5), rwait(.6), son(1));
 649   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, GET, sput(.2), swait(.4), soff(.5), rget(.6), rwait(.8), son(1));
 650   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, WAIT, rget(.2), rwait(.4), sput(.6), soff(.7), son(1));
 651   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, WAIT, rget(.2), sput(.4), rwait(.6), soff(.7), son(1));
 652   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, WAIT, rget(.2), sput(.4), swait(.6), soff(.7), rwait(.8), son(1));
 653   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, WAIT, sput(.2), rget(.4), rwait(.6), soff(.7), son(1));
 654   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, WAIT, sput(.2), rget(.4), swait(.6), soff(.7), rwait(.8), son(1));
 655   MAKE_SCENARIO(RDV_ASYNC, 2, DIE, WAIT, sput(.2), swait(.4), rget(.6), soff(.7), rwait(.8), son(1));
 656   // Link off
 657   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, loff(.1), sput(.2), swait(.4), rget(.6), rwait(.8), lon(1));
 658   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, loff(.1), sput(.2), rget(.4), swait(.6), rwait(.8), lon(1));
 659   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, loff(.1), sput(.2), rget(.4), rwait(.6), swait(.8), lon(1));
 660   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, loff(.1), rget(.2), sput(.4), swait(.6), rwait(.8), lon(1));
 661   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, loff(.1), rget(.2), sput(.4), rwait(.6), swait(.8), lon(1));
 662   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, loff(.1), rget(.2), rwait(.4), sput(.6), swait(.8), lon(1));
 663   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, sput(.2), loff(.3), swait(.4), rget(.6), rwait(.8), lon(1));
 664   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, sput(.2), loff(.3), rget(.4), swait(.6), rwait(.8), lon(1));
 665   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, sput(.2), loff(.3), rget(.4), rwait(.6), swait(.8), lon(1));
 666   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, rget(.2), loff(.3), sput(.4), swait(.6), rwait(.8), lon(1));
 667   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, rget(.2), loff(.3), sput(.4), rwait(.6), swait(.8), lon(1));
 668   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, rget(.2), loff(.3), rwait(.4), sput(.6), swait(.8), lon(1));
 669   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, sput(.2), swait(.4), loff(.5), rget(.6), rwait(.8), lon(1));
 670   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, sput(.2), rget(.4), loff(.5), swait(.6), rwait(.8), lon(1));
 671   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, sput(.2), rget(.4), loff(.5), rwait(.6), swait(.8), lon(1));
 672   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, rget(.2), sput(.4), loff(.5), swait(.6), rwait(.8), lon(1));
 673   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, rget(.2), sput(.4), loff(.5), rwait(.6), swait(.8), lon(1));
 674   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, rget(.2), rwait(.4), loff(.5), sput(.6), swait(.8), lon(1));
 675   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, sput(.2), swait(.4), rget(.6), loff(.7), rwait(.8), lon(1));
 676   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, sput(.2), rget(.4), swait(.6), loff(.7), rwait(.8), lon(1));
 677   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, sput(.2), rget(.4), rwait(.6), loff(.7), swait(.8), lon(1));
 678   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, rget(.2), sput(.4), swait(.6), loff(.7), rwait(.8), lon(1));
 679   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, rget(.2), sput(.4), rwait(.6), loff(.7), swait(.8), lon(1));
 680   MAKE_SCENARIO(RDV_ASYNC, 2, WAIT, WAIT, rget(.2), rwait(.4), sput(.6), loff(.7), swait(.8), lon(1));
 681
 682   // ONESIDE SYNC use cases
 683   // All good
 684   MAKE_SCENARIO(ONESIDE_SYNC, 1, END, END, sput(.2));
 685   // Receiver off
 686   MAKE_SCENARIO(ONESIDE_SYNC, 2, PUT, DIE, roff(.1), sput(.2), ron(1));
 687   MAKE_SCENARIO(ONESIDE_SYNC, 2, PUT, DIE, sput(.2), roff(.3), ron(1));
 688   // Sender off
 689   MAKE_SCENARIO(ONESIDE_SYNC, 2, DIE, END, sput(.2), soff(.3), son(1));
 690   // Link off
 691   MAKE_SCENARIO(ONESIDE_SYNC, 2, PUT, END, loff(.1), sput(.2), lon(1));
 692   MAKE_SCENARIO(ONESIDE_SYNC, 2, PUT, END, sput(.2), loff(.3), lon(1));
 693
 694   // ONESIDE ASYNC use cases
 695   // All good
 696   MAKE_SCENARIO(ONESIDE_ASYNC, 2, END, END, sput(.2), swait(.4));
 697   // Receiver off
 698   MAKE_SCENARIO(ONESIDE_ASYNC, 2, PUT, DIE, roff(.1), sput(.2), swait(.4), ron(1));
 699   MAKE_SCENARIO(ONESIDE_ASYNC, 2, WAIT, DIE, sput(.2), roff(.3), swait(.4), ron(1));
 700   MAKE_SCENARIO(ONESIDE_ASYNC, 2, WAIT, DIE, sput(.2), swait(.4), roff(.5), ron(1));
 701   // Sender off
 702   MAKE_SCENARIO(ONESIDE_ASYNC, 2, DIE, END, sput(.2), soff(.3), son(1));
 703   // Link off
 704   MAKE_SCENARIO(ONESIDE_ASYNC, 2, WAIT, END, loff(.1), sput(.2), swait(.4), lon(1));
 705   MAKE_SCENARIO(ONESIDE_ASYNC, 2, WAIT, END, sput(.2), loff(.3), swait(.4), lon(1));
 706   MAKE_SCENARIO(ONESIDE_ASYNC, 2, WAIT, END, sput(.2), swait(.4), loff(.5), lon(1));
 707
 708   XBT_INFO("Will execute %i active scenarios out of %i.", ctx.active, ctx.index);
 709   return ctx.start_time + 1;
 710 }