extern surf_model_t surf_network_model;
-static lmm_system_t network_maxmin_system = NULL;
-static void (*network_solve) (lmm_system_t) = NULL;
+static lmm_system_t network_im_maxmin_system = NULL;
+static void (*network_im_solve) (lmm_system_t) = NULL;
extern double sg_latency_factor;
extern double sg_bandwidth_factor;
}
-static double (*latency_factor_callback) (double) =
+static double (*im_latency_factor_callback) (double) =
&im_constant_latency_factor;
-static double (*bandwidth_factor_callback) (double) =
+static double (*im_bandwidth_factor_callback) (double) =
&im_constant_bandwidth_factor;
-static double (*bandwidth_constraint_callback) (double, double, double) =
+static double (*im_bandwidth_constraint_callback) (double, double, double) =
&im_constant_bandwidth_constraint;
link_CM02_im_t nw_link = (link_CM02_im_t)
surf_resource_lmm_new(sizeof(s_link_CM02_im_t),
surf_network_model, name, properties,
- network_maxmin_system,
+ network_im_maxmin_system,
sg_bandwidth_factor * bw_initial,
history,
state_initial, state_trace,
e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
tmgr_trace_t state_trace;
- DEBUG0("link_CM02_im");
+ XBT_DEBUG("link_CM02_im");
name_link = xbt_strdup(A_surfxml_link_id);
surf_parse_get_double(&bw_initial, A_surfxml_link_bandwidth);
bw_trace = tmgr_trace_new(A_surfxml_link_bandwidth_file);
static int im_net_resource_used(void *resource_id)
{
- return lmm_constraint_used(network_maxmin_system,
+ return lmm_constraint_used(network_im_maxmin_system,
((surf_resource_lmm_t)
resource_id)->constraint);
}
if (!action->refcount) {
xbt_swag_remove(action, action->state_set);
if (((surf_action_network_CM02_im_t) action)->variable){
- lmm_variable_free(network_maxmin_system,
+ lmm_variable_free(network_im_maxmin_system,
((surf_action_network_CM02_im_t) action)->variable);
}
// remove action from the heap
if (action->category)
xbt_free(action->category);
#endif
- free(action);
- action = NULL;
+ surf_action_free(&action);
return 1;
}
return 0;
double min=-1;
double value;
- DEBUG1("Before share resources, the size of modified actions set is %d", xbt_swag_size(im_net_modified_set));
+ XBT_DEBUG("Before share resources, the size of modified actions set is %d", xbt_swag_size(im_net_modified_set));
update_action_remaining(now);
- lmm_solve(network_maxmin_system);
+ lmm_solve(network_im_maxmin_system);
- DEBUG1("After share resources, The size of modified actions set is %d", xbt_swag_size(im_net_modified_set));
+ XBT_DEBUG("After share resources, The size of modified actions set is %d", xbt_swag_size(im_net_modified_set));
xbt_swag_foreach(action, im_net_modified_set) {
if (GENERIC_ACTION(action).state_set != surf_network_model->states.running_action_set){
GENERIC_ACTION(action).max_duration;
}
- DEBUG4("Action(%p) Start %lf Finish %lf Max_duration %lf", action,
+ XBT_DEBUG("Action(%p) Start %lf Finish %lf Max_duration %lf", action,
GENERIC_ACTION(action).start, now + value,
GENERIC_ACTION(action).max_duration);
if (min != -1) {
heap_insert((surf_action_network_CM02_im_t) action, min, NORMAL);
- DEBUG3("Insert at heap action(%p) min %lf now %lf", action, min, now);
+ XBT_DEBUG("Insert at heap action(%p) min %lf now %lf", action, min, now);
}
}
min = -1;
}
- DEBUG1("The minimum with the HEAP %lf", min);
+ XBT_DEBUG("The minimum with the HEAP %lf", min);
return min;
while ((xbt_heap_size(im_net_action_heap) > 0)
&& (double_equals(xbt_heap_maxkey(im_net_action_heap), now))) {
action = xbt_heap_pop(im_net_action_heap);
- DEBUG1("Action %p: finish", action);
+ XBT_DEBUG("Action %p: finish", action);
GENERIC_ACTION(action).finish = surf_get_clock();
// if I am wearing a latency heat
if( action->hat == LATENCY){
- lmm_update_variable_weight(network_maxmin_system, action->variable,
+ lmm_update_variable_weight(network_im_maxmin_system, action->variable,
action->weight);
heap_remove(action);
action->last_update = surf_get_clock();
- DEBUG1("Action (%p) is not limited by latency anymore", action);
+ XBT_DEBUG("Action (%p) is not limited by latency anymore", action);
#ifdef HAVE_LATENCY_BOUND_TRACKING
GENERIC_ACTION(action).latency_limited = 0;
#endif
surf_action_network_CM02_im_t action = NULL;
nw_link->lmm_resource.power.peak = value;
- lmm_update_constraint_bound(network_maxmin_system,
+ lmm_update_constraint_bound(network_im_maxmin_system,
nw_link->lmm_resource.constraint,
sg_bandwidth_factor *
(nw_link->lmm_resource.power.peak *
#endif
if (sg_weight_S_parameter > 0) {
while ((var = lmm_get_var_from_cnst
- (network_maxmin_system, nw_link->lmm_resource.constraint,
+ (network_im_maxmin_system, nw_link->lmm_resource.constraint,
&elem))) {
action = lmm_variable_id(var);
action->weight += delta;
if (!(action->suspended))
- lmm_update_variable_weight(network_maxmin_system,
+ lmm_update_variable_weight(network_im_maxmin_system,
action->variable, action->weight);
}
}
nw_link->lat_current = value;
while ((var = lmm_get_var_from_cnst
- (network_maxmin_system, nw_link->lmm_resource.constraint,
+ (network_im_maxmin_system, nw_link->lmm_resource.constraint,
&elem))) {
action = lmm_variable_id(var);
action->lat_current += delta;
action->weight += delta;
if (action->rate < 0)
- lmm_update_variable_bound(network_maxmin_system, action->variable,
+ lmm_update_variable_bound(network_im_maxmin_system, action->variable,
sg_tcp_gamma / (2.0 *
action->lat_current));
else {
- lmm_update_variable_bound(network_maxmin_system, action->variable,
+ lmm_update_variable_bound(network_im_maxmin_system, action->variable,
min(action->rate,
sg_tcp_gamma / (2.0 *
action->lat_current)));
if (action->rate < sg_tcp_gamma / (2.0 * action->lat_current)) {
- INFO0("Flow is limited BYBANDWIDTH");
+ XBT_INFO("Flow is limited BYBANDWIDTH");
} else {
- INFO1("Flow is limited BYLATENCY, latency of flow is %f",
+ XBT_INFO("Flow is limited BYLATENCY, latency of flow is %f",
action->lat_current);
}
}
if (!(action->suspended))
- lmm_update_variable_weight(network_maxmin_system, action->variable,
+ lmm_update_variable_weight(network_im_maxmin_system, action->variable,
action->weight);
}
nw_link->lmm_resource.state_current = SURF_RESOURCE_OFF;
while ((var = lmm_get_var_from_cnst
- (network_maxmin_system, cnst, &elem))) {
+ (network_im_maxmin_system, cnst, &elem))) {
surf_action_t action = lmm_variable_id(var);
if (surf_action_state_get(action) == SURF_ACTION_RUNNING ||
if (tmgr_trace_event_free(event_type))
nw_link->lmm_resource.state_event = NULL;
} else {
- CRITICAL0("Unknown event ! \n");
+ XBT_CRITICAL("Unknown event ! \n");
xbt_abort();
}
- DEBUG1("There were a resource state event, need to update actions related to the constraint (%p)", nw_link->lmm_resource.constraint);
+ XBT_DEBUG("There were a resource state event, need to update actions related to the constraint (%p)", nw_link->lmm_resource.constraint);
return;
}
/* LARGE PLATFORMS HACK:
total_route_size = route_size + src->link_nb + dst->nb */
- XBT_IN4("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
+ XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
/* LARGE PLATFORMS HACK:
assert on total_route_size */
xbt_assert2(xbt_dynar_length(route),
(link->lmm_resource.power.peak * link->lmm_resource.power.scale);
if (bandwidth_bound < 0.0)
bandwidth_bound =
- (*bandwidth_factor_callback) (size) *
+ (*im_bandwidth_factor_callback) (size) *
(link->lmm_resource.power.peak * link->lmm_resource.power.scale);
else
bandwidth_bound =
min(bandwidth_bound,
- (*bandwidth_factor_callback) (size) *
+ (*im_bandwidth_factor_callback) (size) *
(link->lmm_resource.power.peak *
link->lmm_resource.power.scale));
}
/* LARGE PLATFORMS HACK:
Add src->link and dst->link latencies */
action->lat_current = action->latency;
- action->latency *= (*latency_factor_callback) (size);
+ action->latency *= (*im_latency_factor_callback) (size);
action->rate =
- (*bandwidth_constraint_callback) (action->rate, bandwidth_bound,
+ (*im_bandwidth_constraint_callback) (action->rate, bandwidth_bound,
size);
/* LARGE PLATFORMS HACK:
if (action->latency > 0){
action->variable =
- lmm_variable_new(network_maxmin_system, action, 0.0, -1.0,
+ lmm_variable_new(network_im_maxmin_system, action, 0.0, -1.0,
constraints_per_variable);
// add to the heap the event when the latency is payed
- DEBUG2("Added action (%p) one latency event at date %f", action, action->latency + action->last_update);
+ XBT_DEBUG("Added action (%p) one latency event at date %f", action, action->latency + action->last_update);
heap_insert(action, action->latency + action->last_update, LATENCY);
#ifdef HAVE_LATENCY_BOUND_TRACKING
(action->generic_action).latency_limited = 1;
}
else
action->variable =
- lmm_variable_new(network_maxmin_system, action, 1.0, -1.0,
+ lmm_variable_new(network_im_maxmin_system, action, 1.0, -1.0,
constraints_per_variable);
if (action->rate < 0) {
if (action->lat_current > 0)
- lmm_update_variable_bound(network_maxmin_system, action->variable,
+ lmm_update_variable_bound(network_im_maxmin_system, action->variable,
sg_tcp_gamma / (2.0 *
action->lat_current));
else
- lmm_update_variable_bound(network_maxmin_system, action->variable,
+ lmm_update_variable_bound(network_im_maxmin_system, action->variable,
-1.0);
} else {
if (action->lat_current > 0)
- lmm_update_variable_bound(network_maxmin_system, action->variable,
+ lmm_update_variable_bound(network_im_maxmin_system, action->variable,
min(action->rate,
sg_tcp_gamma / (2.0 *
action->lat_current)));
else
- lmm_update_variable_bound(network_maxmin_system, action->variable,
+ lmm_update_variable_bound(network_im_maxmin_system, action->variable,
action->rate);
}
xbt_dynar_foreach(route, i, link) {
- lmm_expand(network_maxmin_system, link->lmm_resource.constraint,
+ lmm_expand(network_im_maxmin_system, link->lmm_resource.constraint,
action->variable, 1.0);
}
if (sg_network_fullduplex == 1) {
- DEBUG1("Fullduplex active adding backward flow using 5%c", '%');
+ XBT_DEBUG("Fullduplex active adding backward flow using 5%c", '%');
xbt_dynar_foreach(back_route, i, link) {
- lmm_expand(network_maxmin_system, link->lmm_resource.constraint,
+ lmm_expand(network_im_maxmin_system, link->lmm_resource.constraint,
action->variable, .05);
}
}
#endif
xbt_dynar_free(&route);
- XBT_OUT;
+ XBT_OUT();
return (surf_action_t) action;
}
static void im_net_action_suspend(surf_action_t action)
{
((surf_action_network_CM02_im_t) action)->suspended = 1;
- lmm_update_variable_weight(network_maxmin_system,
+ lmm_update_variable_weight(network_im_maxmin_system,
((surf_action_network_CM02_im_t)
action)->variable, 0.0);
static void im_net_action_resume(surf_action_t action)
{
if (((surf_action_network_CM02_im_t) action)->suspended) {
- lmm_update_variable_weight(network_maxmin_system,
+ lmm_update_variable_weight(network_im_maxmin_system,
((surf_action_network_CM02_im_t)
action)->variable,
((surf_action_network_CM02_im_t)
global_routing->finalize();
- lmm_system_free(network_maxmin_system);
- network_maxmin_system = NULL;
+ lmm_system_free(network_im_maxmin_system);
+ network_im_maxmin_system = NULL;
xbt_heap_free(im_net_action_heap);
xbt_swag_free(im_net_modified_set);
static void im_surf_network_model_init_internal(void)
{
s_surf_action_network_CM02_im_t comm;
- INFO0("You are using the UNSAFE lazy management optimization, I hope you know what you are doing.");
- INFO0("====> For now this optimization is only available for LV08_im network model.");
+ XBT_INFO("You are using the UNSAFE lazy management optimization, I hope you know what you are doing.");
+ XBT_INFO("====> For now this optimization is only available for LV08_im network model.");
surf_network_model = surf_model_init();
im_net_create_resource;
- if (!network_maxmin_system){
+ if (!network_im_maxmin_system){
sg_maxmin_selective_update = 1;
- network_maxmin_system = lmm_system_new();
+ network_im_maxmin_system = lmm_system_new();
}
im_net_action_heap = xbt_heap_new(8,NULL);
im_surf_network_model_init_internal();
im_net_define_callbacks(filename);
xbt_dynar_push(model_list, &surf_network_model);
- network_solve = lmm_solve;
+ network_im_solve = lmm_solve;
xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor", 10.4);
xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
