+/* Copyright (c) 2013-2014. 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. */
+
#include "network_cm02.hpp"
#include "maxmin_private.hpp"
#include "simgrid/sg_config.h"
* CallBacks *
*************/
-static void net_parse_link_init(sg_platf_link_cbarg_t link){
- if (link->policy == SURF_LINK_FULLDUPLEX) {
- char *link_id;
- link_id = bprintf("%s_UP", link->id);
- surf_network_model->createResource(link_id,
- link->bandwidth,
- link->bandwidth_trace,
- link->latency,
- link->latency_trace,
- link->state,
- link->state_trace, link->policy, link->properties);
- xbt_free(link_id);
- link_id = bprintf("%s_DOWN", link->id);
- surf_network_model->createResource(link_id,
- link->bandwidth,
- link->bandwidth_trace,
- link->latency,
- link->latency_trace,
- link->state,
- link->state_trace, link->policy, link->properties);
- xbt_free(link_id);
- } else {
- surf_network_model->createResource(link->id,
- link->bandwidth,
- link->bandwidth_trace,
- link->latency,
- link->latency_trace,
- link->state,
- link->state_trace, link->policy, link->properties);
- }
-}
-
-static void net_add_traces(void){
- xbt_dict_cursor_t cursor = NULL;
- char *trace_name, *elm;
-
- static int called = 0;
- if (called)
- return;
- called = 1;
-
- /* connect all traces relative to network */
- xbt_dict_foreach(trace_connect_list_link_avail, cursor, trace_name, elm) {
- tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- NetworkCm02LinkPtr link = static_cast<NetworkCm02LinkPtr>(
- xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL));
-
- xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
- trace_name, elm);
- xbt_assert(trace,
- "Cannot connect trace %s to link %s: trace undefined",
- trace_name, elm);
-
- link->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
- }
-
- xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) {
- tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- NetworkCm02LinkPtr link = static_cast<NetworkCm02LinkPtr>(
- xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL));
-
- xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
- trace_name, elm);
- xbt_assert(trace,
- "Cannot connect trace %s to link %s: trace undefined",
- trace_name, elm);
-
- link->p_power.event = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
- }
-
- xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) {
- tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
- NetworkCm02LinkPtr link = static_cast<NetworkCm02LinkPtr>(
- xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL));
-
- xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
- trace_name, elm);
- xbt_assert(trace,
- "Cannot connect trace %s to link %s: trace undefined",
- trace_name, elm);
-
- link->p_latEvent = tmgr_history_add_trace(history, trace, 0.0, 0, static_cast<ResourcePtr>(link));
- }
-}
-
void net_define_callbacks(void)
{
/* Figuring out the network links */
- sg_platf_link_add_cb(net_parse_link_init);
+ sg_platf_link_add_cb(netlink_parse_init);
sg_platf_postparse_add_cb(net_add_traces);
}
surf_network_model = new NetworkCm02Model();
net_define_callbacks();
- ModelPtr model = static_cast<ModelPtr>(surf_network_model);
+ ModelPtr model = surf_network_model;
xbt_dynar_push(model_list, &model);
xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor",
surf_network_model = new NetworkCm02Model();
net_define_callbacks();
- ModelPtr model = static_cast<ModelPtr>(surf_network_model);
+ ModelPtr model = surf_network_model;
xbt_dynar_push(model_list, &model);
xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor", 1.0);
surf_network_model = new NetworkCm02Model();
net_define_callbacks();
- ModelPtr model = static_cast<ModelPtr>(surf_network_model);
+ ModelPtr model = surf_network_model;
xbt_dynar_push(model_list, &model);
lmm_set_default_protocol_function(func_reno_f, func_reno_fp,
func_reno_fpi);
surf_network_model = new NetworkCm02Model();
net_define_callbacks();
- ModelPtr model = static_cast<ModelPtr>(surf_network_model);
+ ModelPtr model = surf_network_model;
xbt_dynar_push(model_list, &model);
lmm_set_default_protocol_function(func_reno2_f, func_reno2_fp,
func_reno2_fpi);
surf_network_model = new NetworkCm02Model();
net_define_callbacks();
- ModelPtr model = static_cast<ModelPtr>(surf_network_model);
+ ModelPtr model = surf_network_model;
xbt_dynar_push(model_list, &model);
lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp,
func_vegas_fpi);
p_maxminSystem = lmm_system_new(m_selectiveUpdate);
const char* lb_name = "__loopback__";
- routing_model_create(static_cast<ResourcePtr>(createResource(lb_name,
+ routing_model_create(createNetworkLink(lb_name,
498000000, NULL, 0.000015, NULL,
SURF_RESOURCE_ON, NULL,
- SURF_LINK_FATPIPE, NULL)));
+ SURF_LINK_FATPIPE, NULL));
if (p_updateMechanism == UM_LAZY) {
p_actionHeap = xbt_heap_new(8, NULL);
m_haveGap = false;
}
-NetworkLinkPtr NetworkCm02Model::createResource(const char *name,
+NetworkLinkPtr NetworkCm02Model::createNetworkLink(const char *name,
double bw_initial,
tmgr_trace_t bw_trace,
double lat_initial,
state_initial, state_trace, bw_initial, bw_trace, lat_initial, lat_trace, policy);
- xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, static_cast<ResourcePtr>(nw_link));
+ xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, nw_link);
XBT_DEBUG("Create link '%s'",name);
return nw_link;
{
NetworkCm02ActionPtr action;
while ((xbt_heap_size(p_actionHeap) > 0)
- && (double_equals(xbt_heap_maxkey(p_actionHeap), now))) {
+ && (double_equals(xbt_heap_maxkey(p_actionHeap), now, sg_surf_precision))) {
action = (NetworkCm02ActionPtr) xbt_heap_pop(p_actionHeap);
XBT_DEBUG("Something happened to action %p", action);
#ifdef HAVE_TRACING
xbt_dynar_t route = xbt_dynar_new(sizeof(RoutingEdgePtr), NULL);
- XBT_IN("(%s,%s,%g,%g)", src->p_name, dst->p_name, size, rate);
+ XBT_IN("(%s,%s,%g,%g)", src->getName(), dst->getName(), size, rate);
routing_platf->getRouteAndLatency(src, dst, &route, &latency);
xbt_assert(!xbt_dynar_is_empty(route) || latency,
"You're trying to send data from %s to %s but there is no connection at all between these two hosts.",
- src->p_name, dst->p_name);
+ src->getName(), dst->getName());
xbt_dynar_foreach(route, i, _link) {
link = static_cast<NetworkCm02LinkPtr>(_link);
link = *static_cast<NetworkCm02LinkPtr *>(xbt_dynar_get_ptr(route, 0));
gapAppend(size, link, action);
XBT_DEBUG("Comm %p: %s -> %s gap=%f (lat=%f)",
- action, src->p_name, dst->p_name, action->m_senderGap,
+ action, src->getName(), dst->getName(), action->m_senderGap,
action->m_latency);
}
constraints_per_variable += xbt_dynar_length(back_route);
if (action->m_latency > 0) {
- action->p_variable = lmm_variable_new(p_maxminSystem, static_cast<ActionPtr>(action), 0.0, -1.0,
+ action->p_variable = lmm_variable_new(p_maxminSystem, action, 0.0, -1.0,
constraints_per_variable);
if (p_updateMechanism == UM_LAZY) {
// add to the heap the event when the latency is payed
action->heapInsert(p_actionHeap, action->m_latency + action->m_lastUpdate, xbt_dynar_is_empty(route) ? NORMAL : LATENCY);
}
} else
- action->p_variable = lmm_variable_new(p_maxminSystem, static_cast<ActionPtr>(action), 1.0, -1.0, constraints_per_variable);
+ action->p_variable = lmm_variable_new(p_maxminSystem, action, 1.0, -1.0, constraints_per_variable);
if (action->m_rate < 0) {
lmm_update_variable_bound(p_maxminSystem, action->getVariable(), (action->m_latCurrent > 0) ? sg_tcp_gamma / (2.0 * action->m_latCurrent) : -1.0);
xbt_dynar_free(&route);
XBT_OUT();
+ surf_callback_emit(networkCommunicateCallbacks, action, src, dst, size, rate);
return action;
}
+void NetworkCm02Model::addTraces(){
+ xbt_dict_cursor_t cursor = NULL;
+ char *trace_name, *elm;
+
+ static int called = 0;
+ if (called)
+ return;
+ called = 1;
+
+ /* connect all traces relative to network */
+ xbt_dict_foreach(trace_connect_list_link_avail, cursor, trace_name, elm) {
+ tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
+ NetworkCm02LinkPtr link = static_cast<NetworkCm02LinkPtr>(
+ xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL));
+
+ xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
+ trace_name, elm);
+ xbt_assert(trace,
+ "Cannot connect trace %s to link %s: trace undefined",
+ trace_name, elm);
+
+ link->p_stateEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
+ }
+
+ xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) {
+ tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
+ NetworkCm02LinkPtr link = static_cast<NetworkCm02LinkPtr>(
+ xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL));
+
+ xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
+ trace_name, elm);
+ xbt_assert(trace,
+ "Cannot connect trace %s to link %s: trace undefined",
+ trace_name, elm);
+
+ link->p_power.event = tmgr_history_add_trace(history, trace, 0.0, 0, link);
+ }
+ xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) {
+ tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
+ NetworkCm02LinkPtr link = static_cast<NetworkCm02LinkPtr>(
+ xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL));
+
+ xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
+ trace_name, elm);
+ xbt_assert(trace,
+ "Cannot connect trace %s to link %s: trace undefined",
+ trace_name, elm);
+
+ link->p_latEvent = tmgr_history_add_trace(history, trace, 0.0, 0, link);
+ }
+}
/************
* Resource *
e_surf_link_sharing_policy_t policy)
: NetworkLink(model, name, props, lmm_constraint_new(system, this, constraint_value), history, state_trace)
{
- m_stateCurrent = state_init;
+ setState(state_init);
p_power.scale = 1.0;
p_power.peak = metric_peak;
if (metric_trace)
- p_power.event = tmgr_history_add_trace(history, metric_trace, 0.0, 0, static_cast<ResourcePtr>(this));
+ p_power.event = tmgr_history_add_trace(history, metric_trace, 0.0, 0, this);
else
p_power.event = NULL;
m_latCurrent = lat_initial;
if (lat_trace)
- p_latEvent = tmgr_history_add_trace(history, lat_trace, 0.0, 0, static_cast<ResourcePtr>(this));
+ p_latEvent = tmgr_history_add_trace(history, lat_trace, 0.0, 0, this);
if (policy == SURF_LINK_FATPIPE)
lmm_constraint_shared(getConstraint());
/* value, event_type); */
if (event_type == p_power.event) {
- double delta =
- sg_weight_S_parameter / value - sg_weight_S_parameter /
- (p_power.peak * p_power.scale);
- lmm_variable_t var = NULL;
- lmm_element_t elem = NULL;
- NetworkCm02ActionPtr action = NULL;
-
- p_power.peak = value;
- lmm_update_constraint_bound(getModel()->getMaxminSystem(),
- getConstraint(),
- sg_bandwidth_factor *
- (p_power.peak * p_power.scale));
-#ifdef HAVE_TRACING
- TRACE_surf_link_set_bandwidth(date, getName(), sg_bandwidth_factor * p_power.peak * p_power.scale);
-#endif
- if (sg_weight_S_parameter > 0) {
- while ((var = lmm_get_var_from_cnst(getModel()->getMaxminSystem(), getConstraint(), &elem))) {
- action = (NetworkCm02ActionPtr) lmm_variable_id(var);
- action->m_weight += delta;
- if (!action->isSuspended())
- lmm_update_variable_weight(getModel()->getMaxminSystem(), action->getVariable(), action->m_weight);
- }
- }
+ updateBandwidth(value, date);
if (tmgr_trace_event_free(event_type))
p_power.event = NULL;
} else if (event_type == p_latEvent) {
- double delta = value - m_latCurrent;
- lmm_variable_t var = NULL;
- lmm_element_t elem = NULL;
- NetworkCm02ActionPtr action = NULL;
-
- m_latCurrent = value;
- while ((var = lmm_get_var_from_cnst(getModel()->getMaxminSystem(), getConstraint(), &elem))) {
- action = (NetworkCm02ActionPtr) lmm_variable_id(var);
- action->m_latCurrent += delta;
- action->m_weight += delta;
- if (action->m_rate < 0)
- lmm_update_variable_bound(getModel()->getMaxminSystem(), action->getVariable(), sg_tcp_gamma / (2.0 * action->m_latCurrent));
- else {
- lmm_update_variable_bound(getModel()->getMaxminSystem(), action->getVariable(),
- min(action->m_rate, sg_tcp_gamma / (2.0 * action->m_latCurrent)));
-
- if (action->m_rate < sg_tcp_gamma / (2.0 * action->m_latCurrent)) {
- XBT_INFO("Flow is limited BYBANDWIDTH");
- } else {
- XBT_INFO("Flow is limited BYLATENCY, latency of flow is %f",
- action->m_latCurrent);
- }
- }
- if (!action->isSuspended())
- lmm_update_variable_weight(getModel()->getMaxminSystem(), action->getVariable(), action->m_weight);
-
- }
+ updateLatency(value, date);
if (tmgr_trace_event_free(event_type))
p_latEvent = NULL;
} else if (event_type == p_stateEvent) {
if (value > 0)
- m_stateCurrent = SURF_RESOURCE_ON;
+ setState(SURF_RESOURCE_ON);
else {
lmm_constraint_t cnst = getConstraint();
lmm_variable_t var = NULL;
lmm_element_t elem = NULL;
- m_stateCurrent = SURF_RESOURCE_OFF;
+ setState(SURF_RESOURCE_OFF);
while ((var = lmm_get_var_from_cnst(getModel()->getMaxminSystem(), cnst, &elem))) {
ActionPtr action = (ActionPtr) lmm_variable_id(var);
return;
}
+void NetworkCm02Link::updateBandwidth(double value, double date){
+ double delta = sg_weight_S_parameter / value - sg_weight_S_parameter /
+ (p_power.peak * p_power.scale);
+ lmm_variable_t var = NULL;
+ lmm_element_t elem = NULL;
+ NetworkCm02ActionPtr action = NULL;
+
+ p_power.peak = value;
+ lmm_update_constraint_bound(getModel()->getMaxminSystem(),
+ getConstraint(),
+ sg_bandwidth_factor *
+ (p_power.peak * p_power.scale));
+#ifdef HAVE_TRACING
+ TRACE_surf_link_set_bandwidth(date, getName(), sg_bandwidth_factor * p_power.peak * p_power.scale);
+#endif
+ if (sg_weight_S_parameter > 0) {
+ while ((var = lmm_get_var_from_cnst(getModel()->getMaxminSystem(), getConstraint(), &elem))) {
+ action = (NetworkCm02ActionPtr) lmm_variable_id(var);
+ action->m_weight += delta;
+ if (!action->isSuspended())
+ lmm_update_variable_weight(getModel()->getMaxminSystem(), action->getVariable(), action->m_weight);
+ }
+ }
+}
+
+void NetworkCm02Link::updateLatency(double value, double date){
+ double delta = value - m_latCurrent;
+ lmm_variable_t var = NULL;
+ lmm_element_t elem = NULL;
+ NetworkCm02ActionPtr action = NULL;
+
+ m_latCurrent = value;
+ while ((var = lmm_get_var_from_cnst(getModel()->getMaxminSystem(), getConstraint(), &elem))) {
+ action = (NetworkCm02ActionPtr) lmm_variable_id(var);
+ action->m_latCurrent += delta;
+ action->m_weight += delta;
+ if (action->m_rate < 0)
+ lmm_update_variable_bound(getModel()->getMaxminSystem(), action->getVariable(), sg_tcp_gamma / (2.0 * action->m_latCurrent));
+ else {
+ lmm_update_variable_bound(getModel()->getMaxminSystem(), action->getVariable(),
+ min(action->m_rate, sg_tcp_gamma / (2.0 * action->m_latCurrent)));
+
+ if (action->m_rate < sg_tcp_gamma / (2.0 * action->m_latCurrent)) {
+ XBT_INFO("Flow is limited BYBANDWIDTH");
+ } else {
+ XBT_INFO("Flow is limited BYLATENCY, latency of flow is %f",
+ action->m_latCurrent);
+ }
+ }
+ if (!action->isSuspended())
+ lmm_update_variable_weight(getModel()->getMaxminSystem(), action->getVariable(), action->m_weight);
+ }
+}
+
/**********
* Action *
**********/
delta = now - m_lastUpdate;
if (m_remains > 0) {
- XBT_DEBUG("Updating action(%p): remains was %lf, last_update was: %lf", this, m_remains, m_lastUpdate);
- double_update(&(m_remains), m_lastValue * delta);
+ XBT_DEBUG("Updating action(%p): remains was %f, last_update was: %f", this, m_remains, m_lastUpdate);
+ double_update(&(m_remains), m_lastValue * delta, sg_maxmin_precision*sg_surf_precision);
- XBT_DEBUG("Updating action(%p): remains is now %lf", this, m_remains);
+ XBT_DEBUG("Updating action(%p): remains is now %f", this, m_remains);
}
if (m_maxDuration != NO_MAX_DURATION)
- double_update(&m_maxDuration, delta);
+ double_update(&m_maxDuration, delta, sg_surf_precision);
if (m_remains <= 0 &&
(lmm_get_variable_weight(getVariable()) > 0)) {