double value;
} s_smpi_factor_t;
+
double sg_sender_gap = 0.0;
double sg_latency_factor = 1.0; /* default value; can be set by model or from command line */
double sg_bandwidth_factor = 1.0; /* default value; can be set by model or from command line */
static int net_selective_update = 0;
static int net_action_is_suspended(surf_action_t action);
-static void update_action_remaining_lazy(double now);
+static void net_update_action_remaining_lazy(double now);
static xbt_swag_t net_modified_set = NULL;
static xbt_heap_t net_action_heap = NULL;
-/* added to manage the communication action's heap */
-static void net_action_update_index_heap(void *action, int i)
-{
- ((surf_action_network_CM02_t) action)->index_heap = i;
-}
-
-/* insert action on heap using a given key and a hat (heap_action_type)
- * a hat can be of three types for communications:
- *
- * NORMAL = this is a normal heap entry stating the date to finish transmitting
- * LATENCY = this is a heap entry to warn us when the latency is payed
- * MAX_DURATION =this is a heap entry to warn us when the max_duration limit is reached
- */
-static void heap_insert(surf_action_network_CM02_t action, double key,
- enum heap_action_type hat)
-{
- action->hat = hat;
- xbt_heap_push(net_action_heap, action, key);
-}
-
-static void heap_remove(surf_action_network_CM02_t action)
-{
- action->hat = NOTSET;
- if (((surf_action_network_CM02_t) action)->index_heap >= 0) {
- xbt_heap_remove(net_action_heap, action->index_heap);
- }
-}
/******************************************************************************/
/* Factors callbacks */
lmm_constraint_shared(nw_link->lmm_resource.constraint);
xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, nw_link);
+ XBT_DEBUG("Create link '%s'",name);
return nw_link;
}
((surf_action_lmm_t) action)->variable);
}
if (network_update_mechanism == UM_LAZY) { // remove action from the heap
- heap_remove((surf_action_network_CM02_t) action);
+ surf_action_lmm_heap_remove(net_action_heap,(surf_action_lmm_t) action);
xbt_swag_remove(action, net_modified_set);
}
-#ifdef HAVE_TRACING
- xbt_free(((surf_action_network_CM02_t) action)->src_name);
- xbt_free(((surf_action_network_CM02_t) action)->dst_name);
- xbt_free(action->category);
-#endif
surf_action_free(&action);
return 1;
}
surf_network_model->action_state_set(action, SURF_ACTION_FAILED);
if (network_update_mechanism == UM_LAZY) { // remove action from the heap
xbt_swag_remove(action, net_modified_set);
- heap_remove((surf_action_network_CM02_t) action);
+ surf_action_lmm_heap_remove(net_action_heap,(surf_action_lmm_t) action);
}
}
double net_action_get_remains(surf_action_t action)
{
if (network_update_mechanism == UM_LAZY) /* update remains before return it */
- update_action_remaining_lazy(surf_get_clock());
+ net_update_action_remaining_lazy(surf_get_clock());
return action->remains;
}
-static void update_action_remaining_lazy(double now)
+static void net_update_action_remaining_lazy(double now)
{
- surf_action_network_CM02_t action = NULL;
+ surf_action_lmm_t action = NULL;
double delta = 0.0;
xbt_swag_foreach(action, net_modified_set) {
- if (GENERIC_LMM_ACTION(action).suspended != 0) {
+ if (action->suspended != 0) {
continue;
}
delta = now - action->last_update;
double_update(&(((surf_action_t)action)->remains),
- lmm_variable_getvalue(((surf_action_lmm_t) action)->variable) * delta);
+ lmm_variable_getvalue(action->variable) * delta);
if (((surf_action_t)action)->max_duration != NO_MAX_DURATION)
double_update(&(((surf_action_t)action)->max_duration), delta);
if ((((surf_action_t)action)->remains <= 0) &&
- (lmm_get_variable_weight(((surf_action_lmm_t)action)->variable) > 0)) {
+ (lmm_get_variable_weight(action->variable) > 0)) {
((surf_action_t)action)->finish = surf_get_clock();
surf_network_model->action_state_set((surf_action_t) action,
SURF_ACTION_DONE);
- heap_remove(action);
+ surf_action_lmm_heap_remove(net_action_heap,action);
} else if (((((surf_action_t)action)->max_duration != NO_MAX_DURATION)
&& (((surf_action_t)action)->max_duration <= 0))) {
((surf_action_t)action)->finish = surf_get_clock();
surf_network_model->action_state_set((surf_action_t) action,
SURF_ACTION_DONE);
- heap_remove(action);
+ surf_action_lmm_heap_remove(net_action_heap,action);
}
action->last_update = now;
xbt_swag_foreach(action, running_actions) {
#ifdef HAVE_LATENCY_BOUND_TRACKING
- if (lmm_is_variable_limited_by_latency(action->variable)) {
- GENERIC_LMM_ACTION(action).latency_limited = 1;
+ if (lmm_is_variable_limited_by_latency(GENERIC_LMM_ACTION(action).variable)) {
+ action->latency_limited = 1;
} else {
- GENERIC_LMM_ACTION(action).latency_limited = 0;
+ action->latency_limited = 0;
}
#endif
if (action->latency > 0) {
XBT_DEBUG
("Before share resources, the size of modified actions set is %d",
xbt_swag_size(net_modified_set));
- update_action_remaining_lazy(now);
+ net_update_action_remaining_lazy(now);
lmm_solve(network_maxmin_system);
GENERIC_ACTION(action).start, now + value,
GENERIC_ACTION(action).max_duration);
- if (action->index_heap >= 0) {
- heap_remove((surf_action_network_CM02_t) action);
- }
-
if (min != -1) {
- heap_insert((surf_action_network_CM02_t) action, min,
- max_dur_flag ? MAX_DURATION : NORMAL);
+ surf_action_lmm_heap_remove(net_action_heap,(surf_action_lmm_t)action);
+ surf_action_lmm_heap_insert(net_action_heap,(surf_action_lmm_t)action, min, max_dur_flag ? MAX_DURATION : NORMAL);
XBT_DEBUG("Insert at heap action(%p) min %lf now %lf", action, min,
now);
- }
+ } else DIE_IMPOSSIBLE;
}
//hereafter must have already the min value for this resource model
}
#ifdef HAVE_TRACING
if (TRACE_is_enabled()) {
- xbt_dynar_t route = NULL;
- routing_get_route_and_latency(action->src_name, action->dst_name,
- &route, NULL);
- link_CM02_t link;
+ int n = lmm_get_number_of_cnst_from_var(network_maxmin_system, GENERIC_LMM_ACTION(action).variable);
unsigned int i;
- xbt_dynar_foreach(route, i, link) {
- TRACE_surf_link_set_utilization(link->lmm_resource.
- generic_resource.name,
- (((surf_action_t)action)->data,
- (surf_action_t) action,
- lmm_variable_getvalue(action->
- variable),
- now - delta, delta);
+ for (i = 0; i < n; i++){
+ lmm_constraint_t constraint = lmm_get_cnst_from_var(network_maxmin_system,
+ GENERIC_LMM_ACTION(action).variable,
+ i);
+ link_CM02_t link = lmm_constraint_id(constraint);
+ TRACE_surf_link_set_utilization(link->lmm_resource.generic_resource.name,
+ ((surf_action_t)action)->category,
+ lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable),
+ now - delta,
+ delta);
}
}
#endif
action = xbt_heap_pop(net_action_heap);
XBT_DEBUG("Action %p: finish", action);
GENERIC_ACTION(action).finish = surf_get_clock();
+#ifdef HAVE_TRACING
+ if (TRACE_is_enabled()) {
+ int n = lmm_get_number_of_cnst_from_var(network_maxmin_system, GENERIC_LMM_ACTION(action).variable);
+ unsigned int i;
+ for (i = 0; i < n; i++){
+ lmm_constraint_t constraint = lmm_get_cnst_from_var(network_maxmin_system,
+ GENERIC_LMM_ACTION(action).variable,
+ i);
+ link_CM02_t link = lmm_constraint_id(constraint);
+ TRACE_surf_link_set_utilization(link->lmm_resource.generic_resource.name,
+ ((surf_action_t)action)->category,
+ lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable),
+ GENERIC_LMM_ACTION(action).last_update,
+ now - GENERIC_LMM_ACTION(action).last_update);
+ }
+ }
+#endif
// if I am wearing a latency hat
- if (action->hat == LATENCY) {
+ if (GENERIC_LMM_ACTION(action).hat == LATENCY) {
lmm_update_variable_weight(network_maxmin_system, GENERIC_LMM_ACTION(action).variable,
action->weight);
- heap_remove(action);
- action->last_update = surf_get_clock();
+ surf_action_lmm_heap_remove(net_action_heap,(surf_action_lmm_t)action);
+ GENERIC_LMM_ACTION(action).last_update = surf_get_clock();
// if I am wearing a max_duration or normal hat
- } else if (action->hat == MAX_DURATION || action->hat == NORMAL) {
+ } else if (GENERIC_LMM_ACTION(action).hat == MAX_DURATION ||
+ GENERIC_LMM_ACTION(action).hat == NORMAL) {
// no need to communicate anymore
// assume that flows that reached max_duration have remaining of 0
GENERIC_ACTION(action).remains = 0;
((surf_action_t)action)->finish = surf_get_clock();
surf_network_model->action_state_set((surf_action_t) action,
SURF_ACTION_DONE);
- heap_remove(action);
+ surf_action_lmm_heap_remove(net_action_heap,(surf_action_lmm_t)action);
}
}
return;
}
-static surf_action_t net_communicate(const char *src_name,
- const char *dst_name, double size,
- double rate)
+static surf_action_t net_communicate(network_element_t src,
+ network_element_t dst,
+ double size, double rate)
{
unsigned int i;
link_CM02_t link;
xbt_dynar_t route = xbt_dynar_new(global_routing->size_of_link, NULL);
- XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
+ XBT_IN("(%s,%s,%g,%g)", src->name, dst->name, size, rate);
- routing_get_route_and_latency(src_name, dst_name, &route, &latency);
+ routing_get_route_and_latency(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_name, dst_name);
+ src->name, dst->name);
xbt_dynar_foreach(route, i, link) {
if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
}
}
if (sg_network_crosstraffic == 1) {
- routing_get_route_and_latency(dst_name, src_name, &back_route, NULL);
+ routing_get_route_and_latency(dst, src, &back_route, NULL);
xbt_dynar_foreach(back_route, i, link) {
if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
failed = 1;
surf_action_new(sizeof(s_surf_action_network_CM02_t), size,
surf_network_model, failed);
#ifdef HAVE_LATENCY_BOUND_TRACKING
- (GENERIC_LMM_ACTION(action)).latency_limited = 0;
+ action->latency_limited = 0;
#endif
action->weight = action->latency = latency;
xbt_swag_insert(action, ((surf_action_t)action)->state_set);
action->rate = rate;
if (network_update_mechanism == UM_LAZY) {
- action->index_heap = -1;
- action->last_update = surf_get_clock();
+ GENERIC_LMM_ACTION(action).index_heap = -1;
+ GENERIC_LMM_ACTION(action).last_update = surf_get_clock();
}
bandwidth_bound = -1.0;
link = *(link_CM02_t *) xbt_dynar_get_ptr(route, 0);
gap_append(size, link, action);
XBT_DEBUG("Comm %p: %s -> %s gap=%f (lat=%f)",
- action, src_name, dst_name, action->sender.gap,
+ action, src->name, dst->name, action->sender.gap,
action->latency);
}
if (network_update_mechanism == 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->last_update);
- heap_insert(action, action->latency + action->last_update,
+ action->latency + GENERIC_LMM_ACTION(action).last_update);
+ surf_action_lmm_heap_insert(net_action_heap,(surf_action_lmm_t)action, action->latency + GENERIC_LMM_ACTION(action).last_update,
xbt_dynar_is_empty(route) ? NORMAL : LATENCY);
}
} else
GENERIC_LMM_ACTION(action).variable, .05);
}
}
-#ifdef HAVE_TRACING
- 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();
return (surf_action_t) action;
}
-static xbt_dynar_t net_get_route(const char *src, const char *dst)
+static xbt_dynar_t net_get_route(void *src, void *dst)
{
xbt_dynar_t route = NULL;
routing_get_route_and_latency(src, dst, &route, NULL);
action)->generic_lmm_action.variable, 0.0);
if (network_update_mechanism == UM_LAZY) // remove action from the heap
- heap_remove((surf_action_network_CM02_t) action);
+ surf_action_lmm_heap_remove(net_action_heap,(surf_action_lmm_t)action);
}
static void net_action_resume(surf_action_t action)
action)->weight);
((surf_action_network_CM02_t) action)->generic_lmm_action.suspended = 0;
if (network_update_mechanism == UM_LAZY) // remove action from the heap
- heap_remove((surf_action_network_CM02_t) action);
+ surf_action_lmm_heap_remove(net_action_heap,(surf_action_lmm_t)action);
}
}
{
action->max_duration = duration;
if (network_update_mechanism == UM_LAZY) // remove action from the heap
- heap_remove((surf_action_network_CM02_t) action);
+ surf_action_lmm_heap_remove(net_action_heap,(surf_action_lmm_t)action);
}
#ifdef HAVE_TRACING
if (network_update_mechanism == UM_LAZY) {
net_action_heap = xbt_heap_new(8, NULL);
xbt_heap_set_update_callback(net_action_heap,
- net_action_update_index_heap);
+ surf_action_lmm_update_index_heap);
net_modified_set =
- xbt_swag_new(xbt_swag_offset(comm, action_list_hookup));
+ xbt_swag_new(xbt_swag_offset(comm, generic_lmm_action.action_list_hookup));
network_maxmin_system->keep_track = net_modified_set;
}
}
static void set_update_mechanism(void)
{
-#ifdef HAVE_TRACING
- TRACE_set_network_update_mechanism();
-#endif
-
char *optim = xbt_cfg_get_string(_surf_cfg_set, "network/optim");
int select =
xbt_cfg_get_int(_surf_cfg_set, "network/maxmin_selective_update");