Remove a level of indirection in sd::Global.

diff --git a/src/simdag/sd_daxloader.cpp b/src/simdag/sd_daxloader.cpp
index 54baf37..82f8d0d 100644 (file)
--- a/src/simdag/sd_daxloader.cpp
+++ b/src/simdag/sd_daxloader.cpp
@@ -273,7 +273,7 @@ void STag_dax__uses()
   SD_task_t file;
   if (it == files.end()) {
     file = SD_task_create_comm_e2e(A_dax__uses_file, nullptr, size);
-    sd_global->initial_tasks->erase(file);
+    sd_global->initial_tasks.erase(file);
     files[A_dax__uses_file] = file;
   } else {
     file = it->second;

diff --git a/src/simdag/sd_global.cpp b/src/simdag/sd_global.cpp
index f6974f9..e466ff0 100644 (file)
--- a/src/simdag/sd_global.cpp
+++ b/src/simdag/sd_global.cpp
@@ -17,30 +17,16 @@ simgrid::sd::Global *sd_global = nullptr;
 
 namespace simgrid{
 namespace sd{
-Global::Global(){
-  watch_point_reached = false;
-  initial_tasks = new std::set<SD_task_t>();
-  runnable_tasks = new std::set<SD_task_t>();
-  completed_tasks = new std::set<SD_task_t>();
-  return_set = new std::set<SD_task_t>();
-}
-
-Global::~Global(){
-  delete initial_tasks;
-  delete runnable_tasks;
-  delete completed_tasks;
-  delete return_set;
-}
 
 std::set<SD_task_t>* simulate(double how_long){
   XBT_VERB("Run simulation for %f seconds", how_long);
 
   sd_global->watch_point_reached = false;
-  sd_global->return_set->clear();
+  sd_global->return_set.clear();
 
   /* explore the runnable tasks */
-  while (not sd_global->runnable_tasks->empty())
-    SD_task_run(*(sd_global->runnable_tasks->begin()));
+  while (not sd_global->runnable_tasks.empty())
+    SD_task_run(*(sd_global->runnable_tasks.begin()));
 
   double elapsed_time = 0.0;
   double total_time = 0.0;
@@ -64,8 +50,8 @@ std::set<SD_task_t>* simulate(double how_long){
         SD_task_set_state(task, SD_DONE);
 
         /* the state has changed. Add it only if it's the first change */
-        if (sd_global->return_set->find(task) == sd_global->return_set->end())
-          sd_global->return_set->insert(task);
+        if (sd_global->return_set.find(task) == sd_global->return_set.end())
+          sd_global->return_set.insert(task);
 
         /* remove the dependencies after this task */
         for (auto const& succ : *task->successors) {
@@ -112,15 +98,15 @@ std::set<SD_task_t>* simulate(double how_long){
         SD_task_t task = static_cast<SD_task_t>(action->get_data());
         XBT_VERB("Task '%s' failed", SD_task_get_name(task));
         SD_task_set_state(task, SD_FAILED);
-        sd_global->return_set->insert(task);
+        sd_global->return_set.insert(task);
         action = model->extract_failed_action();
       }
     }
   }
 
-  if (not sd_global->watch_point_reached && how_long < 0 && not sd_global->initial_tasks->empty()) {
-    XBT_WARN("Simulation is finished but %zu tasks are still not done", sd_global->initial_tasks->size());
-    for (auto const& t : *sd_global->initial_tasks)
+  if (not sd_global->watch_point_reached && how_long < 0 && not sd_global->initial_tasks.empty()) {
+    XBT_WARN("Simulation is finished but %zu tasks are still not done", sd_global->initial_tasks.size());
+    for (auto const& t : sd_global->initial_tasks)
       XBT_WARN("%s is in %s state", SD_task_get_name(t), __get_state_name(SD_task_get_state(t)));
   }
 
@@ -128,7 +114,7 @@ std::set<SD_task_t>* simulate(double how_long){
              elapsed_time, total_time, sd_global->watch_point_reached);
   XBT_DEBUG("current time = %f", surf_get_clock());
 
-  return sd_global->return_set;
+  return &sd_global->return_set;
 }
 }
 }

diff --git a/src/simdag/sd_task.cpp b/src/simdag/sd_task.cpp
index 0827cc7..3bdc2f0 100644 (file)
--- a/src/simdag/sd_task.cpp
+++ b/src/simdag/sd_task.cpp
@@ -37,7 +37,7 @@ 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->kind = SD_TASK_NOT_TYPED;
   task->state= SD_NOT_SCHEDULED;
-  sd_global->initial_tasks->insert(task);
+  sd_global->initial_tasks.insert(task);
 
   task->marked = 0;
   task->start_time = -1.0;
@@ -265,28 +265,28 @@ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
   std::set<SD_task_t>::iterator idx;
   XBT_DEBUG("Set state of '%s' to %d", task->name, new_state);
   if ((new_state == SD_NOT_SCHEDULED || new_state == SD_SCHEDULABLE) && task->state == SD_FAILED){
-    sd_global->completed_tasks->erase(task);
-    sd_global->initial_tasks->insert(task);
+    sd_global->completed_tasks.erase(task);
+    sd_global->initial_tasks.insert(task);
   }
 
   if (new_state == SD_SCHEDULED && task->state == SD_RUNNABLE){
-    sd_global->initial_tasks->insert(task);
-    sd_global->runnable_tasks->erase(task);
+    sd_global->initial_tasks.insert(task);
+    sd_global->runnable_tasks.erase(task);
   }
 
   if (new_state == SD_RUNNABLE){
-    idx = sd_global->initial_tasks->find(task);
-    if (idx != sd_global->initial_tasks->end()) {
-      sd_global->runnable_tasks->insert(*idx);
-      sd_global->initial_tasks->erase(idx);
+    idx = sd_global->initial_tasks.find(task);
+    if (idx != sd_global->initial_tasks.end()) {
+      sd_global->runnable_tasks.insert(*idx);
+      sd_global->initial_tasks.erase(idx);
     }
   }
 
   if (new_state == SD_RUNNING)
-    sd_global->runnable_tasks->erase(task);
+    sd_global->runnable_tasks.erase(task);
 
   if (new_state == SD_DONE || new_state == SD_FAILED){
-    sd_global->completed_tasks->insert(task);
+    sd_global->completed_tasks.insert(task);
     task->start_time = task->surf_action->get_start_time();
     if (new_state == SD_DONE){
       task->finish_time = task->surf_action->get_finish_time();
@@ -802,7 +802,7 @@ void SD_task_run(SD_task_t task)
   XBT_DEBUG("surf_action = %p", task->surf_action);
 
   SD_task_set_state(task, SD_RUNNING);
-  sd_global->return_set->insert(task);
+  sd_global->return_set.insert(task);
 }
 
 /**

diff --git a/src/simdag/simdag_private.hpp b/src/simdag/simdag_private.hpp
index 7565424..e452c3b 100644 (file)
--- a/src/simdag/simdag_private.hpp
+++ b/src/simdag/simdag_private.hpp
@@ -19,15 +19,11 @@ namespace simgrid{
 namespace sd{
 class Global {
 public:
-  explicit Global();
-  Global(const Global&) = delete;
-  Global& operator=(const Global&) = delete;
-  ~Global();
-  bool watch_point_reached;      /* has a task just reached a watch point? */
-  std::set<SD_task_t> *initial_tasks;
-  std::set<SD_task_t> *runnable_tasks;
-  std::set<SD_task_t> *completed_tasks;
-  std::set<SD_task_t> *return_set;
+  bool watch_point_reached = false; /* has a task just reached a watch point? */
+  std::set<SD_task_t> initial_tasks;
+  std::set<SD_task_t> runnable_tasks;
+  std::set<SD_task_t> completed_tasks;
+  std::set<SD_task_t> return_set;
 };
 
 std::set<SD_task_t>* simulate (double how_long);