X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9d765a692e8aae0c06d16ce6d7db2acdd0b3b63d..03080afc0b77477ba20511c9cafd53eae962c730:/src/surf/network.c

diff --git a/src/surf/network.c b/src/surf/network.c
index 5df9715530..5afe01f560 100644
--- a/src/surf/network.c
+++ b/src/surf/network.c
@@ -45,6 +45,7 @@ typedef struct s_smpi_factor {
   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 */
@@ -59,38 +60,11 @@ e_UM_t network_update_mechanism = UM_UNDEFINED;
 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                                */
@@ -226,6 +200,7 @@ static void *net_create_resource(const char *name,
     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;
 }
@@ -340,13 +315,11 @@ static int net_action_unref(surf_action_t action)
                         ((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);
+    if (action->category) xbt_free (action->category);
 #endif
     surf_action_free(&action);
     return 1;
@@ -362,7 +335,7 @@ static void net_action_cancel(surf_action_t action)
   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);
   }
 }
 
@@ -381,41 +354,41 @@ int net_get_link_latency_limited(surf_action_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;
@@ -440,10 +413,10 @@ static double net_share_resources_full(double 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) {
@@ -465,7 +438,7 @@ static double net_share_resources_lazy(double now)
   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);
 
@@ -481,9 +454,8 @@ static double net_share_resources_lazy(double now)
       continue;
 
     /* bogus priority, skip it */
-    if (GENERIC_ACTION(action).priority <= 0) {
+    if (GENERIC_ACTION(action).priority <= 0)
       continue;
-    }
 
     min = -1;
     value = lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable);
@@ -510,24 +482,19 @@ static double net_share_resources_lazy(double now)
               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
-  if (xbt_heap_size(net_action_heap) > 0) {
+  if (xbt_heap_size(net_action_heap) > 0)
     min = xbt_heap_maxkey(net_action_heap) - now;
-  } else {
+  else
     min = -1;
-  }
 
   XBT_DEBUG("The minimum with the HEAP %lf", min);
 
@@ -562,19 +529,18 @@ static void net_update_actions_state_full(double now, double delta)
     }
 #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
@@ -622,23 +588,41 @@ static void net_update_actions_state_lazy(double now, double delta)
     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;
@@ -762,9 +746,9 @@ static void net_update_resource_state(void *id,
 }
 
 
-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;
@@ -777,12 +761,12 @@ static surf_action_t net_communicate(const char *src_name,
 
   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) {
@@ -791,7 +775,7 @@ static surf_action_t net_communicate(const char *src_name,
     }
   }
   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;
@@ -804,15 +788,15 @@ static surf_action_t net_communicate(const char *src_name,
       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;
@@ -841,7 +825,7 @@ static surf_action_t net_communicate(const char *src_name,
     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);
   }
 
@@ -856,8 +840,8 @@ static surf_action_t net_communicate(const char *src_name,
     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
@@ -891,14 +875,6 @@ static surf_action_t net_communicate(const char *src_name,
                  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();
@@ -906,7 +882,7 @@ static surf_action_t net_communicate(const char *src_name,
   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);
@@ -938,7 +914,7 @@ static void net_action_suspend(surf_action_t action)
                               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)
@@ -951,7 +927,7 @@ 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);
   }
 }
 
@@ -964,7 +940,7 @@ void net_action_set_max_duration(surf_action_t action, double duration)
 {
   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
@@ -1118,19 +1094,15 @@ static void surf_network_model_init_internal(void)
   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");