Merge branch 'master' of git+ssh://scm.gforge.inria.fr//gitroot/simgrid/simgrid

[simgrid.git] / src / simdag / sd_dotloader.cpp

diff --git a/src/simdag/sd_dotloader.cpp b/src/simdag/sd_dotloader.cpp
index 7c82c61..8e3f736 100644 (file)
--- a/src/simdag/sd_dotloader.cpp
+++ b/src/simdag/sd_dotloader.cpp
@@ -62,8 +62,8 @@ xbt_dynar_t SD_dotload_generic(const char* filename, bool sequential, bool sched
   SD_task_t root;
   SD_task_t end;
   SD_task_t task;
-  xbt_dynar_t computer = nullptr;
-  xbt_dict_cursor_t dict_cursor;
+  std::vector<SD_task_t>* computer;
+  std::unordered_map<std::string, std::vector<SD_task_t>*> computers;
   bool schedule_success = true;
 
   std::unordered_map<std::string, SD_task_t> jobs;
@@ -71,8 +71,6 @@ xbt_dynar_t SD_dotload_generic(const char* filename, bool sequential, bool sched
 
   Agraph_t * dag_dot = agread(in_file, NIL(Agdisc_t *));
 
-  xbt_dict_t computers = xbt_dict_new_homogeneous(nullptr);
-
   /* Create all the nodes */
   Agnode_t *node = nullptr;
   for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) {
@@ -105,24 +103,26 @@ xbt_dynar_t SD_dotload_generic(const char* filename, bool sequential, bool sched
         if ((performer != -1 && order != -1) && performer < static_cast<int>(sg_host_count())) {
           /* required parameters are given and less performers than hosts are required */
           XBT_DEBUG ("Task '%s' is scheduled on workstation '%d' in position '%d'", task->name, performer, order);
-          computer = static_cast<xbt_dynar_t> (xbt_dict_get_or_null(computers, char_performer));
-          if(computer == nullptr){
-            computer = xbt_dynar_new(sizeof(SD_task_t), nullptr);
-            xbt_dict_set(computers, char_performer, computer, nullptr);
+          auto comp = computers.find(char_performer);
+          if (comp != computers.end()) {
+            computer = comp->second;
+          } else {
+            computer = new std::vector<SD_task_t>;
+            computers.insert({char_performer, computer});
           }
-
-          if(static_cast<unsigned int>(order) < xbt_dynar_length(computer)){
-            SD_task_t *task_test = (SD_task_t *)xbt_dynar_get_ptr(computer,order);
-            if(*task_test && *task_test != task){
+          if (static_cast<unsigned int>(order) < computer->size()) {
+            SD_task_t task_test = computer->at(order);
+            if (task_test && task_test != task) {
               /* the user gave the same order to several tasks */
               schedule_success = false;
               XBT_VERB("Task '%s' wants to start on performer '%s' at the same position '%s' as task '%s'",
-                       (*task_test)->name, char_performer, char_order, task->name);
+                       task_test->name, char_performer, char_order, task->name);
               continue;
             }
-          }
-          /* the parameter seems to be ok */
-          xbt_dynar_set_as(computer, order, SD_task_t, task);
+          } else
+            computer->resize(order);
+
+          computer->insert(computer->begin() + order, task);
         } else {
           /* one of required parameters is not given */
           schedule_success = false;
@@ -211,34 +211,32 @@ xbt_dynar_t SD_dotload_generic(const char* filename, bool sequential, bool sched
   fclose(in_file);
 
   if(schedule){
-    char *computer_name;
     if (schedule_success) {
-      const sg_host_t *workstations = sg_host_list ();
-      xbt_dict_foreach(computers,dict_cursor,computer_name,computer){
+      sg_host_t* workstations = sg_host_list();
+      for (auto const& elm : computers) {
         SD_task_t previous_task = nullptr;
-        xbt_dynar_foreach(computer, i, task){
+        for (auto const& task : *elm.second) {
           /* add dependency between the previous and the task to avoid parallel execution */
           if(task){
             if (previous_task && not SD_task_dependency_exists(previous_task, task))
               SD_task_dependency_add(nullptr, nullptr, previous_task, task);
 
-            SD_task_schedulel(task, 1, workstations[atoi(computer_name)]);
+            SD_task_schedulel(task, 1, workstations[atoi(elm.first.c_str())]);
             previous_task = task;
           }
         }
-        xbt_dynar_free(&computer);
+        delete elm.second;
       }
+      xbt_free(workstations);
     } else {
       XBT_WARN("The scheduling is ignored");
-      xbt_dict_foreach(computers,dict_cursor,computer_name,computer)
-        xbt_dynar_free(&computer);
+      for (auto const& elm : computers)
+        delete elm.second;
       xbt_dynar_free(&result);
       result = nullptr;
     }
   }
 
-  xbt_dict_free(&computers);
-
   if (result && not acyclic_graph_detail(result)) {
     char* base = xbt_basename(filename);
     XBT_ERROR("The DOT described in %s is not a DAG. It contains a cycle.", base);