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;
-static link_CM02_im_t im_net_link_new(char *name,
+static void* im_net_create_resource(char *name,
double bw_initial,
tmgr_trace_t bw_trace,
double lat_initial,
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,
bw_initial, bw_trace);
- xbt_assert1(!xbt_dict_get_or_null
- (surf_network_model->resource_set, name),
+ xbt_assert(!xbt_lib_get_or_null(link_lib, name, SURF_LINK_LEVEL),
"Link '%s' declared several times in the platform file.",
name);
if (policy == SURF_LINK_FATPIPE)
lmm_constraint_shared(nw_link->lmm_resource.constraint);
- xbt_dict_set(surf_network_model->resource_set, name, nw_link,
- surf_resource_free);
-#ifdef HAVE_TRACING
- TRACE_surf_link_declaration(nw_link, name, bw_initial, lat_initial);
-#endif
+ xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, nw_link);
+
return nw_link;
}
static void im_net_parse_link_init(void)
{
- char *name_link;
- double bw_initial;
- tmgr_trace_t bw_trace;
- double lat_initial;
- tmgr_trace_t lat_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");
- 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);
- surf_parse_get_double(&lat_initial, A_surfxml_link_latency);
- lat_trace = tmgr_trace_new(A_surfxml_link_latency_file);
-
- xbt_assert0((A_surfxml_link_state == A_surfxml_link_state_ON)
- || (A_surfxml_link_state ==
- A_surfxml_link_state_OFF), "Invalid state");
- if (A_surfxml_link_state == A_surfxml_link_state_ON)
- state_initial_link = SURF_RESOURCE_ON;
- else if (A_surfxml_link_state == A_surfxml_link_state_OFF)
- state_initial_link = SURF_RESOURCE_OFF;
-
- if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
- policy_initial_link = SURF_LINK_SHARED;
- else
- {
- if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FATPIPE)
- policy_initial_link = SURF_LINK_FATPIPE;
- else if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX)
- policy_initial_link = SURF_LINK_FULLDUPLEX;
- }
-
- state_trace = tmgr_trace_new(A_surfxml_link_state_file);
-
- if(policy_initial_link == SURF_LINK_FULLDUPLEX)
+ if(struct_lnk->V_policy_initial_link == SURF_LINK_FULLDUPLEX)
{
- im_net_link_new(bprintf("%s_UP",name_link), bw_initial, bw_trace,
- lat_initial, lat_trace, state_initial_link, state_trace,
- policy_initial_link, xbt_dict_new());
- im_net_link_new(bprintf("%s_DOWN",name_link), bw_initial, bw_trace,
- lat_initial, lat_trace, state_initial_link, state_trace,
- policy_initial_link, xbt_dict_new());
+ im_net_create_resource(bprintf("%s_UP",struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
+ struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
+ struct_lnk->V_policy_initial_link, xbt_dict_new());
+ im_net_create_resource(bprintf("%s_DOWN",struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
+ struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
+ struct_lnk->V_policy_initial_link, xbt_dict_new());
}
else
{
- im_net_link_new(name_link, bw_initial, bw_trace,
- lat_initial, lat_trace, state_initial_link, state_trace,
- policy_initial_link, xbt_dict_new());
+ im_net_create_resource(xbt_strdup(struct_lnk->V_link_id), struct_lnk->V_link_bandwidth, struct_lnk->V_link_bandwidth_file,
+ struct_lnk->V_link_latency, struct_lnk->V_link_latency_file, struct_lnk->V_link_state, struct_lnk->V_link_state_file,
+ struct_lnk->V_policy_initial_link, xbt_dict_new());
}
-
-}
-
-static void im_net_create_resource(char *name,
- double bw_initial,
- tmgr_trace_t bw_trace,
- double lat_initial,
- tmgr_trace_t lat_trace,
- e_surf_resource_state_t
- state_initial,
- tmgr_trace_t state_trace,
- e_surf_link_sharing_policy_t policy,
- xbt_dict_t properties)
-{
- im_net_link_new(name, bw_initial, bw_trace,
- lat_initial, lat_trace, state_initial, state_trace,
- policy, xbt_dict_new());
}
static void im_net_add_traces(void)
xbt_dict_foreach(trace_connect_list_link_avail, cursor, trace_name, elm) {
tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
link_CM02_im_t link =
- xbt_dict_get_or_null(surf_network_model->resource_set, elm);
+ xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL);
- xbt_assert2(link, "Cannot connect trace %s to link %s: link undefined",
+ xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
trace_name, elm);
- xbt_assert2(trace,
+ xbt_assert(trace,
"Cannot connect trace %s to link %s: trace undefined",
trace_name, elm);
xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) {
tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
link_CM02_im_t link =
- xbt_dict_get_or_null(surf_network_model->resource_set, elm);
+ xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL);
- xbt_assert2(link, "Cannot connect trace %s to link %s: link undefined",
+ xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
trace_name, elm);
- xbt_assert2(trace,
+ xbt_assert(trace,
"Cannot connect trace %s to link %s: trace undefined",
trace_name, elm);
xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) {
tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
link_CM02_im_t link =
- xbt_dict_get_or_null(surf_network_model->resource_set, elm);
+ xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL);
- xbt_assert2(link, "Cannot connect trace %s to link %s: link undefined",
+ xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
trace_name, elm);
- xbt_assert2(trace,
+ xbt_assert(trace,
"Cannot connect trace %s to link %s: trace undefined",
trace_name, elm);
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);
+ keep_track = im_net_modified_set;
+ lmm_solve(network_im_maxmin_system);
+ keep_track = NULL;
- 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 *
nw_link->lmm_resource.power.scale));
#ifdef HAVE_TRACING
- TRACE_surf_link_set_bandwidth(date, nw_link,
+ TRACE_surf_link_set_bandwidth(date, (char *)(((nw_link->lmm_resource).generic_resource).name),
sg_bandwidth_factor *
(nw_link->lmm_resource.power.peak *
nw_link->lmm_resource.power.scale));
#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),
+ xbt_assert(xbt_dynar_length(route),
"You're trying to send data from %s to %s but there is no connection between these two hosts.",
src_name, dst_name);
(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);
}
}
/* LARGE PLATFORMS HACK:
expand also with src->link and dst->link */
#ifdef HAVE_TRACING
- action->src_name = xbt_new(char, strlen(src_name) + 1);
- strncpy(action->src_name, src_name, strlen(src_name) + 1);
-
- action->dst_name = xbt_new(char, strlen(dst_name) + 1);
- strncpy(action->dst_name, dst_name, strlen(dst_name) + 1);
+ if (TRACE_is_enabled()) {
+ action->src_name = xbt_strdup(src_name);
+ action->dst_name = xbt_strdup(dst_name);
+ } else {
+ action->src_name = action->dst_name = NULL;
+ }
#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.");
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);
xbt_heap_set_update_callback(im_net_action_heap, im_net_action_update_index_heap);
routing_model_create(sizeof(link_CM02_im_t),
- (void *) im_net_link_new(xbt_strdup("__loopback__"),
- 498000000, NULL, 0.000015, NULL,
- SURF_RESOURCE_ON, NULL,
- SURF_LINK_FATPIPE, NULL));
+ im_net_create_resource(xbt_strdup("__loopback__"),
+ 498000000, NULL, 0.000015, NULL,
+ SURF_RESOURCE_ON, NULL,
+ SURF_LINK_FATPIPE, NULL),
+ im_net_get_link_latency);
im_net_modified_set =
xbt_swag_new(xbt_swag_offset(comm, action_list_hookup));
- keep_track = im_net_modified_set;
}
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",
xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 8775);
update_model_description(surf_network_model_description,
- "LV08_im", surf_network_model);
+ "LV08", surf_network_model);
}
