X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/ce47a7b1b7e9954d5dcbfddc94fa556ab6f7a197..5e5a85aa73a7854d577091848b08dec2351012ab:/src/surf/network.c

diff --git a/src/surf/network.c b/src/surf/network.c
index 9f3b07704b..493623e2d2 100644
--- a/src/surf/network.c
+++ b/src/surf/network.c
@@ -23,8 +23,11 @@
 #include "surf/surf_resource.h"
 #include "surf/surf_resource_lmm.h"
 
+#undef GENERIC_LMM_ACTION
 #undef GENERIC_ACTION
-#define GENERIC_ACTION(action) action->generic_action
+#define GENERIC_LMM_ACTION(action) (action)->generic_lmm_action
+#define GENERIC_ACTION(action) GENERIC_LMM_ACTION(action).generic_action
+
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_network, surf,
                                 "Logging specific to the SURF network module");
@@ -64,7 +67,8 @@ 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;
+  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)
@@ -77,15 +81,15 @@ static void net_action_update_index_heap(void *action, int i)
 static void heap_insert(surf_action_network_CM02_t action, double key,
                         enum heap_action_type hat)
 {
-  action->hat = 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)
 {
-  action->hat = NOTSET;
-  if (((surf_action_network_CM02_t) action)->index_heap >= 0) {
-    xbt_heap_remove(net_action_heap, action->index_heap);
+  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);
   }
 }
 
@@ -332,9 +336,9 @@ static int net_action_unref(surf_action_t action)
   action->refcount--;
   if (!action->refcount) {
     xbt_swag_remove(action, action->state_set);
-    if (((surf_action_network_CM02_t) action)->variable) {
+    if (((surf_action_lmm_t)action)->variable) {
       lmm_variable_free(network_maxmin_system,
-                        ((surf_action_network_CM02_t) action)->variable);
+                        ((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);
@@ -389,39 +393,39 @@ static void update_action_remaining_lazy(double now)
 
   xbt_swag_foreach(action, net_modified_set) {
 
-    if (action->suspended != 0) {
+    if (GENERIC_LMM_ACTION(action).suspended != 0) {
       continue;
     }
 
-    delta = now - action->last_update;
+    delta = now - GENERIC_LMM_ACTION(action).last_update;
 
-    double_update(&(action->generic_action.remains),
-                  lmm_variable_getvalue(action->variable) * delta);
+    double_update(&(((surf_action_t)action)->remains),
+                  lmm_variable_getvalue(((surf_action_lmm_t) action)->variable) * delta);
 
-    if (action->generic_action.max_duration != NO_MAX_DURATION)
-      double_update(&(action->generic_action.max_duration), delta);
+    if (((surf_action_t)action)->max_duration != NO_MAX_DURATION)
+      double_update(&(((surf_action_t)action)->max_duration), delta);
 
-    if ((action->generic_action.remains <= 0) &&
-        (lmm_get_variable_weight(action->variable) > 0)) {
-      action->generic_action.finish = surf_get_clock();
+    if ((((surf_action_t)action)->remains <= 0) &&
+        (lmm_get_variable_weight(((surf_action_lmm_t)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);
-    } else if ((action->generic_action.max_duration != NO_MAX_DURATION)
-               && (action->generic_action.max_duration <= 0)) {
-      action->generic_action.finish = surf_get_clock();
+    } 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);
     }
 
-    action->last_update = now;
+    GENERIC_LMM_ACTION(action).last_update = now;
   }
 }
 
 static double net_share_resources_full(double now)
 {
-  s_surf_action_network_CM02_t s_action;
+  s_surf_action_lmm_t s_action;
   surf_action_network_CM02_t action = NULL;
   xbt_swag_t running_actions =
       surf_network_model->states.running_action_set;
@@ -438,9 +442,9 @@ 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)) {
-      (action->generic_action).latency_limited = 1;
+      GENERIC_LMM_ACTION(action).latency_limited = 1;
     } else {
-      (action->generic_action).latency_limited = 0;
+      GENERIC_LMM_ACTION(action).latency_limited = 0;
     }
 #endif
     if (action->latency > 0) {
@@ -474,17 +478,15 @@ static double net_share_resources_lazy(double now)
     int max_dur_flag = 0;
 
     if (GENERIC_ACTION(action).state_set !=
-        surf_network_model->states.running_action_set) {
+        surf_network_model->states.running_action_set)
       continue;
-    }
 
     /* bogus priority, skip it */
-    if (GENERIC_ACTION(action).priority <= 0) {
+    if (GENERIC_ACTION(action).priority <= 0)
       continue;
-    }
 
     min = -1;
-    value = lmm_variable_getvalue(action->variable);
+    value = lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable);
     if (value > 0) {
       if (GENERIC_ACTION(action).remains > 0) {
         value = GENERIC_ACTION(action).remains / value;
@@ -508,24 +510,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);
+      heap_remove(action);
+      heap_insert(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);
 
@@ -554,8 +551,8 @@ static void net_update_actions_state_full(double now, double delta)
         double_update(&(deltap), action->latency);
         action->latency = 0.0;
       }
-      if ((action->latency == 0.0) && !(action->suspended))
-        lmm_update_variable_weight(network_maxmin_system, action->variable,
+      if ((action->latency == 0.0) && !(GENERIC_LMM_ACTION(action).suspended))
+        lmm_update_variable_weight(network_maxmin_system, GENERIC_LMM_ACTION(action).variable,
                                    action->weight);
     }
 #ifdef HAVE_TRACING
@@ -567,40 +564,39 @@ static void net_update_actions_state_full(double now, double delta)
       unsigned int i;
       xbt_dynar_foreach(route, i, link) {
         TRACE_surf_link_set_utilization(link->lmm_resource.
-                                        generic_resource.name,
-                                        action->generic_action.data,
-                                        (surf_action_t) action,
-                                        lmm_variable_getvalue(action->
-                                                              variable),
-                                        now - delta, delta);
+            generic_resource.name,
+            GENERIC_ACTION(action).data,
+            (surf_action_t) action,
+            lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable),
+            now - delta, delta);
       }
     }
 #endif
     if (!lmm_get_number_of_cnst_from_var
-        (network_maxmin_system, action->variable)) {
+        (network_maxmin_system, GENERIC_LMM_ACTION(action).variable)) {
       /* There is actually no link used, hence an infinite bandwidth.
        * This happens often when using models like vivaldi.
        * In such case, just make sure that the action completes immediately.
        */
-      double_update(&(action->generic_action.remains),
-                    action->generic_action.remains);
+      double_update(&(GENERIC_ACTION(action).remains),
+                    GENERIC_ACTION(action).remains);
     }
-    double_update(&(action->generic_action.remains),
-                  lmm_variable_getvalue(action->variable) * deltap);
-    if (action->generic_action.max_duration != NO_MAX_DURATION)
-      double_update(&(action->generic_action.max_duration), delta);
-
-    if ((action->generic_action.remains <= 0) &&
-        (lmm_get_variable_weight(action->variable) > 0)) {
-      action->generic_action.finish = surf_get_clock();
+    double_update(&(GENERIC_ACTION(action).remains),
+                  lmm_variable_getvalue(GENERIC_LMM_ACTION(action).variable) * deltap);
+    if (((surf_action_t)action)->max_duration != NO_MAX_DURATION)
+      double_update(&(((surf_action_t)action)->max_duration), delta);
+
+    if ((GENERIC_ACTION(action).remains <= 0) &&
+        (lmm_get_variable_weight(GENERIC_LMM_ACTION(action).variable) > 0)) {
+      ((surf_action_t)action)->finish = surf_get_clock();
       surf_network_model->action_state_set((surf_action_t) action,
                                            SURF_ACTION_DONE);
 
       if (gap_remove)
         gap_remove(action);
-    } else if ((action->generic_action.max_duration != NO_MAX_DURATION)
-               && (action->generic_action.max_duration <= 0)) {
-      action->generic_action.finish = surf_get_clock();
+    } 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);
       if (gap_remove)
@@ -622,18 +618,19 @@ static void net_update_actions_state_lazy(double now, double delta)
     GENERIC_ACTION(action).finish = surf_get_clock();
 
     // if I am wearing a latency hat
-    if (action->hat == LATENCY) {
-      lmm_update_variable_weight(network_maxmin_system, action->variable,
+    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();
+      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;
-      action->generic_action.finish = surf_get_clock();
+      ((surf_action_t)action)->finish = surf_get_clock();
       surf_network_model->action_state_set((surf_action_t) action,
                                            SURF_ACTION_DONE);
       heap_remove(action);
@@ -681,9 +678,9 @@ static void net_update_resource_state(void *id,
                &elem))) {
         action = lmm_variable_id(var);
         action->weight += delta;
-        if (!(action->suspended))
+        if (!(GENERIC_LMM_ACTION(action).suspended))
           lmm_update_variable_weight(network_maxmin_system,
-                                     action->variable, action->weight);
+                                     GENERIC_LMM_ACTION(action).variable, action->weight);
       }
     }
     if (tmgr_trace_event_free(event_type))
@@ -702,11 +699,11 @@ static void net_update_resource_state(void *id,
       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_maxmin_system, GENERIC_LMM_ACTION(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_maxmin_system, GENERIC_LMM_ACTION(action).variable,
                                   min(action->rate,
                                       sg_tcp_gamma / (2.0 *
                                                       action->
@@ -719,8 +716,8 @@ static void net_update_resource_state(void *id,
                    action->lat_current);
         }
       }
-      if (!(action->suspended))
-        lmm_update_variable_weight(network_maxmin_system, action->variable,
+      if (!(GENERIC_LMM_ACTION(action).suspended))
+        lmm_update_variable_weight(network_maxmin_system, GENERIC_LMM_ACTION(action).variable,
                                    action->weight);
 
     }
@@ -802,15 +799,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
-  (action->generic_action).latency_limited = 0;
+  (GENERIC_LMM_ACTION(action)).latency_limited = 0;
 #endif
   action->weight = action->latency = latency;
 
-  xbt_swag_insert(action, action->generic_action.state_set);
+  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;
@@ -848,28 +845,28 @@ static surf_action_t net_communicate(const char *src_name,
     constraints_per_variable += xbt_dynar_length(back_route);
 
   if (action->latency > 0) {
-    action->variable =
+    GENERIC_LMM_ACTION(action).variable =
         lmm_variable_new(network_maxmin_system, action, 0.0, -1.0,
                          constraints_per_variable);
     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);
+      heap_insert(action, action->latency + GENERIC_LMM_ACTION(action).last_update,
                   xbt_dynar_is_empty(route) ? NORMAL : LATENCY);
     }
   } else
-    action->variable =
+    GENERIC_LMM_ACTION(action).variable =
         lmm_variable_new(network_maxmin_system, action, 1.0, -1.0,
                          constraints_per_variable);
 
   if (action->rate < 0) {
-    lmm_update_variable_bound(network_maxmin_system, action->variable,
+    lmm_update_variable_bound(network_maxmin_system, GENERIC_LMM_ACTION(action).variable,
                               (action->lat_current > 0) ?
                               sg_tcp_gamma / (2.0 *
                                               action->lat_current) : -1.0);
   } else {
-    lmm_update_variable_bound(network_maxmin_system, action->variable,
+    lmm_update_variable_bound(network_maxmin_system, GENERIC_LMM_ACTION(action).variable,
                               (action->lat_current > 0) ?
                               min(action->rate,
                                   sg_tcp_gamma / (2.0 *
@@ -879,14 +876,14 @@ static surf_action_t net_communicate(const char *src_name,
 
   xbt_dynar_foreach(route, i, link) {
     lmm_expand(network_maxmin_system, link->lmm_resource.constraint,
-               action->variable, 1.0);
+               GENERIC_LMM_ACTION(action).variable, 1.0);
   }
 
   if (sg_network_crosstraffic == 1) {
     XBT_DEBUG("Fullduplex active adding backward flow using 5%%");
     xbt_dynar_foreach(back_route, i, link) {
       lmm_expand(network_maxmin_system, link->lmm_resource.constraint,
-                 action->variable, .05);
+                 GENERIC_LMM_ACTION(action).variable, .05);
     }
   }
 #ifdef HAVE_TRACING
@@ -930,10 +927,10 @@ static int net_link_shared(const void *link)
 
 static void net_action_suspend(surf_action_t action)
 {
-  ((surf_action_network_CM02_t) action)->suspended = 1;
+  ((surf_action_network_CM02_t) action)->generic_lmm_action.suspended = 1;
   lmm_update_variable_weight(network_maxmin_system,
                              ((surf_action_network_CM02_t)
-                              action)->variable, 0.0);
+                              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);
@@ -941,13 +938,13 @@ static void net_action_suspend(surf_action_t action)
 
 static void net_action_resume(surf_action_t action)
 {
-  if (((surf_action_network_CM02_t) action)->suspended) {
+  if (((surf_action_network_CM02_t) action)->generic_lmm_action.suspended) {
     lmm_update_variable_weight(network_maxmin_system,
                                ((surf_action_network_CM02_t)
-                                action)->variable,
+                                action)->generic_lmm_action.variable,
                                ((surf_action_network_CM02_t)
                                 action)->weight);
-    ((surf_action_network_CM02_t) action)->suspended = 0;
+    ((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);
   }
@@ -955,7 +952,7 @@ static void net_action_resume(surf_action_t action)
 
 static int net_action_is_suspended(surf_action_t action)
 {
-  return ((surf_action_network_CM02_t) action)->suspended;
+  return ((surf_action_network_CM02_t) action)->generic_lmm_action.suspended;
 }
 
 void net_action_set_max_duration(surf_action_t action, double duration)
@@ -1118,7 +1115,7 @@ static void surf_network_model_init_internal(void)
     xbt_heap_set_update_callback(net_action_heap,
                                  net_action_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;
   }
 }