-/* 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. */
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<std::string> 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*/
engine->add_model(net_model);
engine->get_netzone_root()->set_network_model(net_model);
- simgrid::config::set_default<double>("network/latency-factor", 13.01);
- simgrid::config::set_default<double>("network/bandwidth-factor", 0.97);
+ simgrid::config::set_default<std::string>("network/latency-factor", "13.01");
+ simgrid::config::set_default<std::string>("network/bandwidth-factor", "0.97");
simgrid::config::set_default<double>("network/weight-S", 20537);
}
/* } */
void surf_network_model_init_CM02()
{
- simgrid::config::set_default<double>("network/latency-factor", 1.0);
- simgrid::config::set_default<double>("network/bandwidth-factor", 1.0);
+ simgrid::config::set_default<std::string>("network/latency-factor", "1.0");
+ simgrid::config::set_default<std::string>("network/bandwidth-factor", "1.0");
simgrid::config::set_default<double>("network/weight-S", 0.0);
auto net_model = std::make_shared<simgrid::kernel::resource::NetworkCm02Model>("Network_CM02");
engine->get_netzone_root()->set_network_model(net_model);
}
-namespace simgrid {
-namespace kernel {
-namespace resource {
+/********************************************************************/
+/* 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} */
+/* } */
+void surf_network_model_init_SMPI()
+{
+ auto net_model = std::make_shared<simgrid::kernel::resource::NetworkCm02Model>("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<double>("network/weight-S", 8775);
+ simgrid::config::set_default<std::string>("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<std::string>("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)
{
select = true;
}
- set_maxmin_system(lmm::System::build("maxmin", select));
- loopback_ = create_link("__loopback__", {config::get_value<double>("network/loopback-bw")});
+ set_maxmin_system(lmm::System::build(cfg_network_solver.get(), select));
+
+ loopback_.reset(create_link("__loopback__", {config::get_value<double>("network/loopback-bw")}));
loopback_->set_sharing_policy(s4u::Link::SharingPolicy::FATPIPE, {});
loopback_->set_latency(config::get_value<double>("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<NetworkFactorCb>& 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<NetworkFactorCb>& 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<double>& bandwidths)
auto& action = static_cast<NetworkCm02Action&>(*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())
/* 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) {
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)
}
}
void NetworkCm02Model::comm_action_set_bounds(const s4u::Host* src, const s4u::Host* dst, double size,
NetworkCm02Action* action, const std::vector<StandardLinkImpl*>& route,
const std::unordered_set<kernel::routing::NetZoneImpl*>& netzones,
- double rate)
+ double rate) const
{
std::vector<s4u::Link*> s4u_route;
std::unordered_set<s4u::NetZone*> 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);
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<StandardLinkImpl*>& route,
- const std::vector<StandardLinkImpl*>& back_route)
+ const std::vector<StandardLinkImpl*>& 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));
}
}
-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<StandardLinkImpl*> back_route;
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();
});
}
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);
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;
set_last_value(get_rate());
}
-} // namespace resource
-} // namespace kernel
-} // namespace simgrid
+} // namespace simgrid::kernel::resource
