X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/867621bdf5a110802ee32316ff1456ffafec3cb2..8d0b1f2f1840a16bb9551f1cfd74f2488599f95b:/teshsuite/s4u/comm-fault-scenarios/comm-fault-scenarios.cpp diff --git a/teshsuite/s4u/comm-fault-scenarios/comm-fault-scenarios.cpp b/teshsuite/s4u/comm-fault-scenarios/comm-fault-scenarios.cpp index 2e2b7e9d19..b996076738 100644 --- a/teshsuite/s4u/comm-fault-scenarios/comm-fault-scenarios.cpp +++ b/teshsuite/s4u/comm-fault-scenarios/comm-fault-scenarios.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2021. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2023. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ @@ -39,7 +39,7 @@ constexpr double LinkBandwidth = 1e9; // Bytes/second constexpr double LinkLatency = 1e-6; // Seconds // Constants for application behaviour -constexpr uint64_t MsgSize = LinkBandwidth / 2; +constexpr auto MsgSize = static_cast(LinkBandwidth / 2); /*************************************************************************************************/ @@ -51,9 +51,12 @@ XBT_DECLARE_ENUM_CLASS(CommType, EAGER_SYNC, EAGER_ASYNC, EAGER_INIT, RDV_SYNC, XBT_DECLARE_ENUM_CLASS(Action, SLEEP, PUT, GET, START, WAIT, DIE, END); struct Step { + XBT_DECLARE_ENUM_CLASS(Type, STATE, ACTION); + XBT_DECLARE_ENUM_CLASS(Entity, LNK, SND, RCV); + double rel_time; // Time relative to Scenario startTime - enum { STATE, ACTION } type; - enum { LNK, SND, RCV } entity; + Type type; + Entity entity; Action action_type; bool new_state; }; @@ -74,20 +77,9 @@ static std::string to_string(const Scenario& s) ss << "#" << s.index << "[" << s.start_time << "s," << s.start_time + s.duration << "s[: (" << to_c_str(s.type); ss << ") Expected: S:" << to_c_str(s.snd_expected) << " R:" << to_c_str(s.rcv_expected) << " Steps: "; for (const Step& step : s.steps) { - ss << "+" << step.rel_time << "s:"; - switch (step.entity) { - case Step::LNK: - ss << "LNK"; - break; - case Step::SND: - ss << "SND"; - break; - case Step::RCV: - ss << "RCV"; - break; - } + ss << "+" << step.rel_time << "s:" << Step::to_c_str(step.entity); - if (step.type == Step::STATE) { + if (step.type == Step::Type::STATE) { ss << "->"; if (step.new_state) ss << "ON"; @@ -98,9 +90,14 @@ static std::string to_string(const Scenario& s) } ss << " "; } - return ss.str().c_str(); + return ss.str(); } +struct MBoxes { + sg4::Mailbox* eager; + sg4::Mailbox* rdv; +}; + struct ScenarioContext { int index; int active; @@ -112,44 +109,43 @@ struct ScenarioContext { std::vector scenarios; }; -sg4::Mailbox* mbox_eager = nullptr; -sg4::Mailbox* mbox_rdv = nullptr; - class SendAgent { - static int run_; static size_t scenario_; int id_; sg4::Host* other_host_; + const MBoxes& mbox_; const ScenarioContext& ctx_; - sg4::CommPtr do_put(CommType type, double& send_value) + sg4::CommPtr do_put(CommType type, double& send_value) const { switch (type) { case CommType::EAGER_SYNC: - mbox_eager->put(&send_value, MsgSize); + mbox_.eager->put(&send_value, MsgSize); return nullptr; case CommType::EAGER_ASYNC: - return mbox_eager->put_async(&send_value, MsgSize); + return mbox_.eager->put_async(&send_value, MsgSize); case CommType::EAGER_INIT: - return mbox_eager->put_init(&send_value, MsgSize); + return mbox_.eager->put_init(&send_value, MsgSize); case CommType::RDV_SYNC: - mbox_rdv->put(&send_value, MsgSize); + mbox_.rdv->put(&send_value, MsgSize); return nullptr; case CommType::RDV_ASYNC: - return mbox_rdv->put_async(&send_value, MsgSize); + return mbox_.rdv->put_async(&send_value, MsgSize); case CommType::RDV_INIT: - return mbox_rdv->put_init(&send_value, MsgSize); + return mbox_.rdv->put_init(&send_value, MsgSize); case CommType::ONESIDE_SYNC: sg4::Comm::sendto(sg4::this_actor::get_host(), other_host_, MsgSize); return nullptr; case CommType::ONESIDE_ASYNC: return sg4::Comm::sendto_async(sg4::this_actor::get_host(), other_host_, MsgSize); + default: + break; } - return nullptr; + DIE_IMPOSSIBLE; } - void send_message(const Scenario& s) + void send_message(const Scenario& s) const { std::string scenario_string = to_string(s); XBT_DEBUG("Will try: %s", scenario_string.c_str()); @@ -161,23 +157,25 @@ class SendAgent { size_t step_index = 0; sg4::this_actor::sleep_until(s.start_time); // Make sure we have a clean slate - xbt_assert(not mbox_eager->listen(), "Eager mailbox should be empty when starting a test"); - xbt_assert(not mbox_rdv->listen(), "RDV mailbox should be empty when starting a test"); - for (; step_index < s.steps.size(); step_index++) { - const Step& step = s.steps[step_index]; - if (step.entity != Step::SND || step.type != Step::ACTION) - continue; - try { + xbt_assert(not mbox_.eager->listen(), "Eager mailbox should be empty when starting a test"); + xbt_assert(not mbox_.rdv->listen(), "RDV mailbox should be empty when starting a test"); + + Action current_action; + try { + for (; step_index < s.steps.size(); step_index++) { + const Step& step = s.steps[step_index]; + if (step.entity != Step::Entity::SND || step.type != Step::Type::ACTION) + continue; + + current_action = Action::SLEEP; sg4::this_actor::sleep_until(s.start_time + step.rel_time); - } catch (std::exception& e) { - XBT_DEBUG("During Sleep, failed to send message because of a %s exception (%s)", typeid(e).name(), e.what()); - break; - } - // Check if the other host is still OK. - if (not other_host_->is_on()) - break; - // Perform the action - try { + + // Check if the other host is still OK. + if (not other_host_->is_on()) + break; + + // Perform the action + current_action = step.action_type; switch (step.action_type) { case Action::PUT: comm = do_put(s.type, send_value); @@ -191,21 +189,20 @@ class SendAgent { default: xbt_die("Not a valid action for SND"); } - } catch (std::exception& e) { - XBT_DEBUG("During %s, failed to send message because of a %s exception (%s)", to_c_str(step.action_type), - typeid(e).name(), e.what()); - break; } + } catch (const simgrid::Exception& e) { + XBT_DEBUG("During %s, failed to send message because of a %s exception (%s)", to_c_str(current_action), + typeid(e).name(), e.what()); } try { sg4::this_actor::sleep_until(end_time); - } catch (std::exception& e) { + } catch (const simgrid::Exception& e) { XBT_DEBUG("During Sleep, failed to send message because of a %s exception (%s)", typeid(e).name(), e.what()); } Action outcome = Action::END; if (step_index < s.steps.size()) { const Step& step = s.steps[step_index]; - assert(step.entity == Step::SND && step.type == Step::ACTION); + assert(step.entity == Step::Entity::SND && step.type == Step::Type::ACTION); outcome = step.action_type; } if (outcome != expected) { @@ -214,20 +211,20 @@ class SendAgent { XBT_DEBUG("OK: %s", scenario_string.c_str()); } sg4::this_actor::sleep_until(end_time); - xbt_assert(not mbox_eager->listen(), "Mailbox should not have ongoing communication!"); - xbt_assert(not mbox_rdv->listen(), "Mailbox should not have ongoing communication!"); + xbt_assert(not mbox_.eager->listen(), "Mailbox should not have ongoing communication!"); + xbt_assert(not mbox_.rdv->listen(), "Mailbox should not have ongoing communication!"); } public: - explicit SendAgent(int id, sg4::Host* other_host, const ScenarioContext& ctx) - : id_(id), other_host_(other_host), ctx_(ctx) + explicit SendAgent(int id, sg4::Host* other_host, const MBoxes& mbox, const ScenarioContext& ctx) + : id_(id), other_host_(other_host), mbox_(mbox), ctx_(ctx) { } - void operator()() + void operator()() const { run_++; - XBT_DEBUG("Host %i starts run %i and scenario %lu.", id_, run_, scenario_); + XBT_DEBUG("Host %i starts run %i and scenario %zu.", id_, run_, scenario_); while (scenario_ < ctx_.scenarios.size()) { const Scenario& s = ctx_.scenarios[scenario_]; scenario_++; @@ -242,38 +239,40 @@ size_t SendAgent::scenario_ = 0; /*************************************************************************************************/ class ReceiveAgent { - static int run_; static size_t scenario_; int id_; sg4::Host* other_host_; + const MBoxes& mbox_; const ScenarioContext& ctx_; - sg4::CommPtr do_get(CommType type, double*& receive_ptr) + sg4::CommPtr do_get(CommType type, double*& receive_ptr) const { switch (type) { case CommType::EAGER_SYNC: - receive_ptr = mbox_eager->get(); + receive_ptr = mbox_.eager->get(); return nullptr; case CommType::EAGER_ASYNC: - return mbox_eager->get_async(&receive_ptr); + return mbox_.eager->get_async(&receive_ptr); case CommType::EAGER_INIT: - return mbox_eager->get_init()->set_dst_data((void**)(&receive_ptr)); + return mbox_.eager->get_init()->set_dst_data((void**)(&receive_ptr)); case CommType::RDV_SYNC: - receive_ptr = mbox_rdv->get(); + receive_ptr = mbox_.rdv->get(); return nullptr; case CommType::RDV_ASYNC: - return mbox_rdv->get_async(&receive_ptr); + return mbox_.rdv->get_async(&receive_ptr); case CommType::RDV_INIT: - return mbox_rdv->get_init()->set_dst_data((void**)(&receive_ptr)); + return mbox_.rdv->get_init()->set_dst_data((void**)(&receive_ptr)); case CommType::ONESIDE_SYNC: case CommType::ONESIDE_ASYNC: xbt_die("No get in One Sided comunications!"); + default: + break; } - return nullptr; + DIE_IMPOSSIBLE; } - void receive_message(const Scenario& s) + void receive_message(const Scenario& s) const { sg4::CommPtr comm = nullptr; CommType type = s.type; @@ -283,23 +282,23 @@ class ReceiveAgent { size_t step_index = 0; sg4::this_actor::sleep_until(s.start_time); // Make sure we have a clean slate - xbt_assert(not mbox_eager->listen(), "Eager mailbox should be empty when starting a test"); - xbt_assert(not mbox_rdv->listen(), "RDV mailbox should be empty when starting a test"); - for (; step_index < s.steps.size(); step_index++) { - const Step& step = s.steps[step_index]; - if (step.entity != Step::RCV || step.type != Step::ACTION) - continue; - try { + xbt_assert(not mbox_.eager->listen(), "Eager mailbox should be empty when starting a test"); + xbt_assert(not mbox_.rdv->listen(), "RDV mailbox should be empty when starting a test"); + + Action current_action; + try { + for (; step_index < s.steps.size(); step_index++) { + const Step& step = s.steps[step_index]; + if (step.entity != Step::Entity::RCV || step.type != Step::Type::ACTION) + continue; + + current_action = Action::SLEEP; sg4::this_actor::sleep_until(s.start_time + step.rel_time); - } catch (std::exception& e) { - XBT_DEBUG("During Sleep, failed to receive message because of a %s exception (%s)", typeid(e).name(), e.what()); - break; - } - // Check if the other host is still OK. - if (not other_host_->is_on()) - break; - // Perform the action - try { + + // Check if the other host is still OK. + if (not other_host_->is_on()) + break; + // Perform the action switch (step.action_type) { case Action::GET: comm = do_get(type, receive_ptr); @@ -313,22 +312,21 @@ class ReceiveAgent { default: xbt_die("Not a valid action for RCV"); } - } catch (std::exception& e) { - XBT_DEBUG("During %s, failed to receive message because of a %s exception (%s)", to_c_str(step.action_type), - typeid(e).name(), e.what()); - break; } + } catch (const simgrid::Exception& e) { + XBT_DEBUG("During %s, failed to receive message because of a %s exception (%s)", to_c_str(current_action), + typeid(e).name(), e.what()); } try { sg4::this_actor::sleep_until(end_time - .1); - } catch (std::exception& e) { + } catch (const simgrid::Exception& e) { XBT_DEBUG("During Sleep, failed to send message because of a %s exception (%s)", typeid(e).name(), e.what()); } Action outcome = Action::END; std::string scenario_string = to_string(s); if (step_index < s.steps.size()) { const Step& step = s.steps[step_index]; - assert(step.entity == Step::RCV && step.type == Step::ACTION); + assert(step.entity == Step::Entity::RCV && step.type == Step::Type::ACTION); outcome = step.action_type; } else if (s.type != CommType::ONESIDE_SYNC && s.type != CommType::ONESIDE_ASYNC) { // One sided / detached operations do not actually transfer anything @@ -345,20 +343,20 @@ class ReceiveAgent { XBT_DEBUG("OK: %s", scenario_string.c_str()); } sg4::this_actor::sleep_until(end_time); - xbt_assert(not mbox_eager->listen(), "Mailbox should not have ongoing communication!"); - xbt_assert(not mbox_rdv->listen(), "Mailbox should not have ongoing communication!"); + xbt_assert(not mbox_.eager->listen(), "Mailbox should not have ongoing communication!"); + xbt_assert(not mbox_.rdv->listen(), "Mailbox should not have ongoing communication!"); } public: - explicit ReceiveAgent(int id, sg4::Host* other_host, const ScenarioContext& ctx) - : id_(id), other_host_(other_host), ctx_(ctx) + explicit ReceiveAgent(int id, sg4::Host* other_host, const MBoxes& mbox, const ScenarioContext& ctx) + : id_(id), other_host_(other_host), mbox_(mbox), ctx_(ctx) { } - void operator()() + void operator()() const { run_++; - XBT_DEBUG("Host %i starts run %i and scenario %lu.", id_, run_, scenario_); - mbox_eager->set_receiver(sg4::Actor::self()); + XBT_DEBUG("Host %i starts run %i and scenario %zu.", id_, run_, scenario_); + mbox_.eager->set_receiver(sg4::Actor::self()); while (scenario_ < ctx_.scenarios.size()) { const Scenario& s = ctx_.scenarios[scenario_]; scenario_++; @@ -370,21 +368,7 @@ public: int ReceiveAgent::run_ = 0; size_t ReceiveAgent::scenario_ = 0; -static void on_host_state_change(sg4::Host const& host) -{ - XBT_DEBUG("Host %s is now %s", host.get_cname(), host.is_on() ? "ON " : "OFF"); - if (not host.is_on()) { - mbox_eager->clear(); - mbox_rdv->clear(); - } -} - -static void on_link_state_change(sg4::Link const& link) -{ - XBT_DEBUG("Link %s is now %s", link.get_cname(), link.is_on() ? "ON " : "OFF"); -} - -double build_scenarios(ScenarioContext& ctx); +static double build_scenarios(ScenarioContext& ctx); int main(int argc, char* argv[]) { @@ -393,82 +377,87 @@ int main(int argc, char* argv[]) int previous_index = -1; bool is_range_last = false; for (int i = 1; i < argc; i++) { - if (not strcmp(argv[i], "-")) + if (not strcmp(argv[i], "-")) { is_range_last = true; - else { - int index = atoi(argv[i]); - xbt_assert(index > previous_index); - if (is_range_last) - for (int j = previous_index + 1; j <= index; j++) - ctx.active_indices.push_back(j); - else - ctx.active_indices.push_back(index); - is_range_last = false; - previous_index = index; + continue; } + int index = atoi(argv[i]); + xbt_assert(index > previous_index); + if (is_range_last) + for (int j = previous_index + 1; j <= index; j++) + ctx.active_indices.push_back(j); + else + ctx.active_indices.push_back(index); + is_range_last = false; + previous_index = index; } double end_time = build_scenarios(ctx); XBT_INFO("Will run for %f seconds", end_time); - mbox_eager = e.mailbox_by_name_or_create("eager"); - mbox_rdv = e.mailbox_by_name_or_create("rdv"); + MBoxes mbox; + mbox.eager = e.mailbox_by_name_or_create("eager"); + mbox.rdv = e.mailbox_by_name_or_create("rdv"); sg4::NetZone* zone = sg4::create_full_zone("Top"); pr::Profile* profile_sender = pr::ProfileBuilder::from_string("sender_profile", ctx.sender_profile.str(), 0); sg4::Host* sender_host = zone->create_host("senderHost", HostComputePower)->set_state_profile(profile_sender)->seal(); pr::Profile* profile_receiver = pr::ProfileBuilder::from_string("receiver_profile", ctx.receiver_profile.str(), 0); sg4::Host* receiver_host = zone->create_host("receiverHost", HostComputePower)->set_state_profile(profile_receiver)->seal(); - sg4::ActorPtr sender = sg4::Actor::create("sender", sender_host, SendAgent(0, receiver_host, ctx)); + sg4::ActorPtr sender = sg4::Actor::create("sender", sender_host, SendAgent(0, receiver_host, mbox, ctx)); sender->set_auto_restart(true); - sg4::ActorPtr receiver = sg4::Actor::create("receiver", receiver_host, ReceiveAgent(1, sender_host, ctx)); + sg4::ActorPtr receiver = sg4::Actor::create("receiver", receiver_host, ReceiveAgent(1, sender_host, mbox, ctx)); receiver->set_auto_restart(true); pr::Profile* profile_link = pr::ProfileBuilder::from_string("link_profile", ctx.link_profile.str(), 0); - sg4::Link* link = + sg4::Link const* link = zone->create_link("link", LinkBandwidth)->set_latency(LinkLatency)->set_state_profile(profile_link)->seal(); - zone->add_route(sender_host->get_netpoint(), receiver_host->get_netpoint(), nullptr, nullptr, - {sg4::LinkInRoute{link}}, false); + zone->add_route(sender_host, receiver_host, {link}); zone->seal(); - sg4::Host::on_state_change.connect(on_host_state_change); - sg4::Link::on_state_change_cb(on_link_state_change); + + sg4::Host::on_onoff_cb([mbox](sg4::Host const& host) { + XBT_DEBUG("Host %s is now %s", host.get_cname(), host.is_on() ? "ON " : "OFF"); + if (not host.is_on()) { + mbox.eager->clear(); + mbox.rdv->clear(); + } + }); + + sg4::Link::on_onoff_cb( + [](sg4::Link const& lnk) { XBT_DEBUG("Link %s is now %s", lnk.get_cname(), lnk.is_on() ? "ON " : "OFF"); }); + e.run_until(end_time); // Make sure we have a clean slate - xbt_assert(not mbox_eager->listen(), "Eager mailbox should be empty in the end"); - xbt_assert(not mbox_rdv->listen(), "RDV mailbox should be empty in the end"); + xbt_assert(not mbox.eager->listen(), "Eager mailbox should be empty in the end"); + xbt_assert(not mbox.rdv->listen(), "RDV mailbox should be empty in the end"); XBT_INFO("Done."); return 0; } -static void addStateEvent(std::ostream& out, double date, bool isOn) -{ - if (isOn) - out << date << " 1\n"; - else - out << date << " 0\n"; -} - static void prepareScenario(ScenarioContext& ctx, CommType type, double duration, Action sender_expected, - Action receiver_expected, std::vector steps) + Action receiver_expected, const std::vector& steps) { if (std::find(ctx.active_indices.begin(), ctx.active_indices.end(), ctx.index) != ctx.active_indices.end()) { // Update fault profiles - for (Step& step : steps) { + for (const Step& step : steps) { assert(step.rel_time < duration); - if (step.type != Step::STATE) + if (step.type != Step::Type::STATE) continue; int val = step.new_state ? 1 : 0; switch (step.entity) { - case Step::SND: + case Step::Entity::SND: ctx.sender_profile << ctx.start_time + step.rel_time << " " << val << std::endl; break; - case Step::RCV: + case Step::Entity::RCV: ctx.receiver_profile << ctx.start_time + step.rel_time << " " << val << std::endl; break; - case Step::LNK: + case Step::Entity::LNK: ctx.link_profile << ctx.start_time + step.rel_time << " " << val << std::endl; break; + default: + DIE_IMPOSSIBLE; } } - ctx.scenarios.push_back({type, ctx.start_time, duration, sender_expected, receiver_expected, steps, ctx.index}); + Scenario scen{type, ctx.start_time, duration, sender_expected, receiver_expected, steps, ctx.index}; + ctx.scenarios.push_back(scen); ctx.active++; } ctx.index++; @@ -484,48 +473,48 @@ static void prepareScenario(ScenarioContext& ctx, CommType type, double duration // Link static Step loff(double rel_time) { - return {rel_time, Step::STATE, Step::LNK, Action::END, false}; + return {rel_time, Step::Type::STATE, Step::Entity::LNK, Action::END, false}; } static Step lon(double rel_time) { - return {rel_time, Step::STATE, Step::LNK, Action::END, true}; + return {rel_time, Step::Type::STATE, Step::Entity::LNK, Action::END, true}; } // Sender static Step soff(double rel_time) { - return {rel_time, Step::STATE, Step::SND, Action::END, false}; + return {rel_time, Step::Type::STATE, Step::Entity::SND, Action::END, false}; } static Step son(double rel_time) { - return {rel_time, Step::STATE, Step::SND, Action::END, true}; + return {rel_time, Step::Type::STATE, Step::Entity::SND, Action::END, true}; } static Step sput(double rel_time) { - return {rel_time, Step::ACTION, Step::SND, Action::PUT, false}; + return {rel_time, Step::Type::ACTION, Step::Entity::SND, Action::PUT, false}; } static Step swait(double rel_time) { - return {rel_time, Step::ACTION, Step::SND, Action::WAIT, false}; + return {rel_time, Step::Type::ACTION, Step::Entity::SND, Action::WAIT, false}; } // Receiver static Step roff(double rel_time) { - return {rel_time, Step::STATE, Step::RCV, Action::END, false}; + return {rel_time, Step::Type::STATE, Step::Entity::RCV, Action::END, false}; } static Step ron(double rel_time) { - return {rel_time, Step::STATE, Step::RCV, Action::END, true}; + return {rel_time, Step::Type::STATE, Step::Entity::RCV, Action::END, true}; } static Step rget(double rel_time) { - return {rel_time, Step::ACTION, Step::RCV, Action::GET, false}; + return {rel_time, Step::Type::ACTION, Step::Entity::RCV, Action::GET, false}; } static Step rwait(double rel_time) { - return {rel_time, Step::ACTION, Step::RCV, Action::WAIT, false}; + return {rel_time, Step::Type::ACTION, Step::Entity::RCV, Action::WAIT, false}; } -double build_scenarios(ScenarioContext& ctx) +static double build_scenarios(ScenarioContext& ctx) { ctx.start_time = 0; ctx.index = 0; @@ -718,4 +707,4 @@ double build_scenarios(ScenarioContext& ctx) XBT_INFO("Will execute %i active scenarios out of %i.", ctx.active, ctx.index); return ctx.start_time + 1; -} \ No newline at end of file +}