X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/919a006452206f935fe271499ab68eb8cf875854..a48a21761805fa35836d89b496ccc7efb90f7bb4:/src/surf/network_cm02.cpp diff --git a/src/surf/network_cm02.cpp b/src/surf/network_cm02.cpp index fef1236760..57a7efd448 100644 --- a/src/surf/network_cm02.cpp +++ b/src/surf/network_cm02.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2022. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2013-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. */ @@ -19,13 +19,16 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(res_network); -double sg_latency_factor = 1.0; /* default value; can be set by model or from command line */ -double sg_bandwidth_factor = 1.0; /* default value; can be set by model or from command line */ -double sg_weight_S_parameter = 0.0; /* default value; can be set by model or from command line */ +/*********** + * Options * + ***********/ +static simgrid::config::Flag cfg_network_solver("network/solver", + "Set linear equations solver used by network model", + "maxmin", &simgrid::kernel::lmm::System::validate_solver); -/************************************************************************/ -/* New model based on optimizations discussed during Pedro Velho's thesis*/ -/************************************************************************/ +/******************************************************************************/ +/* Network model based on optimizations discussed during Pedro Velho's thesis */ +/******************************************************************************/ /* @techreport{VELHO:2011:HAL-00646896:1, */ /* url = {http://hal.inria.fr/hal-00646896/en/}, */ /* title = {{Flow-level network models: have we reached the limits?}}, */ @@ -37,21 +40,24 @@ double sg_weight_S_parameter = 0.0; /* default value; can be set by model or fro /* month = Nov, */ /* pdf = {http://hal.inria.fr/hal-00646896/PDF/rr-validity.pdf}, */ /* } */ -void surf_network_model_init_LegrandVelho() -{ - auto net_model = std::make_shared("Network_LegrandVelho"); - auto* engine = simgrid::kernel::EngineImpl::get_instance(); - engine->add_model(net_model); - engine->get_netzone_root()->set_network_model(net_model); - - simgrid::config::set_default("network/latency-factor", 13.01); - simgrid::config::set_default("network/bandwidth-factor", 0.97); - simgrid::config::set_default("network/weight-S", 20537); -} - -/***************************************************************************/ -/* The nice TCP sharing model designed by Loris Marchal and Henri Casanova */ -/***************************************************************************/ +SIMGRID_REGISTER_NETWORK_MODEL( + LV08, + "Realistic network analytic model (slow-start modeled by multiplying latency by 13.01, bandwidth by .97; " + "bottleneck sharing uses a payload of S=20537 for evaluating RTT). ", + []() { + auto net_model = std::make_shared("Network_LegrandVelho"); + auto* engine = simgrid::kernel::EngineImpl::get_instance(); + engine->add_model(net_model); + engine->get_netzone_root()->set_network_model(net_model); + + simgrid::config::set_default("network/latency-factor", "13.01"); + simgrid::config::set_default("network/bandwidth-factor", "0.97"); + simgrid::config::set_default("network/weight-S", 20537); + }); + +/****************************************************************************/ +/* The older TCP sharing model designed by Loris Marchal and Henri Casanova */ +/****************************************************************************/ /* @TechReport{ rr-lip2002-40, */ /* author = {Henri Casanova and Loris Marchal}, */ /* institution = {LIP}, */ @@ -60,21 +66,53 @@ void surf_network_model_init_LegrandVelho() /* month = {oct}, */ /* year = {2002} */ /* } */ -void surf_network_model_init_CM02() -{ - simgrid::config::set_default("network/latency-factor", 1.0); - simgrid::config::set_default("network/bandwidth-factor", 1.0); - simgrid::config::set_default("network/weight-S", 0.0); - - auto net_model = std::make_shared("Network_CM02"); - auto* engine = simgrid::kernel::EngineImpl::get_instance(); - engine->add_model(net_model); - engine->get_netzone_root()->set_network_model(net_model); -} - -namespace simgrid { -namespace kernel { -namespace resource { +SIMGRID_REGISTER_NETWORK_MODEL( + CM02, + "Legacy network analytic model (Very similar to LV08, but without corrective factors. The timings of " + "small messages are thus poorly modeled).", + []() { + simgrid::config::set_default("network/latency-factor", "1.0"); + simgrid::config::set_default("network/bandwidth-factor", "1.0"); + simgrid::config::set_default("network/weight-S", 0.0); + + auto net_model = std::make_shared("Network_CM02"); + auto* engine = simgrid::kernel::EngineImpl::get_instance(); + engine->add_model(net_model); + engine->get_netzone_root()->set_network_model(net_model); + }); + +/********************************************************************/ +/* Model based on LV08 and experimental results of MPI ping-pongs */ +/********************************************************************/ +/* @Inproceedings{smpi_ipdps, */ +/* author={Pierre-Nicolas Clauss and Mark Stillwell and Stéphane Genaud and Frédéric Suter and Henri Casanova and + * Martin Quinson}, */ +/* title={Single Node On-Line Simulation of {MPI} Applications with SMPI}, */ +/* booktitle={25th IEEE International Parallel and Distributed Processing Symposium (IPDPS'11)}, */ +/* address={Anchorage (Alaska) USA}, */ +/* month=may, */ +/* year={2011} */ +/* } */ +SIMGRID_REGISTER_NETWORK_MODEL( + SMPI, + "Realistic network model specifically tailored for HPC settings (accurate modeling of slow start with " + "correction factors on three intervals: < 1KiB, < 64 KiB, >= 64 KiB)", + []() { + auto net_model = std::make_shared("Network_SMPI"); + auto* engine = simgrid::kernel::EngineImpl::get_instance(); + engine->add_model(net_model); + engine->get_netzone_root()->set_network_model(net_model); + + simgrid::config::set_default("network/weight-S", 8775); + simgrid::config::set_default("network/bandwidth-factor", + "65472:0.940694;15424:0.697866;9376:0.58729;5776:1.08739;3484:0.77493;" + "1426:0.608902;732:0.341987;257:0.338112;0:0.812084"); + simgrid::config::set_default("network/latency-factor", + "65472:11.6436;15424:3.48845;9376:2.59299;5776:2.18796;3484:1.88101;" + "1426:1.61075;732:1.9503;257:1.95341;0:2.01467"); + }); + +namespace simgrid::kernel::resource { NetworkCm02Model::NetworkCm02Model(const std::string& name) : NetworkModel(name) { @@ -88,46 +126,12 @@ NetworkCm02Model::NetworkCm02Model(const std::string& name) : NetworkModel(name) select = true; } - set_maxmin_system(lmm::System::build("maxmin", select)); + set_maxmin_system(lmm::System::build(cfg_network_solver.get(), select)); - loopback_ = create_link("__loopback__", {config::get_value("network/loopback-bw")}); + loopback_.reset(create_link("__loopback__", {config::get_value("network/loopback-bw")})); loopback_->set_sharing_policy(s4u::Link::SharingPolicy::FATPIPE, {}); loopback_->set_latency(config::get_value("network/loopback-lat")); - loopback_->seal(); -} - -void NetworkCm02Model::check_lat_factor_cb() -{ - if (not simgrid::config::is_default("network/latency-factor")) { - throw std::invalid_argument( - "NetworkModelIntf: Cannot mix network/latency-factor and callback configuration. Choose only one of them."); - } -} - -void NetworkCm02Model::check_bw_factor_cb() -{ - if (not simgrid::config::is_default("network/bandwidth-factor")) { - throw std::invalid_argument( - "NetworkModelIntf: Cannot mix network/bandwidth-factor and callback configuration. Choose only one of them."); - } -} - -void NetworkCm02Model::set_lat_factor_cb(const std::function& cb) -{ - if (not cb) - throw std::invalid_argument("NetworkModelIntf: Invalid callback"); - check_lat_factor_cb(); - - lat_factor_cb_ = cb; -} - -void NetworkCm02Model::set_bw_factor_cb(const std::function& cb) -{ - if (not cb) - throw std::invalid_argument("NetworkModelIntf: Invalid callback"); - check_bw_factor_cb(); - - bw_factor_cb_ = cb; + loopback_->get_iface()->seal(); } StandardLinkImpl* NetworkCm02Model::create_link(const std::string& name, const std::vector& bandwidths) @@ -175,13 +179,10 @@ void NetworkCm02Model::update_actions_state_full(double /*now*/, double delta) auto& action = static_cast(*it); ++it; // increment iterator here since the following calls to action.finish() may invalidate it XBT_DEBUG("Something happened to action %p", &action); - double deltap = delta; if (action.latency_ > 0) { - if (action.latency_ > deltap) { - double_update(&action.latency_, deltap, sg_surf_precision); - deltap = 0.0; + if (action.latency_ > delta) { + double_update(&action.latency_, delta, sg_surf_precision); } else { - double_update(&deltap, action.latency_, sg_surf_precision); action.latency_ = 0.0; } if (action.latency_ <= 0.0 && not action.is_suspended()) @@ -223,19 +224,21 @@ void NetworkCm02Model::comm_action_expand_constraints(const s4u::Host* src, cons /* WI-FI links needs special treatment, do it here */ if (src_wifi_link != nullptr) { - /* In case of 0Mbps data rate, don't consider it in the LMM */ if (src_wifi_link->get_host_rate(src) > 0) get_maxmin_system()->expand(src_wifi_link->get_constraint(), action->get_variable(), 1.0 / src_wifi_link->get_host_rate(src)); - else + else { get_maxmin_system()->update_variable_penalty(action->get_variable(), 0); + } } + if (dst_wifi_link != nullptr) { if (dst_wifi_link->get_host_rate(dst) > 0) get_maxmin_system()->expand(dst_wifi_link->get_constraint(), action->get_variable(), 1.0 / dst_wifi_link->get_host_rate(dst)); - else + else { get_maxmin_system()->update_variable_penalty(action->get_variable(), 0); + } } for (auto const* link : route) { @@ -256,9 +259,6 @@ void NetworkCm02Model::comm_action_expand_constraints(const s4u::Host* src, cons if (link->get_sharing_policy() != s4u::Link::SharingPolicy::WIFI) get_maxmin_system()->expand(link->get_constraint(), action->get_variable(), .05); } - // Change concurrency_share here, if you want that cross-traffic is included in the SURF concurrency - // (You would also have to change simgrid::kernel::lmm::Element::get_concurrency()) - // action->getVariable()->set_concurrency_share(2) } } @@ -337,24 +337,20 @@ bool NetworkCm02Model::comm_get_route_info(const s4u::Host* src, const s4u::Host void NetworkCm02Model::comm_action_set_bounds(const s4u::Host* src, const s4u::Host* dst, double size, NetworkCm02Action* action, const std::vector& route, const std::unordered_set& netzones, - double rate) + double rate) const { std::vector s4u_route; std::unordered_set s4u_netzones; /* transform data to user structures if necessary */ - if (lat_factor_cb_ || bw_factor_cb_) { + if (has_network_factor_cb()) { std::for_each(route.begin(), route.end(), [&s4u_route](StandardLinkImpl* l) { s4u_route.push_back(l->get_iface()); }); std::for_each(netzones.begin(), netzones.end(), [&s4u_netzones](kernel::routing::NetZoneImpl* n) { s4u_netzones.insert(n->get_iface()); }); } - double bw_factor; - if (bw_factor_cb_) { - bw_factor = bw_factor_cb_(size, src, dst, s4u_route, s4u_netzones); - } else { - bw_factor = get_bandwidth_factor(size); - } + + double bw_factor = get_bandwidth_factor(size, src, dst, s4u_route, s4u_netzones); xbt_assert(bw_factor != 0, "Invalid param for comm %s -> %s. Bandwidth factor cannot be 0", src->get_cname(), dst->get_cname()); action->set_rate_factor(bw_factor); @@ -378,18 +374,20 @@ void NetworkCm02Model::comm_action_set_bounds(const s4u::Host* src, const s4u::H action->set_user_bound(bandwidth_bound); action->lat_current_ = action->latency_; - if (lat_factor_cb_) { - action->latency_ *= lat_factor_cb_(size, src, dst, s4u_route, s4u_netzones); - } else { - action->latency_ *= get_latency_factor(size); - } + action->latency_ *= get_latency_factor(size, src, dst, s4u_route, s4u_netzones); } void NetworkCm02Model::comm_action_set_variable(NetworkCm02Action* action, const std::vector& route, - const std::vector& back_route) + const std::vector& back_route, bool streamed) { size_t constraints_per_variable = route.size(); constraints_per_variable += back_route.size(); + if (streamed) { + // setting the number of variable for a communication action involved in a I/O streaming operation + // requires to reserve some extra space for the constraints related to the source disk (global and read + // bandwidth) and destination disk (global and write bandwidth). We thus add 4 constraints. + constraints_per_variable += 4; + } if (action->latency_ > 0) { action->set_variable(get_maxmin_system()->variable_new(action, 0.0, -1.0, constraints_per_variable)); @@ -408,16 +406,17 @@ void NetworkCm02Model::comm_action_set_variable(NetworkCm02Action* action, const /* after setting the variable, update the bounds depending on user configuration */ if (action->get_user_bound() < 0) { get_maxmin_system()->update_variable_bound( - action->get_variable(), (action->lat_current_ > 0) ? cfg_tcp_gamma / (2.0 * action->lat_current_) : -1.0); + action->get_variable(), + (action->lat_current_ > 0 && cfg_tcp_gamma > 0) ? cfg_tcp_gamma / (2.0 * action->lat_current_) : -1.0); } else { get_maxmin_system()->update_variable_bound( - action->get_variable(), (action->lat_current_ > 0) + action->get_variable(), (action->lat_current_ > 0 && cfg_tcp_gamma > 0) ? std::min(action->get_user_bound(), cfg_tcp_gamma / (2.0 * action->lat_current_)) : action->get_user_bound()); } } -Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate) +Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate, bool streamed) { double latency = 0.0; std::vector back_route; @@ -432,10 +431,10 @@ Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double siz action->sharing_penalty_ = latency; action->latency_ = latency; - if (sg_weight_S_parameter > 0) { + if (cfg_weight_S_parameter > 0) { action->sharing_penalty_ = std::accumulate(route.begin(), route.end(), action->sharing_penalty_, [](double total, StandardLinkImpl* const& link) { - return total + sg_weight_S_parameter / link->get_bandwidth(); + return total + cfg_weight_S_parameter / link->get_bandwidth(); }); } @@ -443,7 +442,7 @@ Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double siz comm_action_set_bounds(src, dst, size, action, route, netzones, rate); /* creating the maxmin variable associated to this action */ - comm_action_set_variable(action, route, back_route); + comm_action_set_variable(action, route, back_route, streamed); /* expand maxmin system to consider this communication in bw constraint for each link in route and back_route */ comm_action_expand_constraints(src, dst, action, route, back_route); @@ -497,9 +496,9 @@ void NetworkCm02Link::set_bandwidth(double value) StandardLinkImpl::on_bandwidth_change(); - if (sg_weight_S_parameter > 0) { - double delta = sg_weight_S_parameter / (bandwidth_.peak * bandwidth_.scale) - - sg_weight_S_parameter / (old_peak * bandwidth_.scale); + if (NetworkModel::cfg_weight_S_parameter > 0) { + double delta = NetworkModel::cfg_weight_S_parameter / (bandwidth_.peak * bandwidth_.scale) - + NetworkModel::cfg_weight_S_parameter / (old_peak * bandwidth_.scale); const kernel::lmm::Element* elem = nullptr; const kernel::lmm::Element* nextelem = nullptr; @@ -529,20 +528,21 @@ void NetworkCm02Link::set_latency(double value) auto* action = static_cast(var->get_id()); action->lat_current_ += delta; action->sharing_penalty_ += delta; - if (action->get_user_bound() < 0) + if (action->get_user_bound() < 0 && NetworkModel::cfg_tcp_gamma > 0) get_model()->get_maxmin_system()->update_variable_bound(action->get_variable(), NetworkModel::cfg_tcp_gamma / (2.0 * action->lat_current_)); - else { + else if (NetworkModel::cfg_tcp_gamma > 0) { get_model()->get_maxmin_system()->update_variable_bound( action->get_variable(), std::min(action->get_user_bound(), NetworkModel::cfg_tcp_gamma / (2.0 * action->lat_current_))); - - if (action->get_user_bound() < NetworkModel::cfg_tcp_gamma / (2.0 * action->lat_current_)) { - XBT_DEBUG("Flow is limited BYBANDWIDTH"); - } else { - XBT_DEBUG("Flow is limited BYLATENCY, latency of flow is %f", action->lat_current_); - } } + if (NetworkModel::cfg_tcp_gamma == 0 || + action->get_user_bound() < NetworkModel::cfg_tcp_gamma / (2.0 * action->lat_current_)) { + XBT_DEBUG("Flow is limited BYBANDWIDTH"); + } else { + XBT_DEBUG("Flow is limited BYLATENCY, latency of flow is %f", action->lat_current_); + } + if (not action->is_suspended()) get_model()->get_maxmin_system()->update_variable_penalty(action->get_variable(), action->sharing_penalty_); } @@ -579,6 +579,4 @@ void NetworkCm02Action::update_remains_lazy(double now) set_last_value(get_rate()); } -} // namespace resource -} // namespace kernel -} // namespace simgrid +} // namespace simgrid::kernel::resource