X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/41fdcc1cfbd0503e436da495f0eebc272a9e931a..2bcb5dd3317c733c31c288ae79e72fb28863d936:/src/simdag/sd_task.cpp

diff --git a/src/simdag/sd_task.cpp b/src/simdag/sd_task.cpp
index 75f575fa12..3cf0a0e469 100644
--- a/src/simdag/sd_task.cpp
+++ b/src/simdag/sd_task.cpp
@@ -4,9 +4,9 @@
 /* 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 "simdag_private.hpp"
 #include "src/surf/HostImpl.hpp"
 #include "src/surf/surf_interface.hpp"
-#include "src/simdag/simdag_private.h"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_task, sd, "Logging specific to SimDag (task)");
 
@@ -22,22 +22,18 @@ static void __SD_task_destroy_scheduling_data(SD_task_t task)
   task->flops_amount = nullptr;
 }
 
-void* SD_task_new_f()
+/**
+ * \brief Creates a new task.
+ *
+ * \param name the name of the task (can be \c nullptr)
+ * \param data the user data you want to associate with the task (can be \c nullptr)
+ * \param amount amount of the task
+ * \return the new task
+ * \see SD_task_destroy()
+ */
+SD_task_t SD_task_create(const char *name, void *data, double amount)
 {
   SD_task_t task = xbt_new0(s_SD_task_t, 1);
-
-  task->inputs = new std::set<SD_task_t>();
-  task->outputs = new std::set<SD_task_t>();
-  task->predecessors = new std::set<SD_task_t>();
-  task->successors = new std::set<SD_task_t>();
-  return task;
-}
-
-void SD_task_recycle_f(void *t)
-{
-  SD_task_t task = static_cast<SD_task_t>(t);
-
-  /* Reset the content */
   task->kind = SD_TASK_NOT_TYPED;
   task->state= SD_NOT_SCHEDULED;
   sd_global->initial_tasks->insert(task);
@@ -48,46 +44,16 @@ void SD_task_recycle_f(void *t)
   task->surf_action = nullptr;
   task->watch_points = 0;
 
-  /* dependencies */
-  task->inputs->clear();
-  task->outputs->clear();
-  task->predecessors->clear();
-  task->successors->clear();
-
-  /* scheduling parameters */
-  task->flops_amount = nullptr;
-  task->bytes_amount = nullptr;
-  task->rate = -1;
-}
-
-void SD_task_free_f(void *t)
-{
-  SD_task_t task = static_cast<SD_task_t>(t);
-  delete task->inputs;
-  delete task->outputs;
-  delete task->predecessors;
-  delete task->successors;
-  xbt_free(task);
-}
-
-/**
- * \brief Creates a new task.
- *
- * \param name the name of the task (can be \c nullptr)
- * \param data the user data you want to associate with the task (can be \c nullptr)
- * \param amount amount of the task
- * \return the new task
- * \see SD_task_destroy()
- */
-SD_task_t SD_task_create(const char *name, void *data, double amount)
-{
-  SD_task_t task = static_cast<SD_task_t>(xbt_mallocator_get(sd_global->task_mallocator));
+  task->inputs = new std::set<SD_task_t>();
+  task->outputs = new std::set<SD_task_t>();
+  task->predecessors = new std::set<SD_task_t>();
+  task->successors = new std::set<SD_task_t>();
 
   task->data = data;
   task->name = xbt_strdup(name);
   task->amount = amount;
-  task->remains = amount;
   task->allocation = new std::vector<sg_host_t>();
+  task->rate = -1;
   return task;
 }
 
@@ -220,8 +186,11 @@ void SD_task_destroy(SD_task_t task)
   delete task->allocation;
   xbt_free(task->bytes_amount);
   xbt_free(task->flops_amount);
-
-  xbt_mallocator_release(sd_global->task_mallocator,task);
+  delete task->inputs;
+  delete task->outputs;
+  delete task->predecessors;
+  delete task->successors;
+  xbt_free(task);
 
   XBT_DEBUG("Task destroyed.");
 }
@@ -320,7 +289,6 @@ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
     task->start_time = task->surf_action->getStartTime();
     if (new_state == SD_DONE){
       task->finish_time = task->surf_action->getFinishTime();
-      task->remains = 0;
 #if HAVE_JEDULE
       jedule_log_sd_event(task);
 #endif
@@ -468,7 +436,7 @@ double SD_task_get_remaining_amount(SD_task_t task)
   if (task->surf_action)
     return task->surf_action->getRemains();
   else
-    return task->remains;
+    return (task->state == SD_DONE) ? 0 : task->amount;
 }
 
 e_SD_task_kind_t SD_task_get_kind(SD_task_t task)
@@ -480,16 +448,12 @@ e_SD_task_kind_t SD_task_get_kind(SD_task_t task)
 void SD_task_dump(SD_task_t task)
 {
   XBT_INFO("Displaying task %s", SD_task_get_name(task));
-  char *statename = bprintf("%s%s%s%s%s%s%s",
-                      (task->state == SD_NOT_SCHEDULED ? " not scheduled" : ""),
-                      (task->state == SD_SCHEDULABLE ? " schedulable" : ""),
-                      (task->state == SD_SCHEDULED ? " scheduled" : ""),
-                      (task->state == SD_RUNNABLE ? " runnable" : " not runnable"),
-                      (task->state == SD_RUNNING ? " running" : ""),
-                      (task->state == SD_DONE ? " done" : ""),
-                      (task->state == SD_FAILED ? " failed" : ""));
-  XBT_INFO("  - state:%s", statename);
-  free(statename);
+  if (task->state == SD_RUNNABLE)
+    XBT_INFO("  - state: runnable");
+  else if (task->state < SD_RUNNABLE)
+    XBT_INFO("  - state: %s not runnable", __get_state_name(task->state));
+  else
+    XBT_INFO("  - state: not runnable %s", __get_state_name(task->state));
 
   if (task->kind != 0) {
     switch (task->kind) {
@@ -726,8 +690,8 @@ double SD_task_get_execution_time(SD_task_t task, int host_count, const sg_host_
     if (bytes_amount != nullptr)
       for (int j = 0; j < host_count; j++)
         if (bytes_amount[i * host_count + j] != 0)
-          time += (SD_route_get_latency(host_list[i], host_list[j]) +
-                   bytes_amount[i * host_count + j] / SD_route_get_bandwidth(host_list[i], host_list[j]));
+          time += (sg_host_route_latency(host_list[i], host_list[j]) +
+                   bytes_amount[i * host_count + j] / sg_host_route_bandwidth(host_list[i], host_list[j]));
 
     if (time > max_time)
       max_time = time;
@@ -754,7 +718,7 @@ static inline void SD_task_do_schedule(SD_task_t task)
  *
  * \param task the task you want to schedule
  * \param host_count number of hosts on which the task will be executed
- * \param workstation_list the hosts on which the task will be executed
+ * \param host_list the hosts on which the task will be executed
  * \param flops_amount computation amount for each hosts (i.e., an array of host_count doubles)
  * \param bytes_amount communication amount between each pair of hosts (i.e., a matrix of host_count*host_count doubles)
  * \param rate task execution speed rate
@@ -821,7 +785,6 @@ void SD_task_unschedule(SD_task_t task)
     else
       SD_task_set_state(task, SD_NOT_SCHEDULED);
   }
-  task->remains = task->amount;
   task->start_time = -1.0;
 }
 
@@ -837,8 +800,10 @@ void SD_task_run(SD_task_t task)
   int host_nb = task->allocation->size();
   sg_host_t *hosts = xbt_new(sg_host_t, host_nb);
   int i =0;
-  for (auto host: *task->allocation)
-    hosts[i++] = host;
+  for (auto host: *task->allocation){
+    hosts[i] = host;
+    i++;
+  }
 
   double *flops_amount = xbt_new0(double, host_nb);
   double *bytes_amount = xbt_new0(double, host_nb * host_nb);
@@ -856,7 +821,7 @@ void SD_task_run(SD_task_t task)
 
   __SD_task_destroy_scheduling_data(task);      /* now the scheduling data are not useful anymore */
   SD_task_set_state(task, SD_RUNNING);
-  xbt_dynar_push(sd_global->return_set, &task);
+  sd_global->return_set->insert(task);
 }
 
 /**
@@ -948,7 +913,7 @@ void SD_task_schedulev(SD_task_t task, int count, const sg_host_t * list)
   if (task->kind == SD_TASK_COMP_SEQ) {
     if (!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;
+      task->flops_amount[0] = task->amount;
     }
     XBT_VERB("It costs %.f flops", task->flops_amount[0]);
   }