X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d7621ee830197a4b0f44de326bbfe4397f0e1d6a..e4e4b7da7f6a6d04b659f0aa9c1de8733939096f:/src/surf/network_cm02.cpp diff --git a/src/surf/network_cm02.cpp b/src/surf/network_cm02.cpp index 73e4ba8d9c..54e369e2e3 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. */ @@ -26,13 +26,9 @@ static simgrid::config::Flag cfg_network_solver("network/solver", "Set linear equations solver used by network model", "maxmin", &simgrid::kernel::lmm::System::validate_solver); -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 */ - -/************************************************************************/ -/* 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?}}, */ @@ -44,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}, */ @@ -67,26 +66,71 @@ 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); -} +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 { +static simgrid::config::Flag + network_optim_opt("network/optim", "Optimization algorithm to use for network resources. ", "Lazy", + + std::map>({ + {"Lazy", "Lazy action management (partial invalidation in lmm + heap in action remaining)."}, + {"Full", "Full update of remaining and variables. Slow but may be useful when debugging."}, + }), + + [](std::string const&) { + xbt_assert(_sg_cfg_init_status < 2, + "Cannot change the optimization algorithm after the initialization"); + }); NetworkCm02Model::NetworkCm02Model(const std::string& name) : NetworkModel(name) { - std::string optim = config::get_value("network/optim"); - bool select = config::get_value("network/maxmin-selective-update"); + bool select = config::get_value("network/maxmin-selective-update"); - if (optim == "Lazy") { + if (network_optim_opt == "Lazy") { set_update_algorithm(Model::UpdateAlgo::LAZY); xbt_assert(select || config::is_default("network/maxmin-selective-update"), "You cannot disable network selective update when using the lazy update mechanism"); @@ -101,40 +145,6 @@ NetworkCm02Model::NetworkCm02Model(const std::string& name) : NetworkModel(name) loopback_->get_iface()->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; -} - StandardLinkImpl* NetworkCm02Model::create_link(const std::string& name, const std::vector& bandwidths) { xbt_assert(bandwidths.size() == 1, "Non-WIFI links must use only 1 bandwidth."); @@ -338,24 +348,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); @@ -379,18 +385,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)); @@ -409,16 +417,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; @@ -433,10 +442,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(); }); } @@ -444,7 +453,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); @@ -498,9 +507,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; @@ -530,20 +539,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_); }