namespace simgrid {
namespace surf {
-NetworkCm02Model::NetworkCm02Model(kernel::lmm::System* (*make_new_lmm_system)(bool)) : NetworkModel()
+NetworkCm02Model::NetworkCm02Model(kernel::lmm::System* (*make_new_lmm_system)(bool))
+ : NetworkModel(xbt_cfg_get_string("network/optim") == "Full" ? kernel::resource::Model::UpdateAlgo::Full
+ : kernel::resource::Model::UpdateAlgo::Lazy)
{
std::string optim = xbt_cfg_get_string("network/optim");
bool select = xbt_cfg_get_boolean("network/maxmin-selective-update");
- if (optim == "Full") {
- setUpdateMechanism(kernel::resource::Model::UpdateAlgo::Full);
- } else if (optim == "Lazy") {
+ if (optim == "Lazy") {
xbt_assert(select || xbt_cfg_is_default_value("network/maxmin-selective-update"),
"You cannot disable network selective update when using the lazy update mechanism");
select = true;
- setUpdateMechanism(kernel::resource::Model::UpdateAlgo::Lazy);
- } else {
- xbt_die("Unsupported optimization (%s) for this model. Accepted: Full, Lazy.", optim.c_str());
}
set_maxmin_system(make_new_lmm_system(select));
loopback_ = NetworkCm02Model::createLink("__loopback__", 498000000, 0.000015, SURF_LINK_FATPIPE);
-
- if (getUpdateMechanism() == kernel::resource::Model::UpdateAlgo::Lazy)
- get_maxmin_system()->modified_set_ = new kernel::resource::Action::ModifiedSet();
}
LinkImpl* NetworkCm02Model::createLink(const std::string& name, double bandwidth, double latency,
void NetworkCm02Model::update_actions_state_lazy(double now, double /*delta*/)
{
- while (not actionHeapIsEmpty() && double_equals(actionHeapTopDate(), now, sg_surf_precision)) {
+ while (not get_action_heap().empty() && double_equals(actionHeapTopDate(), now, sg_surf_precision)) {
NetworkCm02Action* action = static_cast<NetworkCm02Action*>(actionHeapPop());
XBT_DEBUG("Something happened to action %p", action);
}
// if I am wearing a latency hat
- if (action->get_type() == kernel::resource::Action::Type::LATENCY) {
+ if (action->get_type() == kernel::resource::Action::Type::latency) {
XBT_DEBUG("Latency paid for action %p. Activating", action);
get_maxmin_system()->update_variable_weight(action->get_variable(), action->weight_);
action->heapRemove();
action->set_last_update();
// if I am wearing a max_duration or normal hat
- } else if (action->get_type() == kernel::resource::Action::Type::MAX_DURATION ||
- action->get_type() == kernel::resource::Action::Type::NORMAL) {
+ } else if (action->get_type() == kernel::resource::Action::Type::max_duration ||
+ action->get_type() == kernel::resource::Action::Type::normal) {
// no need to communicate anymore
// assume that flows that reached max_duration have remaining of 0
XBT_DEBUG("Action %p finished", action);
action->weight_ = latency;
action->latency_ = latency;
action->rate_ = rate;
- if (getUpdateMechanism() == kernel::resource::Model::UpdateAlgo::Lazy) {
+ if (get_update_algorithm() == kernel::resource::Model::UpdateAlgo::Lazy) {
action->set_last_update();
}
bandwidth_bound = (bandwidth_bound < 0.0) ? bb : std::min(bandwidth_bound, bb);
}
- action->latCurrent_ = action->latency_;
+ action->lat_current_ = action->latency_;
action->latency_ *= latencyFactor(size);
action->rate_ = bandwidthConstraint(action->rate_, bandwidth_bound, size);
if (action->latency_ > 0) {
action->set_variable(get_maxmin_system()->variable_new(action, 0.0, -1.0, constraints_per_variable));
- if (getUpdateMechanism() == kernel::resource::Model::UpdateAlgo::Lazy) {
+ if (get_update_algorithm() == kernel::resource::Model::UpdateAlgo::Lazy) {
// add to the heap the event when the latency is payed
XBT_DEBUG("Added action (%p) one latency event at date %f", action, action->latency_ + action->get_last_update());
action->heapInsert(action->latency_ + action->get_last_update(), route.empty()
- ? kernel::resource::Action::Type::NORMAL
- : kernel::resource::Action::Type::LATENCY);
+ ? kernel::resource::Action::Type::normal
+ : kernel::resource::Action::Type::latency);
}
} else
action->set_variable(get_maxmin_system()->variable_new(action, 1.0, -1.0, constraints_per_variable));
if (action->rate_ < 0) {
get_maxmin_system()->update_variable_bound(
- action->get_variable(), (action->latCurrent_ > 0) ? sg_tcp_gamma / (2.0 * action->latCurrent_) : -1.0);
+ action->get_variable(), (action->lat_current_ > 0) ? sg_tcp_gamma / (2.0 * action->lat_current_) : -1.0);
} else {
- get_maxmin_system()->update_variable_bound(action->get_variable(),
- (action->latCurrent_ > 0)
- ? std::min(action->rate_, sg_tcp_gamma / (2.0 * action->latCurrent_))
- : action->rate_);
+ get_maxmin_system()->update_variable_bound(
+ action->get_variable(), (action->lat_current_ > 0)
+ ? std::min(action->rate_, sg_tcp_gamma / (2.0 * action->lat_current_))
+ : action->rate_);
}
for (auto const& link : route)
while ((var = constraint()->get_variable_safe(&elem, &nextelem, &numelem))) {
NetworkCm02Action* action = static_cast<NetworkCm02Action*>(var->get_id());
- action->latCurrent_ += delta;
+ action->lat_current_ += delta;
action->weight_ += delta;
if (action->rate_ < 0)
model()->get_maxmin_system()->update_variable_bound(action->get_variable(),
- sg_tcp_gamma / (2.0 * action->latCurrent_));
+ sg_tcp_gamma / (2.0 * action->lat_current_));
else {
model()->get_maxmin_system()->update_variable_bound(
- action->get_variable(), std::min(action->rate_, sg_tcp_gamma / (2.0 * action->latCurrent_)));
+ action->get_variable(), std::min(action->rate_, sg_tcp_gamma / (2.0 * action->lat_current_)));
- if (action->rate_ < sg_tcp_gamma / (2.0 * action->latCurrent_)) {
+ if (action->rate_ < sg_tcp_gamma / (2.0 * action->lat_current_)) {
XBT_INFO("Flow is limited BYBANDWIDTH");
} else {
- XBT_INFO("Flow is limited BYLATENCY, latency of flow is %f", action->latCurrent_);
+ XBT_INFO("Flow is limited BYLATENCY, latency of flow is %f", action->lat_current_);
}
}
if (not action->is_suspended())