factorize some more code so that supernovae works again

diff --git a/src/surf/cpu_cas01.c b/src/surf/cpu_cas01.c
index 10eb871..9998f86 100644 (file)
--- a/src/surf/cpu_cas01.c
+++ b/src/surf/cpu_cas01.c
@@ -47,34 +47,6 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_cpu, surf,
 static xbt_swag_t
     cpu_running_action_set_that_does_not_need_being_checked = NULL;
 
 static xbt_swag_t
     cpu_running_action_set_that_does_not_need_being_checked = NULL;
 

-/* added to manage the communication action's heap */
-static void net_action_update_index_heap(void *action, int i)
-{
-  surf_action_cpu_Cas01_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_cpu_Cas01_t action, double key,
-                        enum heap_action_type hat)
-{
-  GENERIC_LMM_ACTION(action).hat = hat;
-  xbt_heap_push(cpu_action_heap, action, key);
-}
-
-static void heap_remove(surf_action_cpu_Cas01_t action)
-{
-  GENERIC_LMM_ACTION(action).hat = NOTSET;
-  if (GENERIC_LMM_ACTION(action).index_heap >= 0) {
-    xbt_heap_remove(cpu_action_heap, GENERIC_LMM_ACTION(action).index_heap);
-  }
-}

 
 static void *cpu_create_resource(const char *name, double power_peak,
                                  double power_scale,
 
 static void *cpu_create_resource(const char *name, double power_peak,
                                  double power_scale,


@@ -183,7 +155,7 @@ static int cpu_action_unref(surf_action_t action)
                         ((surf_action_lmm_t) action)->variable);
     if (cpu_update_mechanism == UM_LAZY) {
       /* remove from heap */
                         ((surf_action_lmm_t) action)->variable);
     if (cpu_update_mechanism == UM_LAZY) {
       /* remove from heap */

-      heap_remove((surf_action_cpu_Cas01_t) action);
+      surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);

       xbt_swag_remove(action, cpu_modified_set);
     }
 #ifdef HAVE_TRACING
       xbt_swag_remove(action, cpu_modified_set);
     }
 #ifdef HAVE_TRACING


@@ -200,7 +172,7 @@ static void cpu_action_cancel(surf_action_t action)
   surf_action_state_set(action, SURF_ACTION_FAILED);
   if (cpu_update_mechanism == UM_LAZY) {
     xbt_swag_remove(action, cpu_modified_set);
   surf_action_state_set(action, SURF_ACTION_FAILED);
   if (cpu_update_mechanism == UM_LAZY) {
     xbt_swag_remove(action, cpu_modified_set);

-    heap_remove((surf_action_cpu_Cas01_t) action);
+    surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);

   }
   return;
 }
   }
   return;
 }


@@ -218,7 +190,7 @@ static void cpu_action_state_set(surf_action_t action,
   return;
 }
 
   return;
 }
 

-static void update_action_remaining_lazy(double now)
+static void cpu_update_action_remaining_lazy(double now)

 {
   surf_action_cpu_Cas01_t action;
   double delta = 0.0;
 {
   surf_action_cpu_Cas01_t action;
   double delta = 0.0;


@@ -268,7 +240,7 @@ static double cpu_share_resources_lazy(double now)
   XBT_DEBUG
       ("Before share resources, the size of modified actions set is %d",
        xbt_swag_size(cpu_modified_set));
   XBT_DEBUG
       ("Before share resources, the size of modified actions set is %d",
        xbt_swag_size(cpu_modified_set));

-  update_action_remaining_lazy(now);
+  cpu_update_action_remaining_lazy(now);

 
   lmm_solve(cpu_maxmin_system);
 
 
   lmm_solve(cpu_maxmin_system);
 


@@ -313,8 +285,8 @@ static double cpu_share_resources_lazy(double now)
         GENERIC_ACTION(action).max_duration);
 
     if (min != -1) {
         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(cpu_action_heap,(surf_action_lmm_t)action);
+      surf_action_lmm_heap_insert(cpu_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;
       XBT_DEBUG("Insert at heap action(%p) min %lf now %lf", action, min,
                 now);
     } else DIE_IMPOSSIBLE;


@@ -366,7 +338,7 @@ static void cpu_update_actions_state_lazy(double now, double delta)
     /* set the remains to 0 due to precision problems when updating the remaining amount */
     GENERIC_ACTION(action).remains = 0;
     cpu_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
     /* set the remains to 0 due to precision problems when updating the remaining amount */
     GENERIC_ACTION(action).remains = 0;
     cpu_action_state_set((surf_action_t) action, SURF_ACTION_DONE);

-    heap_remove(action);
+    surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);

   }
 #ifdef HAVE_TRACING
   if (TRACE_is_enabled()) {
   }
 #ifdef HAVE_TRACING
   if (TRACE_is_enabled()) {


@@ -542,7 +514,7 @@ static surf_action_t cpu_action_sleep(void *cpu, double duration)
   lmm_update_variable_weight(cpu_maxmin_system,
                              GENERIC_LMM_ACTION(action).variable, 0.0);
   if (cpu_update_mechanism == UM_LAZY) {     // remove action from the heap
   lmm_update_variable_weight(cpu_maxmin_system,
                              GENERIC_LMM_ACTION(action).variable, 0.0);
   if (cpu_update_mechanism == UM_LAZY) {     // remove action from the heap

-    heap_remove((surf_action_cpu_Cas01_t) action);
+    surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);

     // this is necessary for a variable with weight 0 since such
     // variables are ignored in lmm and we need to set its max_duration
     // correctly at the next call to share_resources
     // this is necessary for a variable with weight 0 since such
     // variables are ignored in lmm and we need to set its max_duration
     // correctly at the next call to share_resources


@@ -562,7 +534,7 @@ static void cpu_action_suspend(surf_action_t action)
                                0.0);
     ((surf_action_lmm_t) action)->suspended = 1;
     if (cpu_update_mechanism == UM_LAZY)
                                0.0);
     ((surf_action_lmm_t) action)->suspended = 1;
     if (cpu_update_mechanism == UM_LAZY)

-      heap_remove((surf_action_cpu_Cas01_t) action);
+      surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);

   }
   XBT_OUT();
 }
   }
   XBT_OUT();
 }


@@ -577,7 +549,7 @@ static void cpu_action_resume(surf_action_t action)
                                action->priority);
     ((surf_action_lmm_t) action)->suspended = 0;
     if (cpu_update_mechanism == UM_LAZY)
                                action->priority);
     ((surf_action_lmm_t) action)->suspended = 0;
     if (cpu_update_mechanism == UM_LAZY)

-      heap_remove((surf_action_cpu_Cas01_t) action);
+      surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);

   }
   XBT_OUT();
 }
   }
   XBT_OUT();
 }


@@ -594,7 +566,7 @@ static void cpu_action_set_max_duration(surf_action_t action,
 
   action->max_duration = duration;
   if (cpu_update_mechanism == UM_LAZY)
 
   action->max_duration = duration;
   if (cpu_update_mechanism == UM_LAZY)

-    heap_remove((surf_action_cpu_Cas01_t) action);
+    surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);

   XBT_OUT();
 }
 
   XBT_OUT();
 }
 


@@ -607,7 +579,7 @@ static void cpu_action_set_priority(surf_action_t action, double priority)
                              priority);
 
   if (cpu_update_mechanism == UM_LAZY)
                              priority);
 
   if (cpu_update_mechanism == UM_LAZY)

-    heap_remove((surf_action_cpu_Cas01_t) action);
+    surf_action_lmm_heap_remove(cpu_action_heap,(surf_action_lmm_t)action);

   XBT_OUT();
 }
 
   XBT_OUT();
 }
 


@@ -626,7 +598,7 @@ static double cpu_action_get_remains(surf_action_t action)
   XBT_IN("(%p)", action);
   /* update remains before return it */
   if (cpu_update_mechanism == UM_LAZY)
   XBT_IN("(%p)", action);
   /* update remains before return it */
   if (cpu_update_mechanism == UM_LAZY)

-    update_action_remaining_lazy(surf_get_clock());
+    cpu_update_action_remaining_lazy(surf_get_clock());

   XBT_OUT();
   return action->remains;
 }
   XBT_OUT();
   return action->remains;
 }


@@ -722,7 +694,7 @@ static void surf_cpu_model_init_internal()
   if (cpu_update_mechanism == UM_LAZY) {
     cpu_action_heap = xbt_heap_new(8, NULL);
     xbt_heap_set_update_callback(cpu_action_heap,
   if (cpu_update_mechanism == UM_LAZY) {
     cpu_action_heap = xbt_heap_new(8, NULL);
     xbt_heap_set_update_callback(cpu_action_heap,

-        net_action_update_index_heap);
+        surf_action_lmm_update_index_heap);

     cpu_modified_set =
         xbt_swag_new(xbt_swag_offset(comp, generic_lmm_action.action_list_hookup));
     cpu_maxmin_system->keep_track = cpu_modified_set;
     cpu_modified_set =
         xbt_swag_new(xbt_swag_offset(comp, generic_lmm_action.action_list_hookup));
     cpu_maxmin_system->keep_track = cpu_modified_set;

diff --git a/src/surf/cpu_ti.c b/src/surf/cpu_ti.c
index 0b9f262..b168b10 100644 (file)
--- a/src/surf/cpu_ti.c
+++ b/src/surf/cpu_ti.c
@@ -313,7 +313,6 @@ static void cpu_ti_action_state_set(surf_action_t action,
 */
 static void cpu_ti_update_remaining_amount(cpu_ti_t cpu, double now)
 {
 */
 static void cpu_ti_update_remaining_amount(cpu_ti_t cpu, double now)
 {

-#define GENERIC_ACTION(action) action->generic_action

   double area_total;
   surf_action_cpu_ti_t action;
 
   double area_total;
   surf_action_cpu_ti_t action;
 


@@ -329,13 +328,14 @@ static void cpu_ti_update_remaining_amount(cpu_ti_t cpu, double now)
          cpu->last_update);
 
   xbt_swag_foreach(action, cpu->action_set) {
          cpu->last_update);
 
   xbt_swag_foreach(action, cpu->action_set) {

+    surf_action_t generic = (surf_action_t)action;

     /* action not running, skip it */
     /* action not running, skip it */

-    if (GENERIC_ACTION(action).state_set !=
+    if (generic->state_set !=

         surf_cpu_model->states.running_action_set)
       continue;
 
     /* bogus priority, skip it */
         surf_cpu_model->states.running_action_set)
       continue;
 
     /* bogus priority, skip it */

-    if (GENERIC_ACTION(action).priority <= 0)
+    if (generic->priority <= 0)

       continue;
 
     /* action suspended, skip it */
       continue;
 
     /* action suspended, skip it */


@@ -343,20 +343,20 @@ static void cpu_ti_update_remaining_amount(cpu_ti_t cpu, double now)
       continue;
 
     /* action don't need update */
       continue;
 
     /* action don't need update */

-    if (GENERIC_ACTION(action).start >= now)
+    if (generic->start >= now)

       continue;
 
     /* skip action that are finishing now */
       continue;
 
     /* skip action that are finishing now */

-    if (GENERIC_ACTION(action).finish >= 0
-        && GENERIC_ACTION(action).finish <= now)
+    if (generic->finish >= 0
+        && generic->finish <= now)

       continue;
 
     /* update remaining */
       continue;
 
     /* update remaining */

-    double_update(&(GENERIC_ACTION(action).remains),
+    double_update(&(generic->remains),

                   area_total / (cpu->sum_priority *
                   area_total / (cpu->sum_priority *

-                                GENERIC_ACTION(action).priority));
+                                generic->priority));

     XBT_DEBUG("Update remaining action(%p) remaining %lf", action,
     XBT_DEBUG("Update remaining action(%p) remaining %lf", action,

-           GENERIC_ACTION(action).remains);
+           generic->remains);

   }
   cpu->last_update = now;
 #undef GENERIC_ACTION
   }
   cpu->last_update = now;
 #undef GENERIC_ACTION

diff --git a/src/surf/network.c b/src/surf/network.c
index 5156a31..4781065 100644 (file)
--- a/src/surf/network.c
+++ b/src/surf/network.c
@@ -59,39 +59,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 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;
 
 
 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                                */
 
 /******************************************************************************/
 /*                           Factors callbacks                                */


@@ -341,7 +313,7 @@ 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
                         ((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);
     }
     surf_action_free(&action);
       xbt_swag_remove(action, net_modified_set);
     }
     surf_action_free(&action);


@@ -358,7 +330,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);
   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);

   }
 }
 
   }
 }
 


@@ -377,44 +349,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 */
 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;
 }
 
   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) {
 
   double delta = 0.0;
 
   xbt_swag_foreach(action, net_modified_set) {
 

-    if (GENERIC_LMM_ACTION(action).suspended != 0) {
+    if (action->suspended != 0) {

       continue;
     }
 
       continue;
     }
 

-    delta = now - GENERIC_LMM_ACTION(action).last_update;
+    delta = now - action->last_update;

 
     double_update(&(((surf_action_t)action)->remains),
 
     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) &&
 
     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);
       ((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);
     } 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;

   }
 }
 
   }
 }
 


@@ -461,7 +433,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));
   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);
 
 
   lmm_solve(network_maxmin_system);
 


@@ -506,8 +478,8 @@ static double net_share_resources_lazy(double now)
               GENERIC_ACTION(action).max_duration);
 
     if (min != -1) {
               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;
       XBT_DEBUG("Insert at heap action(%p) min %lf now %lf", action, min,
                 now);
     } else DIE_IMPOSSIBLE;


@@ -633,7 +605,7 @@ static void net_update_actions_state_lazy(double now, double delta)
     if (GENERIC_LMM_ACTION(action).hat == LATENCY) {
       lmm_update_variable_weight(network_maxmin_system, GENERIC_LMM_ACTION(action).variable,
                                  action->weight);
     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
       GENERIC_LMM_ACTION(action).last_update = surf_get_clock();
 
       // if I am wearing a max_duration or normal hat


@@ -645,7 +617,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);
       ((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;
     }
   }
   return;


@@ -864,7 +836,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);
       // 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
                   xbt_dynar_is_empty(route) ? NORMAL : LATENCY);
     }
   } else


@@ -937,7 +909,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
                               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)
 }
 
 static void net_action_resume(surf_action_t action)


@@ -950,7 +922,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
                                 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);

   }
 }
 
   }
 }
 


@@ -963,7 +935,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
 {
   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
 }
 
 #ifdef HAVE_TRACING


@@ -1117,7 +1089,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,
   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;
     net_modified_set =
         xbt_swag_new(xbt_swag_offset(comm, generic_lmm_action.action_list_hookup));
     network_maxmin_system->keep_track = net_modified_set;

diff --git a/src/surf/surf_action.c b/src/surf/surf_action.c
index 49a22ff..0622378 100644 (file)
--- a/src/surf/surf_action.c
+++ b/src/surf/surf_action.c
@@ -154,12 +154,33 @@ XBT_INLINE void surf_action_ref(surf_action_t action)
   action->refcount++;
 }
 
   action->refcount++;
 }
 

-/*
-void surf_action_suspend(surf_action_t action)
-{
-  action->suspended = 1;
-}*/
-

 /*
  * Maxmin action
  */
 /*
  * Maxmin action
  */

+
+/* added to manage the communication action's heap */
+void surf_action_lmm_update_index_heap(void *action, int i) {
+  surf_action_lmm_t a = 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
+ */
+void surf_action_lmm_heap_insert(xbt_heap_t heap, surf_action_lmm_t action, double key,
+    enum heap_action_type hat)
+{
+  action->hat = hat;
+  xbt_heap_push(heap, action, key);
+}
+
+void surf_action_lmm_heap_remove(xbt_heap_t heap, surf_action_lmm_t action)
+{
+  action->hat = NOTSET;
+  if (action->index_heap >= 0) {
+    xbt_heap_remove(heap, action->index_heap);
+  }
+}

diff --git a/src/surf/surf_private.h b/src/surf/surf_private.h
index bb7ee78..d1a4ddc 100644 (file)
--- a/src/surf/surf_private.h
+++ b/src/surf/surf_private.h
@@ -66,6 +66,13 @@ void surf_action_free(surf_action_t * action);
 void surf_action_state_set(surf_action_t action,
                            e_surf_action_state_t state);
 void surf_action_data_set(surf_action_t action, void *data);    /* cannot declare inline since we use a pointer to it */
 void surf_action_state_set(surf_action_t action,
                            e_surf_action_state_t state);
 void surf_action_data_set(surf_action_t action, void *data);    /* cannot declare inline since we use a pointer to it */

+
+void surf_action_lmm_update_index_heap(void *action, int i); /* callback for heap management shared by cpu and net models */
+void surf_action_lmm_heap_insert(xbt_heap_t heap, surf_action_lmm_t action,
+    double key, enum heap_action_type hat);
+void surf_action_lmm_heap_remove(xbt_heap_t heap,surf_action_lmm_t action);
+
+

 FILE *surf_fopen(const char *name, const char *mode);
 
 extern tmgr_history_t history;
 FILE *surf_fopen(const char *name, const char *mode);
 
 extern tmgr_history_t history;