X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8903a9aabbc969129dbda1a414045cc7dfec98fb..23e3b951a5bc0e18ab5de0edbed5be9d5e334ef7:/src/surf/network.c

diff --git a/src/surf/network.c b/src/surf/network.c
index de14baad11..f8c22b0fd3 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,39 +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 a = action;
-  GENERIC_LMM_ACTION(a).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)
-{
-  GENERIC_LMM_ACTION(action).hat = hat;
-  xbt_heap_push(net_action_heap, action, key);
-}
-
-static void heap_remove(surf_action_network_CM02_t action)
-{
-  GENERIC_LMM_ACTION(action).hat = NOTSET;
-  if (GENERIC_LMM_ACTION(action).index_heap >= 0) {
-    xbt_heap_remove(net_action_heap, GENERIC_LMM_ACTION(action).index_heap);
-  }
-}
 
 /******************************************************************************/
 /*                           Factors callbacks                                */
@@ -341,14 +314,9 @@ 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);
-#endif
     surf_action_free(&action);
     return 1;
   }
@@ -363,7 +331,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);
   }
 }
 
@@ -382,44 +350,44 @@ 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 - GENERIC_LMM_ACTION(action).last_update;
+    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);
     }
 
-    GENERIC_LMM_ACTION(action).last_update = now;
+    action->last_update = now;
   }
 }
 
@@ -441,10 +409,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) {
@@ -466,7 +434,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);
 
@@ -511,8 +479,8 @@ static double net_share_resources_lazy(double now)
               GENERIC_ACTION(action).max_duration);
 
     if (min != -1) {
-      heap_remove(action);
-      heap_insert(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;
@@ -616,12 +584,29 @@ 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 (GENERIC_LMM_ACTION(action).hat == LATENCY) {
       lmm_update_variable_weight(network_maxmin_system, GENERIC_LMM_ACTION(action).variable,
                                  action->weight);
-      heap_remove(action);
+      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
@@ -633,7 +618,7 @@ static void net_update_actions_state_lazy(double now, double delta)
       ((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;
@@ -757,8 +742,8 @@ static void net_update_resource_state(void *id,
 }
 
 
-static surf_action_t net_communicate(const char *src_name,
-                                     const char *dst_name, double size,
+static surf_action_t net_communicate(void *src,
+                                     void *dst, double size,
                                      double rate)
 {
   unsigned int i;
@@ -772,12 +757,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)", ((network_element_t)src)->name, ((network_element_t)dst)->name, size, rate);
 
-  routing_get_route_and_latency(src_name, dst_name, &route, &latency);
+  routing_get_route_and_latency((network_element_t)src, (network_element_t)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);
+             ((network_element_t)src)->name, ((network_element_t)dst)->name);
 
   xbt_dynar_foreach(route, i, link) {
     if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
@@ -786,7 +771,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((network_element_t)dst, (network_element_t)src, &back_route, NULL);
     xbt_dynar_foreach(back_route, i, link) {
       if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
         failed = 1;
@@ -799,7 +784,7 @@ 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;
 
@@ -836,7 +821,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, ((network_element_t)src)->name, ((network_element_t)dst)->name, action->sender.gap,
               action->latency);
   }
 
@@ -852,7 +837,7 @@ static surf_action_t net_communicate(const char *src_name,
       // 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 + GENERIC_LMM_ACTION(action).last_update);
-      heap_insert(action, 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
@@ -886,14 +871,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();
@@ -901,7 +878,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);
@@ -933,7 +910,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)
@@ -946,7 +923,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);
   }
 }
 
@@ -959,7 +936,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
@@ -1113,7 +1090,7 @@ 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, generic_lmm_action.action_list_hookup));
     network_maxmin_system->keep_track = net_modified_set;
@@ -1122,10 +1099,6 @@ static void surf_network_model_init_internal(void)
 
 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");