X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/2703e1ee2a79e9fc7c86ebb122caa515ecf24d14..b3b356352e87ae00a20f737c48e19b0c8413455a:/src/simdag/sd_task.c

diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c
index af052fb289..c55d588f79 100644
--- a/src/simdag/sd_task.c
+++ b/src/simdag/sd_task.c
@@ -1,11 +1,11 @@
-/* Copyright (c) 2006 - 2013. The SimGrid Team.
+/* Copyright (c) 2006-2015. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "private.h"
-#include "simdag/simdag.h"
+#include "simgrid/simdag.h"
 #include "xbt/sysdep.h"
 #include "xbt/dynar.h"
 #include "instr/instr_private.h"
@@ -55,8 +55,8 @@ void SD_task_recycle_f(void *t)
   /* scheduling parameters */
   task->workstation_nb = 0;
   task->workstation_list = NULL;
-  task->computation_amount = NULL;
-  task->communication_amount = NULL;
+  task->flops_amount = NULL;
+  task->bytes_amount = NULL;
   task->rate = -1;
 }
 
@@ -90,9 +90,7 @@ SD_task_t SD_task_create(const char *name, void *data, double amount)
 
   sd_global->task_number++;
 
-#ifdef HAVE_TRACING
   TRACE_sd_task_create(task);
-#endif
 
   return task;
 }
@@ -102,8 +100,8 @@ static XBT_INLINE SD_task_t SD_task_create_sized(const char *name,
                                                  int ws_count)
 {
   SD_task_t task = SD_task_create(name, data, amount);
-  task->communication_amount = xbt_new0(double, ws_count * ws_count);
-  task->computation_amount = xbt_new0(double, ws_count);
+  task->bytes_amount = xbt_new0(double, ws_count * ws_count);
+  task->flops_amount = xbt_new0(double, ws_count);
   task->workstation_nb = ws_count;
   task->workstation_list = xbt_new0(SD_workstation_t, ws_count);
   return task;
@@ -123,13 +121,11 @@ SD_task_t SD_task_create_comm_e2e(const char *name, void *data,
                                   double amount)
 {
   SD_task_t res = SD_task_create_sized(name, data, amount, 2);
-  res->communication_amount[2] = amount;
+  res->bytes_amount[2] = amount;
   res->kind = SD_TASK_COMM_E2E;
 
-#ifdef HAVE_TRACING
   TRACE_category("COMM_E2E");
   TRACE_sd_set_task_category(res, "COMM_E2E");
-#endif
 
   return res;
 }
@@ -146,22 +142,20 @@ SD_task_t SD_task_create_comm_e2e(const char *name, void *data,
  *
  * \param name the name of the task (can be \c NULL)
  * \param data the user data you want to associate with the task (can be \c NULL)
- * \param amount amount of compute work to be done by the task
+ * \param flops_amount amount of compute work to be done by the task
  * \return the new SD_TASK_COMP_SEQ typed task
  */
 SD_task_t SD_task_create_comp_seq(const char *name, void *data,
-                                  double amount)
+                                  double flops_amount)
 {
-  SD_task_t res = SD_task_create_sized(name, data, amount, 1);
-  res->computation_amount[0] = amount;
+  SD_task_t res = SD_task_create_sized(name, data, flops_amount, 1);
+  res->flops_amount[0] = flops_amount;
   res->kind = SD_TASK_COMP_SEQ;
 
-#ifdef HAVE_TRACING
   TRACE_category("COMP_SEQ");
   TRACE_sd_set_task_category(res, "COMP_SEQ");
-#endif
 
-return res;
+  return res;
 }
 
 /** @brief create a parallel computation task that can then be auto-scheduled
@@ -172,29 +166,27 @@ return res;
  * mandatory power.
  *
  * A parallel computation can be scheduled on any number of host.
- * The underlying speedup model is Amdahl's law. 
- * To be auto-scheduled, \see SD_task_distribute_comp_amdhal has to be called 
+ * The underlying speedup model is Amdahl's law.
+ * To be auto-scheduled, \see SD_task_distribute_comp_amdahl has to be called
  * first.
  * \param name the name of the task (can be \c NULL)
  * \param data the user data you want to associate with the task (can be \c NULL)
- * \param amount amount of compute work to be done by the task
+ * \param flops_amount amount of compute work to be done by the task
  * \param alpha purely serial fraction of the work to be done (in [0.;1.[)
  * \return the new task
  */
 SD_task_t SD_task_create_comp_par_amdahl(const char *name, void *data,
-                                  double amount, double alpha)
+                                  double flops_amount, double alpha)
 {
   xbt_assert(alpha < 1. && alpha >= 0.,
               "Invalid parameter: alpha must be in [0.;1.[");
   
-  SD_task_t res = SD_task_create(name, data, amount);
+  SD_task_t res = SD_task_create(name, data, flops_amount);
   res->alpha = alpha;
   res->kind = SD_TASK_COMP_PAR_AMDAHL;
 
-#ifdef HAVE_TRACING
   TRACE_category("COMP_PAR_AMDAHL");
   TRACE_sd_set_task_category(res, "COMP_PAR_AMDAHL");
-#endif
 
   return res;
 }
@@ -225,10 +217,8 @@ SD_task_t SD_task_create_comm_par_mxn_1d_block(const char *name, void *data,
   res->workstation_list=NULL;
   res->kind = SD_TASK_COMM_PAR_MXN_1D_BLOCK;
 
-#ifdef HAVE_TRACING
   TRACE_category("COMM_PAR_MXN_1D_BLOCK");
   TRACE_sd_set_task_category(res, "COMM_PAR_MXN_1D_BLOCK");
-#endif
 
   return res;
 }
@@ -257,15 +247,13 @@ void SD_task_destroy(SD_task_t task)
   xbt_free(task->name);
 
   if (task->surf_action != NULL)
-    surf_workstation_model->action_unref(task->surf_action);
+	surf_action_unref(task->surf_action);
 
   xbt_free(task->workstation_list);
-  xbt_free(task->communication_amount);
-  xbt_free(task->computation_amount);
+  xbt_free(task->bytes_amount);
+  xbt_free(task->flops_amount);
 
-#ifdef HAVE_TRACING
   TRACE_sd_task_destroy(task);
-#endif
 
   xbt_mallocator_release(sd_global->task_mallocator,task);
   sd_global->task_number--;
@@ -304,9 +292,10 @@ void SD_task_set_data(SD_task_t task, void *data)
  * \brief Sets the rate of a task
  *
  * This will change the network bandwidth a task can use. This rate
- * depends on both the nominal bandwidth on the route onto which the task is
- * scheduled (\see SD_task_get_current_bandwidth) and the amount of data to
- * transfer.
+ * cannot be dynamically changed. Once the task has started, this call
+ * is ineffective. This rate depends on both the nominal bandwidth on
+ * the route onto which the task is scheduled (\see
+ * SD_task_get_current_bandwidth) and the amount of data to transfer.
  *
  * To divide the nominal bandwidth by 2, the rate then has to be :
  *    rate = bandwidth/(2*amount)
@@ -318,8 +307,11 @@ void SD_task_set_rate(SD_task_t task, double rate)
 {
   xbt_assert(task->kind == SD_TASK_COMM_E2E,
              "The rate can be modified for end-to-end communications only.");
-
-  task->rate = rate;
+  if(task->start_time<0) {
+    task->rate = rate;
+  } else {
+    XBT_WARN("Task %p has started. Changing rate is ineffective.", task);
+  }
 }
 
 /**
@@ -358,13 +350,11 @@ void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
     break;
   case SD_RUNNING:
     task->state_set = sd_global->running_task_set;
-    task->start_time =
-        surf_workstation_model->action_get_start_time(task->surf_action);
+    task->start_time = surf_action_get_start_time(task->surf_action);
     break;
   case SD_DONE:
     task->state_set = sd_global->done_task_set;
-    task->finish_time =
-        surf_workstation_model->action_get_finish_time(task->surf_action);
+    task->finish_time = surf_action_get_finish_time(task->surf_action);
     task->remains = 0;
 #ifdef HAVE_JEDULE
     jedule_log_sd_event(task);
@@ -476,7 +466,27 @@ double SD_task_get_amount(SD_task_t task)
 }
 
 /**
- * \brief Returns the alpha parameter of a SD_TASK_COMP_PAR_AMDAH task
+ * \brief Sets the total amount of work of a task
+ * For sequential typed tasks (COMP_SEQ and COMM_E2E), it also sets the
+ * appropriate values in the flops_amount and bytes_amount arrays
+ * respectively. Nothing more than modifying task->amount is done for paralle
+ * typed tasks (COMP_PAR_AMDAHL and COMM_PAR_MXN_1D_BLOCK) as the distribution
+ * of the amount of work is done at scheduling time.
+ *
+ * \param task a task
+ * \param amount the new amount of work to execute
+ */
+void SD_task_set_amount(SD_task_t task, double amount)
+{
+  task->amount = amount;
+  if (task->kind == SD_TASK_COMP_SEQ)
+    task->flops_amount[0] = amount;
+  if (task->kind == SD_TASK_COMM_E2E)
+    task->bytes_amount[2] = amount;
+}
+
+/**
+ * \brief Returns the alpha parameter of a SD_TASK_COMP_PAR_AMDAHL task
  *
  * \param task a parallel task assuming Amdahl's law as speedup model
  * \return the alpha parameter (serial part of a task in percent) for this task
@@ -499,7 +509,7 @@ double SD_task_get_alpha(SD_task_t task)
 double SD_task_get_remaining_amount(SD_task_t task)
 {
   if (task->surf_action)
-    return surf_workstation_model->get_remains(task->surf_action);
+	return surf_action_get_remains(task->surf_action);
   else
     return task->remains;
 }
@@ -550,10 +560,8 @@ void SD_task_dump(SD_task_t task)
     }
   }
 
-#ifdef HAVE_TRACING
   if (task->category)
     XBT_INFO("  - tracing category: %s", task->category);
-#endif
 
   XBT_INFO("  - amount: %.0f", SD_task_get_amount(task));
   if (task->kind == SD_TASK_COMP_PAR_AMDAHL)
@@ -905,16 +913,16 @@ void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state)
  * \param task the task to evaluate
  * \param workstation_nb number of workstations on which the task would be executed
  * \param workstation_list the workstations on which the task would be executed
- * \param computation_amount computation amount for each workstation
- * \param communication_amount communication amount between each pair of workstations
+ * \param flops_amount computation amount for each workstation
+ * \param bytes_amount communication amount between each pair of workstations
  * \see SD_schedule()
  */
 double SD_task_get_execution_time(SD_task_t task,
                                   int workstation_nb,
                                   const SD_workstation_t *
                                   workstation_list,
-                                  const double *computation_amount,
-                                  const double *communication_amount)
+                                  const double *flops_amount,
+                                  const double *bytes_amount)
 {
   double time, max_time = 0.0;
   int i, j;
@@ -924,17 +932,17 @@ double SD_task_get_execution_time(SD_task_t task,
 
   for (i = 0; i < workstation_nb; i++) {
     time = 0.0;
-    if (computation_amount != NULL)
+    if (flops_amount != NULL)
       time =
           SD_workstation_get_computation_time(workstation_list[i],
-                                              computation_amount[i]);
+                                              flops_amount[i]);
 
-    if (communication_amount != NULL)
+    if (bytes_amount != NULL)
       for (j = 0; j < workstation_nb; j++) {
         time +=
             SD_route_get_communication_time(workstation_list[i],
                                             workstation_list[j],
-                                            communication_amount[i *
+                                            bytes_amount[i *
                                                                  workstation_nb
                                                                  + j]);
       }
@@ -969,15 +977,15 @@ static XBT_INLINE void SD_task_do_schedule(SD_task_t task)
  * \param task the task you want to schedule
  * \param workstation_count number of workstations on which the task will be executed
  * \param workstation_list the workstations on which the task will be executed
- * \param computation_amount computation amount for each workstation
- * \param communication_amount communication amount between each pair of workstations
+ * \param flops_amount computation amount for each workstation
+ * \param bytes_amount communication amount between each pair of workstations
  * \param rate task execution speed rate
  * \see SD_task_unschedule()
  */
 void SD_task_schedule(SD_task_t task, int workstation_count,
                       const SD_workstation_t * workstation_list,
-                      const double *computation_amount,
-                      const double *communication_amount, double rate)
+                      const double *flops_amount,
+                      const double *bytes_amount, double rate)
 {
   int communication_nb;
   task->workstation_nb = 0;
@@ -987,25 +995,25 @@ void SD_task_schedule(SD_task_t task, int workstation_count,
   task->workstation_nb = workstation_count;
   task->rate = rate;
 
-  if (computation_amount) {
-    task->computation_amount = xbt_realloc(task->computation_amount,
+  if (flops_amount) {
+    task->flops_amount = xbt_realloc(task->flops_amount,
                                            sizeof(double) * workstation_count);
-    memcpy(task->computation_amount, computation_amount,
+    memcpy(task->flops_amount, flops_amount,
            sizeof(double) * workstation_count);
   } else {
-    xbt_free(task->computation_amount);
-    task->computation_amount = NULL;
+    xbt_free(task->flops_amount);
+    task->flops_amount = NULL;
   }
 
   communication_nb = workstation_count * workstation_count;
-  if (communication_amount) {
-    task->communication_amount = xbt_realloc(task->communication_amount,
+  if (bytes_amount) {
+    task->bytes_amount = xbt_realloc(task->bytes_amount,
                                              sizeof(double) * communication_nb);
-    memcpy(task->communication_amount, communication_amount,
+    memcpy(task->bytes_amount, bytes_amount,
            sizeof(double) * communication_nb);
   } else {
-    xbt_free(task->communication_amount);
-    task->communication_amount = NULL;
+    xbt_free(task->bytes_amount);
+    task->bytes_amount = NULL;
   }
 
   task->workstation_list =
@@ -1047,7 +1055,7 @@ void SD_task_unschedule(SD_task_t task)
   }
 
   if (__SD_task_is_running(task))       /* the task should become SD_FAILED */
-    surf_workstation_model->action_cancel(task->surf_action);
+	surf_action_cancel(task->surf_action);
   else {
     if (task->unsatisfied_dependencies == 0)
       __SD_task_set_state(task, SD_SCHEDULABLE);
@@ -1069,9 +1077,9 @@ static void __SD_task_destroy_scheduling_data(SD_task_t task)
            "Task '%s' must be SD_SCHEDULED, SD_RUNNABLE or SD_IN_FIFO",
            SD_task_get_name(task));
 
-  xbt_free(task->computation_amount);
-  xbt_free(task->communication_amount);
-  task->computation_amount = task->communication_amount = NULL;
+  xbt_free(task->flops_amount);
+  xbt_free(task->bytes_amount);
+  task->flops_amount = task->bytes_amount = NULL;
 }
 
 /* Runs a task. This function is directly called by __SD_task_try_to_run if
@@ -1082,7 +1090,7 @@ void __SD_task_really_run(SD_task_t task)
 {
 
   int i;
-  void **surf_workstations;
+  sg_host_t *hosts;
 
   xbt_assert(__SD_task_is_runnable_or_in_fifo(task),
               "Task '%s' is not runnable or in a fifo! Task state: %d",
@@ -1092,13 +1100,13 @@ void __SD_task_really_run(SD_task_t task)
               SD_task_get_name(task));
 
   XBT_DEBUG("Really running task '%s'", SD_task_get_name(task));
-  int workstation_nb = task->workstation_nb;
+  int host_nb = task->workstation_nb;
 
   /* set this task as current task for the workstations in sequential mode */
-  for (i = 0; i < workstation_nb; i++) {
+  for (i = 0; i < host_nb; i++) {
     if (SD_workstation_get_access_mode(task->workstation_list[i]) ==
         SD_WORKSTATION_SEQUENTIAL_ACCESS) {
-      SD_workstation_priv(task->workstation_list[i])->current_task = task;
+    	sg_host_sd(task->workstation_list[i])->current_task = task;
       xbt_assert(__SD_workstation_is_busy(task->workstation_list[i]),
                   "The workstation should be busy now");
     }
@@ -1109,40 +1117,36 @@ void __SD_task_really_run(SD_task_t task)
 
   /* start the task */
 
-  /* we have to create a Surf workstation array instead of the SimDag
-   * workstation array */
-  surf_workstations = xbt_new(void *, workstation_nb);
+  /* Copy the elements of the task into the action */
+  hosts = xbt_new(sg_host_t, host_nb);
 
-  for (i = 0; i < workstation_nb; i++)
-    surf_workstations[i] = task->workstation_list[i];
+  for (i = 0; i < host_nb; i++)
+    hosts[i] =  task->workstation_list[i];
 
-  double *computation_amount = xbt_new0(double, workstation_nb);
-  double *communication_amount = xbt_new0(double, workstation_nb * workstation_nb);
+  double *flops_amount = xbt_new0(double, host_nb);
+  double *bytes_amount = xbt_new0(double, host_nb * host_nb);
 
 
-  if(task->computation_amount)
-    memcpy(computation_amount, task->computation_amount, sizeof(double) *
-           workstation_nb);
-  if(task->communication_amount)
-    memcpy(communication_amount, task->communication_amount,
-           sizeof(double) * workstation_nb * workstation_nb);
+  if(task->flops_amount)
+    memcpy(flops_amount, task->flops_amount, sizeof(double) *
+           host_nb);
+  if(task->bytes_amount)
+    memcpy(bytes_amount, task->bytes_amount,
+           sizeof(double) * host_nb * host_nb);
 
-  task->surf_action =
-        surf_workstation_model->extension.
-        workstation.execute_parallel_task(workstation_nb,
-                                          surf_workstations,
-                                          computation_amount,
-                                          communication_amount,
-                                          task->rate);
+  task->surf_action = surf_host_model_execute_parallel_task((surf_host_model_t)surf_host_model,
+		                                                     host_nb,
+		                                                     hosts,
+		                                                     flops_amount,
+		                                                     bytes_amount,
+		                                                     task->rate);
 
-  surf_workstation_model->action_data_set(task->surf_action, task);
+  surf_action_set_data(task->surf_action, task);
 
   XBT_DEBUG("surf_action = %p", task->surf_action);
 
-#ifdef HAVE_TRACING
   if (task->category)
     TRACE_surf_action(task->surf_action, task->category);
-#endif
 
   __SD_task_destroy_scheduling_data(task);      /* now the scheduling data are not useful anymore */
   __SD_task_set_state(task, SD_RUNNING);
@@ -1180,11 +1184,11 @@ int __SD_task_try_to_run(SD_task_t task)
   if (!can_start) {             /* if the task cannot start and is not in the FIFOs yet */
     for (i = 0; i < task->workstation_nb; i++) {
       workstation = task->workstation_list[i];
-      if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+      if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
         XBT_DEBUG("Pushing task '%s' in the FIFO of workstation '%s'",
                SD_task_get_name(task),
                SD_workstation_get_name(workstation));
-        xbt_fifo_push(SD_workstation_priv(workstation)->task_fifo, task);
+        xbt_fifo_push(sg_host_sd(workstation)->task_fifo, task);
       }
     }
     __SD_task_set_state(task, SD_IN_FIFO);
@@ -1224,7 +1228,7 @@ void __SD_task_just_done(SD_task_t task)
   candidates = xbt_new(SD_task_t, 8);
 
   __SD_task_set_state(task, SD_DONE);
-  surf_workstation_model->action_unref(task->surf_action);
+  surf_action_unref(task->surf_action);
   task->surf_action = NULL;
 
   XBT_DEBUG("Looking for candidates");
@@ -1234,23 +1238,23 @@ void __SD_task_just_done(SD_task_t task)
   for (i = 0; i < task->workstation_nb; i++) {
     workstation = task->workstation_list[i];
     XBT_DEBUG("Workstation '%s': access_mode = %d",
-              SD_workstation_get_name(workstation), (int)SD_workstation_priv(workstation)->access_mode);
-    if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
-      xbt_assert(SD_workstation_priv(workstation)->task_fifo != NULL,
+              SD_workstation_get_name(workstation), (int)sg_host_sd(workstation)->access_mode);
+    if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+      xbt_assert(sg_host_sd(workstation)->task_fifo != NULL,
                   "Workstation '%s' has sequential access but no FIFO!",
                   SD_workstation_get_name(workstation));
-      xbt_assert(SD_workstation_priv(workstation)->current_task =
+      xbt_assert(sg_host_sd(workstation)->current_task =
                   task, "Workstation '%s': current task should be '%s'",
                   SD_workstation_get_name(workstation),
                   SD_task_get_name(task));
 
       /* the task is over so we can release the workstation */
-      SD_workstation_priv(workstation)->current_task = NULL;
+      sg_host_sd(workstation)->current_task = NULL;
 
       XBT_DEBUG("Getting candidate in FIFO");
       candidate =
           xbt_fifo_get_item_content(xbt_fifo_get_first_item
-                                    (SD_workstation_priv(workstation)->task_fifo));
+                                    (sg_host_sd(workstation)->task_fifo));
 
       if (candidate != NULL) {
         XBT_DEBUG("Candidate: '%s'", SD_task_get_name(candidate));
@@ -1304,10 +1308,10 @@ void __SD_task_just_done(SD_task_t task)
 
       /* I can start on this workstation if the workstation is shared
          or if I am the first task in the FIFO */
-      can_start = SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SHARED_ACCESS
+      can_start = sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SHARED_ACCESS
           || candidate ==
           xbt_fifo_get_item_content(xbt_fifo_get_first_item
-                                    (SD_workstation_priv(workstation)->task_fifo));
+                                    (sg_host_sd(workstation)->task_fifo));
     }
 
     XBT_DEBUG("Candidate '%s' can start: %d", SD_task_get_name(candidate),
@@ -1319,8 +1323,8 @@ void __SD_task_just_done(SD_task_t task)
         workstation = candidate->workstation_list[j];
 
         /* update the FIFO */
-        if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
-          candidate = xbt_fifo_shift(SD_workstation_priv(workstation)->task_fifo);   /* the return value is stored just for debugging */
+        if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+          candidate = xbt_fifo_shift(sg_host_sd(workstation)->task_fifo);   /* the return value is stored just for debugging */
           XBT_DEBUG("Head of the FIFO: '%s'",
                  (candidate !=
                   NULL) ? SD_task_get_name(candidate) : "NULL");
@@ -1382,8 +1386,7 @@ static void __SD_task_remove_dependencies(SD_task_t task)
 double SD_task_get_start_time(SD_task_t task)
 {
   if (task->surf_action)
-    return surf_workstation_model->
-        action_get_start_time(task->surf_action);
+    return surf_action_get_start_time(task->surf_action);
   else
     return task->start_time;
 }
@@ -1402,29 +1405,28 @@ double SD_task_get_start_time(SD_task_t task)
 double SD_task_get_finish_time(SD_task_t task)
 {
   if (task->surf_action)        /* should never happen as actions are destroyed right after their completion */
-    return surf_workstation_model->
-        action_get_finish_time(task->surf_action);
+    return surf_action_get_finish_time(task->surf_action);
   else
     return task->finish_time;
 }
 /** @brief Blah
  *
  */
-void SD_task_distribute_comp_amdhal(SD_task_t task, int ws_count)
+void SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count)
 {
   int i;
   xbt_assert(task->kind == SD_TASK_COMP_PAR_AMDAHL,
               "Task %s is not a SD_TASK_COMP_PAR_AMDAHL typed task."
               "Cannot use this function.",
               SD_task_get_name(task));  
-  task->computation_amount = xbt_new0(double, ws_count);
-  task->communication_amount = xbt_new0(double, ws_count * ws_count);
+  task->flops_amount = xbt_new0(double, ws_count);
+  task->bytes_amount = xbt_new0(double, ws_count * ws_count);
   xbt_free(task->workstation_list);
   task->workstation_nb = ws_count;
   task->workstation_list = xbt_new0(SD_workstation_t, ws_count);
   
   for(i=0;i<ws_count;i++){
-    task->computation_amount[i] = 
+    task->flops_amount[i] = 
       (task->alpha + (1 - task->alpha)/ws_count) * task->amount;
   }
 } 
@@ -1462,7 +1464,7 @@ void SD_task_schedulev(SD_task_t task, int count,
               SD_task_get_name(task));
   switch (task->kind) {
   case SD_TASK_COMP_PAR_AMDAHL:
-    SD_task_distribute_comp_amdhal(task, count);
+    SD_task_distribute_comp_amdahl(task, count);
   case SD_TASK_COMM_E2E:
   case SD_TASK_COMP_SEQ:
     xbt_assert(task->workstation_nb == count,
@@ -1470,10 +1472,10 @@ void SD_task_schedulev(SD_task_t task, int count,
                count,task->workstation_nb);
     for (i = 0; i < count; i++)
       task->workstation_list[i] = list[i];
-    if (SD_task_get_kind(task)== SD_TASK_COMP_SEQ && !task->computation_amount){
-      /*This task has failed and is rescheduled. Reset the computation amount*/
-      task->computation_amount = xbt_new0(double, 1);
-      task->computation_amount[0] = task->remains;
+    if (SD_task_get_kind(task)== SD_TASK_COMP_SEQ && !task->flops_amount){
+      /*This task has failed and is rescheduled. Reset the flops_amount*/
+      task->flops_amount = xbt_new0(double, 1);
+      task->flops_amount[0] = task->remains;
     }
     SD_task_do_schedule(task);
     break;
@@ -1486,7 +1488,7 @@ void SD_task_schedulev(SD_task_t task, int count,
           SD_task_get_name(task),
           SD_workstation_get_name(task->workstation_list[0]),
           SD_workstation_get_name(task->workstation_list[1]),
-          task->communication_amount[2]);
+          task->bytes_amount[2]);
 
   }
 
@@ -1496,7 +1498,7 @@ void SD_task_schedulev(SD_task_t task, int count,
     XBT_VERB("Schedule computation task %s on %s. It costs %.f flops",
           SD_task_get_name(task),
           SD_workstation_get_name(task->workstation_list[0]),
-          task->computation_amount[0]);
+          task->flops_amount[0]);
 
     xbt_dynar_foreach(task->tasks_before, cpt, dep) {
       SD_task_t before = dep->src;
@@ -1512,7 +1514,7 @@ void SD_task_schedulev(SD_task_t task, int count,
                SD_task_get_name(before),
                SD_workstation_get_name(before->workstation_list[0]),
                SD_workstation_get_name(before->workstation_list[1]),
-               before->communication_amount[2]);
+               before->bytes_amount[2]);
         }
       }
     }
@@ -1529,7 +1531,7 @@ void SD_task_schedulev(SD_task_t task, int count,
                SD_task_get_name(after),
                SD_workstation_get_name(after->workstation_list[0]),
                SD_workstation_get_name(after->workstation_list[1]),
-               after->communication_amount[2]);
+               after->bytes_amount[2]);
 
         }
       }
@@ -1539,9 +1541,9 @@ void SD_task_schedulev(SD_task_t task, int count,
    * located (and start them if runnable) */
   if (task->kind == SD_TASK_COMP_PAR_AMDAHL) {
     XBT_VERB("Schedule computation task %s on %d workstations. %.f flops"
-             " will be distributed following Amdahl'Law",
+             " will be distributed following Amdahl's Law",
           SD_task_get_name(task), task->workstation_nb,
-          task->computation_amount[0]);
+          task->flops_amount[0]);
     xbt_dynar_foreach(task->tasks_before, cpt, dep) {
       SD_task_t before = dep->src;
       if (before->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){
@@ -1569,11 +1571,11 @@ void SD_task_schedulev(SD_task_t task, int count,
                task->workstation_list[i];
 
           before->workstation_nb += count;
-          xbt_free(before->computation_amount);
-          xbt_free(before->communication_amount);
-          before->computation_amount = xbt_new0(double,
+          xbt_free(before->flops_amount);
+          xbt_free(before->bytes_amount);
+          before->flops_amount = xbt_new0(double,
                                                 before->workstation_nb);
-          before->communication_amount = xbt_new0(double,
+          before->bytes_amount = xbt_new0(double,
                                                   before->workstation_nb*
                                                   before->workstation_nb);
 
@@ -1588,13 +1590,13 @@ void SD_task_schedulev(SD_task_t task, int count,
                   SD_workstation_get_name(before->workstation_list[src_nb+j]),
                   src_start, src_end, dst_start, dst_end);
               if ((src_end <= dst_start) || (dst_end <= src_start)) {
-                before->communication_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
+                before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
               } else {
-                before->communication_amount[i*(src_nb+dst_nb)+src_nb+j] =
+                before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j] =
                   MIN(src_end, dst_end) - MAX(src_start, dst_start);
               }
               XBT_VERB("==> %.2f",
-                 before->communication_amount[i*(src_nb+dst_nb)+src_nb+j]);
+                 before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]);
             }
           }
 
@@ -1635,11 +1637,11 @@ void SD_task_schedulev(SD_task_t task, int count,
 
           after->workstation_nb += count;
 
-          xbt_free(after->computation_amount);
-          xbt_free(after->communication_amount);
+          xbt_free(after->flops_amount);
+          xbt_free(after->bytes_amount);
 
-          after->computation_amount = xbt_new0(double, after->workstation_nb);
-          after->communication_amount = xbt_new0(double,
+          after->flops_amount = xbt_new0(double, after->workstation_nb);
+          after->bytes_amount = xbt_new0(double,
                                                  after->workstation_nb*
                                                  after->workstation_nb);
 
@@ -1652,13 +1654,13 @@ void SD_task_schedulev(SD_task_t task, int count,
               XBT_VERB("(%d->%d): (%.2f, %.2f)-> (%.2f, %.2f)",
                   i, j, src_start, src_end, dst_start, dst_end);
               if ((src_end <= dst_start) || (dst_end <= src_start)) {
-                after->communication_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
+                after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
               } else {
-                after->communication_amount[i*(src_nb+dst_nb)+src_nb+j] =
+                after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j] =
                    MIN(src_end, dst_end)- MAX(src_start, dst_start);
               }
               XBT_VERB("==> %.2f",
-                 after->communication_amount[i*(src_nb+dst_nb)+src_nb+j]);
+                 after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]);
             }
           }