#include "network_cm02.hpp"
#include "simgrid/s4u/Host.hpp"
#include "simgrid/sg_config.h"
-#include "src/instr/instr_private.h" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
+#include "src/instr/instr_private.hpp" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_network);
NetworkCm02Model::NetworkCm02Model()
:NetworkModel()
{
- char *optim = xbt_cfg_get_string("network/optim");
+ std::string optim = xbt_cfg_get_string("network/optim");
bool select = xbt_cfg_get_boolean("network/maxmin-selective-update");
- if (not strcmp(optim, "Full")) {
- updateMechanism_ = UM_FULL;
+ if (optim == "Full") {
+ setUpdateMechanism(UM_FULL);
selectiveUpdate_ = select;
- } else if (not strcmp(optim, "Lazy")) {
- updateMechanism_ = UM_LAZY;
+ } else if (optim == "Lazy") {
+ setUpdateMechanism(UM_LAZY);
selectiveUpdate_ = true;
xbt_assert(select || (xbt_cfg_is_default_value("network/maxmin-selective-update")),
"You cannot disable selective update when using the lazy update mechanism");
} else {
- xbt_die("Unsupported optimization (%s) for this model. Accepted: Full, Lazy.", optim);
+ xbt_die("Unsupported optimization (%s) for this model. Accepted: Full, Lazy.", optim.c_str());
}
maxminSystem_ = lmm_system_new(selectiveUpdate_);
loopback_ = createLink("__loopback__", 498000000, 0.000015, SURF_LINK_FATPIPE);
- if (updateMechanism_ == UM_LAZY) {
- actionHeap_ = xbt_heap_new(8, nullptr);
- xbt_heap_set_update_callback(actionHeap_, surf_action_lmm_update_index_heap);
+ if (getUpdateMechanism() == UM_LAZY) {
modifiedSet_ = new ActionLmmList();
maxminSystem_->keep_track = modifiedSet_;
}
maxminSystem_->solve_fun = specificSolveFun;
}
-LinkImpl* NetworkCm02Model::createLink(const char* name, double bandwidth, double latency,
+LinkImpl* NetworkCm02Model::createLink(const std::string& name, double bandwidth, double latency,
e_surf_link_sharing_policy_t policy)
{
return new NetworkCm02Link(this, name, bandwidth, latency, policy, maxminSystem_);
void NetworkCm02Model::updateActionsStateLazy(double now, double /*delta*/)
{
- while ((xbt_heap_size(actionHeap_) > 0)
- && (double_equals(xbt_heap_maxkey(actionHeap_), now, sg_surf_precision))) {
+ while (not actionHeapIsEmpty() && double_equals(actionHeapTopDate(), now, sg_surf_precision)) {
- NetworkCm02Action *action = static_cast<NetworkCm02Action*> (xbt_heap_pop(actionHeap_));
+ NetworkCm02Action* action = static_cast<NetworkCm02Action*>(actionHeapPop());
XBT_DEBUG("Something happened to action %p", action);
if (TRACE_is_enabled()) {
int n = lmm_get_number_of_cnst_from_var(maxminSystem_, action->getVariable());
NetworkCm02Link *link = static_cast<NetworkCm02Link*>(lmm_constraint_id(constraint));
double value = lmm_variable_getvalue(action->getVariable())*
lmm_get_cnst_weight_from_var(maxminSystem_, action->getVariable(), i);
- TRACE_surf_link_set_utilization(link->cname(), action->getCategory(), value, action->getLastUpdate(),
+ TRACE_surf_link_set_utilization(link->getCname(), action->getCategory(), value, action->getLastUpdate(),
now - action->getLastUpdate());
}
}
if (action->getHat() == LATENCY) {
XBT_DEBUG("Latency paid for action %p. Activating", action);
lmm_update_variable_weight(maxminSystem_, action->getVariable(), action->weight_);
- action->heapRemove(actionHeap_);
+ action->heapRemove(getActionHeap());
action->refreshLastUpdate();
// if I am wearing a max_duration or normal hat
// assume that flows that reached max_duration have remaining of 0
XBT_DEBUG("Action %p finished", action);
action->setRemains(0);
- action->finish();
- action->setState(Action::State::done);
- action->heapRemove(actionHeap_);
+ action->finish(Action::State::done);
+ action->heapRemove(getActionHeap());
}
}
}
void NetworkCm02Model::updateActionsStateFull(double now, double delta)
{
ActionList *running_actions = getRunningActionSet();
-
- for(ActionList::iterator it(running_actions->begin()), itNext=it, itend(running_actions->end())
- ; it != itend ; it=itNext) {
- ++itNext;
-
+ ActionList::iterator it(running_actions->begin());
+ ActionList::iterator itend(running_actions->end());
+ while (it != itend) {
NetworkCm02Action *action = static_cast<NetworkCm02Action*> (&*it);
+ ++it;
XBT_DEBUG("Something happened to action %p", action);
double deltap = delta;
if (action->latency_ > 0) {
lmm_constraint_t constraint = lmm_get_cnst_from_var(maxminSystem_, action->getVariable(), i);
NetworkCm02Link* link = static_cast<NetworkCm02Link*>(lmm_constraint_id(constraint));
- TRACE_surf_link_set_utilization(link->cname(), action->getCategory(),
+ TRACE_surf_link_set_utilization(link->getCname(), action->getCategory(),
(lmm_variable_getvalue(action->getVariable()) *
lmm_get_cnst_weight_from_var(maxminSystem_, action->getVariable(), i)),
action->getLastUpdate(), now - action->getLastUpdate());
if (((action->getRemains() <= 0) && (lmm_get_variable_weight(action->getVariable()) > 0)) ||
((action->getMaxDuration() > NO_MAX_DURATION) && (action->getMaxDuration() <= 0))) {
- action->finish();
- action->setState(Action::State::done);
+ action->finish(Action::State::done);
}
}
}
{
int failed = 0;
double latency = 0.0;
- std::vector<LinkImpl*>* back_route = nullptr;
- std::vector<LinkImpl*>* route = new std::vector<LinkImpl*>();
+ std::vector<LinkImpl*> back_route;
+ std::vector<LinkImpl*> route;
XBT_IN("(%s,%s,%g,%g)", src->getCname(), dst->getCname(), size, rate);
src->routeTo(dst, route, &latency);
- xbt_assert(not route->empty() || latency,
+ xbt_assert(not route.empty() || latency,
"You're trying to send data from %s to %s but there is no connecting path between these two hosts.",
src->getCname(), dst->getCname());
- for (auto const& link : *route)
+ for (auto const& link : route)
if (link->isOff())
failed = 1;
if (sg_network_crosstraffic == 1) {
- back_route = new std::vector<LinkImpl*>();
dst->routeTo(src, back_route, nullptr);
- for (auto const& link : *back_route)
+ for (auto const& link : back_route)
if (link->isOff())
failed = 1;
}
action->weight_ = latency;
action->latency_ = latency;
action->rate_ = rate;
- if (updateMechanism_ == UM_LAZY) {
- action->indexHeap_ = -1;
- action->lastUpdate_ = surf_get_clock();
+ if (getUpdateMechanism() == UM_LAZY) {
+ action->refreshLastUpdate();
}
double bandwidth_bound = -1.0;
if (sg_weight_S_parameter > 0)
- for (auto const& link : *route)
+ for (auto const& link : route)
action->weight_ += sg_weight_S_parameter / link->bandwidth();
- for (auto const& link : *route) {
+ for (auto const& link : route) {
double bb = bandwidthFactor(size) * link->bandwidth();
bandwidth_bound = (bandwidth_bound < 0.0) ? bb : std::min(bandwidth_bound, bb);
}
action->latency_ *= latencyFactor(size);
action->rate_ = bandwidthConstraint(action->rate_, bandwidth_bound, size);
- int constraints_per_variable = route->size();
- if (back_route != nullptr)
- constraints_per_variable += back_route->size();
+ int constraints_per_variable = route.size();
+ constraints_per_variable += back_route.size();
if (action->latency_ > 0) {
- action->variable_ = lmm_variable_new(maxminSystem_, action, 0.0, -1.0, constraints_per_variable);
- if (updateMechanism_ == UM_LAZY) {
+ action->setVariable(lmm_variable_new(maxminSystem_, action, 0.0, -1.0, constraints_per_variable));
+ if (getUpdateMechanism() == UM_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->lastUpdate_);
- action->heapInsert(actionHeap_, action->latency_ + action->lastUpdate_, route->empty() ? NORMAL : LATENCY);
+ XBT_DEBUG("Added action (%p) one latency event at date %f", action, action->latency_ + action->getLastUpdate());
+ action->heapInsert(getActionHeap(), action->latency_ + action->getLastUpdate(), route.empty() ? NORMAL : LATENCY);
}
} else
- action->variable_ = lmm_variable_new(maxminSystem_, action, 1.0, -1.0, constraints_per_variable);
+ action->setVariable(lmm_variable_new(maxminSystem_, action, 1.0, -1.0, constraints_per_variable));
if (action->rate_ < 0) {
lmm_update_variable_bound(maxminSystem_, action->getVariable(), (action->latCurrent_ > 0) ? sg_tcp_gamma / (2.0 * action->latCurrent_) : -1.0);
lmm_update_variable_bound(maxminSystem_, action->getVariable(), (action->latCurrent_ > 0) ? std::min(action->rate_, sg_tcp_gamma / (2.0 * action->latCurrent_)) : action->rate_);
}
- for (auto const& link : *route)
+ for (auto const& link : route)
lmm_expand(maxminSystem_, link->constraint(), action->getVariable(), 1.0);
- if (back_route != nullptr) { // sg_network_crosstraffic was activated
+ if (not back_route.empty()) { // sg_network_crosstraffic was activated
XBT_DEBUG("Fullduplex active adding backward flow using 5%%");
- for (auto const& link : *back_route)
+ for (auto const& link : back_route)
lmm_expand(maxminSystem_, link->constraint(), action->getVariable(), .05);
//Change concurrency_share here, if you want that cross-traffic is included in the SURF concurrency
//(You would also have to change lmm_element_concurrency())
//lmm_variable_concurrency_share_set(action->getVariable(),2);
}
-
- delete route;
- delete back_route;
XBT_OUT();
simgrid::s4u::Link::onCommunicate(action, src, dst);
/************
* Resource *
************/
-NetworkCm02Link::NetworkCm02Link(NetworkCm02Model* model, const char* name, double bandwidth, double latency,
+NetworkCm02Link::NetworkCm02Link(NetworkCm02Model* model, const std::string& name, double bandwidth, double latency,
e_surf_link_sharing_policy_t policy, lmm_system_t system)
: LinkImpl(model, name, lmm_constraint_new(system, this, sg_bandwidth_factor * bandwidth))
{
lmm_update_constraint_bound(model()->getMaxminSystem(), constraint(),
sg_bandwidth_factor * (bandwidth_.peak * bandwidth_.scale));
- TRACE_surf_link_set_bandwidth(surf_get_clock(), cname(), sg_bandwidth_factor * bandwidth_.peak * bandwidth_.scale);
+ TRACE_surf_link_set_bandwidth(surf_get_clock(), getCname(), sg_bandwidth_factor * bandwidth_.peak * bandwidth_.scale);
if (sg_weight_S_parameter > 0) {
double delta = sg_weight_S_parameter / value - sg_weight_S_parameter / (bandwidth_.peak * bandwidth_.scale);
if (suspended_ != 0)
return;
- double delta = now - lastUpdate_;
+ double delta = now - getLastUpdate();
+ double max_duration = getMaxDuration();
- if (remains_ > 0) {
- XBT_DEBUG("Updating action(%p): remains was %f, last_update was: %f", this, remains_, lastUpdate_);
- double_update(&(remains_), lastValue_ * delta, sg_maxmin_precision*sg_surf_precision);
+ if (getRemainsNoUpdate() > 0) {
+ XBT_DEBUG("Updating action(%p): remains was %f, last_update was: %f", this, getRemainsNoUpdate(), getLastUpdate());
+ updateRemains(getLastValue() * delta);
- XBT_DEBUG("Updating action(%p): remains is now %f", this, remains_);
+ XBT_DEBUG("Updating action(%p): remains is now %f", this, getRemainsNoUpdate());
}
- if (maxDuration_ > NO_MAX_DURATION)
- double_update(&maxDuration_, delta, sg_surf_precision);
+ if (max_duration > NO_MAX_DURATION) {
+ double_update(&max_duration, delta, sg_surf_precision);
+ setMaxDuration(max_duration);
+ }
- if ((remains_ <= 0 && (lmm_get_variable_weight(getVariable()) > 0)) ||
- ((maxDuration_ > NO_MAX_DURATION) && (maxDuration_ <= 0))) {
- finish();
- setState(Action::State::done);
+ if ((getRemainsNoUpdate() <= 0 && (lmm_get_variable_weight(getVariable()) > 0)) ||
+ ((max_duration > NO_MAX_DURATION) && (max_duration <= 0))) {
+ finish(Action::State::done);
heapRemove(getModel()->getActionHeap());
}
- lastUpdate_ = now;
- lastValue_ = lmm_variable_getvalue(getVariable());
+ refreshLastUpdate();
+ setLastValue(lmm_variable_getvalue(getVariable()));
}
}
