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