various tiny changes

diff --git a/src/simdag/sd_daxloader.cpp b/src/simdag/sd_daxloader.cpp
index d8e0a91..df81674 100644 (file)
--- a/src/simdag/sd_daxloader.cpp
+++ b/src/simdag/sd_daxloader.cpp
@@ -356,18 +356,18 @@ void ETag_dax__adag()
   XBT_DEBUG("See </adag>");
 }
 
   XBT_DEBUG("See </adag>");
 }
 

-void ETag_dax__job(void)
+void ETag_dax__job()

 {
   current_job = nullptr;
   XBT_DEBUG("See </job>");
 }
 
 {
   current_job = nullptr;
   XBT_DEBUG("See </job>");
 }
 

-void ETag_dax__parent(void)
+void ETag_dax__parent()

 {
   XBT_DEBUG("See </parent>");
 }
 
 {
   XBT_DEBUG("See </parent>");
 }
 

-void ETag_dax__uses(void)
+void ETag_dax__uses()

 {
   XBT_DEBUG("See </uses>");
 }
 {
   XBT_DEBUG("See </uses>");
 }

diff --git a/src/simdag/sd_dotloader.cpp b/src/simdag/sd_dotloader.cpp
index 5a35d52..e9ebab0 100644 (file)
--- a/src/simdag/sd_dotloader.cpp
+++ b/src/simdag/sd_dotloader.cpp
@@ -60,7 +60,9 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool
   xbt_assert(in_file != nullptr, "Failed to open file: %s", filename);
 
   unsigned int i;
   xbt_assert(in_file != nullptr, "Failed to open file: %s", filename);
 
   unsigned int i;

-  SD_task_t root, end, task;
+  SD_task_t root;
+  SD_task_t end;
+  SD_task_t task;

   xbt_dict_t computers;
   xbt_dynar_t computer = nullptr;
   xbt_dict_cursor_t dict_cursor;
   xbt_dict_t computers;
   xbt_dynar_t computer = nullptr;
   xbt_dict_cursor_t dict_cursor;


@@ -78,9 +80,9 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool
   Agnode_t *node = nullptr;
   for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) {
     char *name = agnameof(node);
   Agnode_t *node = nullptr;
   for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) {
     char *name = agnameof(node);

-    double amount = atof(agget(node, (char *) "size"));
-
-    if (!(task = (SD_task_t)xbt_dict_get_or_null(jobs, name))) {
+    double amount = atof(agget(node, (char*)"size"));
+    task = static_cast<SD_task_t>(xbt_dict_get_or_null(jobs, name));
+    if (task == nullptr) {

       if (seq_or_par == sequential){
         XBT_DEBUG("See <job id=%s amount =%.0f>", name, amount);
         task = SD_task_create_comp_seq(name, nullptr , amount);
       if (seq_or_par == sequential){
         XBT_DEBUG("See <job id=%s amount =%.0f>", name, amount);
         task = SD_task_create_comp_seq(name, nullptr , amount);


@@ -159,17 +161,17 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool
     xbt_dynar_sort(edges, edge_compare);
 
     xbt_dynar_foreach(edges, i, edge) {
     xbt_dynar_sort(edges, edge_compare);
 
     xbt_dynar_foreach(edges, i, edge) {

-      SD_task_t src, dst;

       char *src_name=agnameof(agtail(edge)), *dst_name=agnameof(aghead(edge));
       double size = atof(agget(edge, (char *) "size"));
 
       char *src_name=agnameof(agtail(edge)), *dst_name=agnameof(aghead(edge));
       double size = atof(agget(edge, (char *) "size"));
 

-      src = (SD_task_t)xbt_dict_get_or_null(jobs, src_name);
-      dst = (SD_task_t)xbt_dict_get_or_null(jobs, dst_name);
+      SD_task_t src = static_cast<SD_task_t>(xbt_dict_get_or_null(jobs, src_name));
+      SD_task_t dst = static_cast<SD_task_t>(xbt_dict_get_or_null(jobs, dst_name));

 
       if (size > 0) {
         char *name = bprintf("%s->%s", src_name, dst_name);
         XBT_DEBUG("See <transfer id=%s amount = %.0f>", name, size);
 
       if (size > 0) {
         char *name = bprintf("%s->%s", src_name, dst_name);
         XBT_DEBUG("See <transfer id=%s amount = %.0f>", name, size);

-        if (!(task = (SD_task_t)xbt_dict_get_or_null(jobs, name))) {
+        task = static_cast<SD_task_t>(xbt_dict_get_or_null(jobs, name));
+        if (task == nullptr) {

           if (seq_or_par == sequential)
             task = SD_task_create_comm_e2e(name, nullptr , size);
           else
           if (seq_or_par == sequential)
             task = SD_task_create_comm_e2e(name, nullptr , size);
           else

diff --git a/src/simdag/sd_global.cpp b/src/simdag/sd_global.cpp
index 166f54a..7579f31 100644 (file)
--- a/src/simdag/sd_global.cpp
+++ b/src/simdag/sd_global.cpp
@@ -31,8 +31,6 @@ SD_global_t sd_global = nullptr;
  */
 void SD_init(int *argc, char **argv)
 {
  */
 void SD_init(int *argc, char **argv)
 {

-  TRACE_global_init(argc, argv);
-

   xbt_assert(sd_global == nullptr, "SD_init() already called");
 
   sd_global = xbt_new(s_SD_global_t, 1);
   xbt_assert(sd_global == nullptr, "SD_init() already called");
 
   sd_global = xbt_new(s_SD_global_t, 1);


@@ -41,7 +39,7 @@ void SD_init(int *argc, char **argv)
   sd_global->task_mallocator=xbt_mallocator_new(65536, SD_task_new_f, SD_task_free_f, SD_task_recycle_f);
 
   sd_global->initial_tasks = new std::set<SD_task_t>();
   sd_global->task_mallocator=xbt_mallocator_new(65536, SD_task_new_f, SD_task_free_f, SD_task_recycle_f);
 
   sd_global->initial_tasks = new std::set<SD_task_t>();

-  sd_global->executable_tasks = new std::set<SD_task_t>();
+  sd_global->runnable_tasks = new std::set<SD_task_t>();

   sd_global->completed_tasks = new std::set<SD_task_t>();
   sd_global->return_set = xbt_dynar_new(sizeof(SD_task_t), nullptr);
 
   sd_global->completed_tasks = new std::set<SD_task_t>();
   sd_global->return_set = xbt_dynar_new(sizeof(SD_task_t), nullptr);
 


@@ -117,28 +115,26 @@ void SD_create_environment(const char *platform_file)
 
 xbt_dynar_t SD_simulate(double how_long) {
   /* we stop the simulation when total_time >= how_long */
 
 xbt_dynar_t SD_simulate(double how_long) {
   /* we stop the simulation when total_time >= how_long */

-  double total_time = 0.0;
-  SD_task_t task, dst;
+  SD_task_t task;
+  SD_task_t dst;

   surf_action_t action;
   unsigned int iter;
 
   XBT_VERB("Run simulation for %f seconds", how_long);
   surf_action_t action;
   unsigned int iter;
 
   XBT_VERB("Run simulation for %f seconds", how_long);

-  sd_global->watch_point_reached = 0;
+  sd_global->watch_point_reached = false;

 
   xbt_dynar_reset(sd_global->return_set);
 
   /* explore the runnable tasks */
 
   xbt_dynar_reset(sd_global->return_set);
 
   /* explore the runnable tasks */

-  std::set<SD_task_t>::iterator it=sd_global->executable_tasks->begin();
-  while(it != sd_global->executable_tasks->end()){
-    task = *it;
-    it++;
+  while(!sd_global->runnable_tasks->empty()){
+    task = *(sd_global->runnable_tasks->begin());

     XBT_VERB("Executing task '%s'", SD_task_get_name(task));
     SD_task_run(task);
     XBT_VERB("Executing task '%s'", SD_task_get_name(task));
     SD_task_run(task);

-    xbt_dynar_push(sd_global->return_set, &task);

   }
 
   /* main loop */
   double elapsed_time = 0.0;
   }
 
   /* main loop */
   double elapsed_time = 0.0;

+  double total_time = 0.0;

   while (elapsed_time >= 0.0 && (how_long < 0.0 || 0.00001 < (how_long -total_time)) &&
          !sd_global->watch_point_reached) {
     surf_model_t model = nullptr;
   while (elapsed_time >= 0.0 && (how_long < 0.0 || 0.00001 < (how_long -total_time)) &&
          !sd_global->watch_point_reached) {
     surf_model_t model = nullptr;


@@ -154,13 +150,8 @@ xbt_dynar_t SD_simulate(double how_long) {
     xbt_dynar_foreach(all_existing_models, iter, model) {
       while ((action = surf_model_extract_done_action_set(model))) {
         task = static_cast<SD_task_t>(action->getData());
     xbt_dynar_foreach(all_existing_models, iter, model) {
       while ((action = surf_model_extract_done_action_set(model))) {
         task = static_cast<SD_task_t>(action->getData());

-        task->start_time = task->surf_action->getStartTime();
-
-        task->finish_time = surf_get_clock();

         XBT_VERB("Task '%s' done", SD_task_get_name(task));
         SD_task_set_state(task, SD_DONE);
         XBT_VERB("Task '%s' done", SD_task_get_name(task));
         SD_task_set_state(task, SD_DONE);

-        task->surf_action->unref();
-        task->surf_action = nullptr;

 
         /* the state has changed. Add it only if it's the first change */
         if (xbt_dynar_member(sd_global->return_set, &task) == 0) {
 
         /* the state has changed. Add it only if it's the first change */
         if (xbt_dynar_member(sd_global->return_set, &task) == 0) {


@@ -168,26 +159,21 @@ xbt_dynar_t SD_simulate(double how_long) {
         }
 
         /* remove the dependencies after this task */
         }
 
         /* remove the dependencies after this task */

-        for (std::set<SD_task_t>::iterator it=task->successors->begin(); it!=task->successors->end(); ++it){
-          dst=*it;
-          dst->predecessors->erase(task);
-          dst->inputs->erase(task);
-          XBT_DEBUG("Released a dependency on %s: %zu remain(s). Became schedulable if %zu=0",
-             SD_task_get_name(dst), dst->predecessors->size()+dst->inputs->size(), dst->predecessors->size());
-          if (dst->predecessors->empty() && dst->inputs->empty()) {
-            if (SD_task_get_state(dst) == SD_SCHEDULED)
-              SD_task_set_state(dst, SD_RUNNABLE);
-            else
-              SD_task_set_state(dst, SD_SCHEDULABLE);
-          }
+        for (std::set<SD_task_t>::iterator succ = task->successors->begin(); succ != task->successors->end(); ++succ){
+          (*succ)->predecessors->erase(task);
+          (*succ)->inputs->erase(task);
+          XBT_DEBUG("Release dependency on %s: %zu remain(s). Becomes schedulable if %zu=0", SD_task_get_name((*succ)),
+              (*succ)->predecessors->size()+(*succ)->inputs->size(), (*succ)->predecessors->size());

 
 

-          if (SD_task_get_state(dst) == SD_NOT_SCHEDULED && dst->predecessors->empty()){
-            SD_task_set_state(dst, SD_SCHEDULABLE);
-          }
-          if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) {
-            XBT_VERB("Executing task '%s'", SD_task_get_name(dst));
-            SD_task_run(dst);
-            xbt_dynar_push(sd_global->return_set, &dst);
+          if (SD_task_get_state((*succ)) == SD_NOT_SCHEDULED && (*succ)->predecessors->empty())
+            SD_task_set_state((*succ), SD_SCHEDULABLE);
+
+          if (SD_task_get_state((*succ)) == SD_SCHEDULED && (*succ)->predecessors->empty() && (*succ)->inputs->empty())
+            SD_task_set_state((*succ), SD_RUNNABLE);
+
+          if (SD_task_get_state((*succ)) == SD_RUNNABLE && !sd_global->watch_point_reached) {
+            XBT_VERB("Executing task '%s'", SD_task_get_name((*succ)));
+            SD_task_run((*succ));

           }
         }
         task->successors->clear();
           }
         }
         task->successors->clear();


@@ -200,6 +186,7 @@ xbt_dynar_t SD_simulate(double how_long) {
              SD_task_set_state(dst, SD_RUNNABLE);
           else
              SD_task_set_state(dst, SD_SCHEDULABLE);
              SD_task_set_state(dst, SD_RUNNABLE);
           else
              SD_task_set_state(dst, SD_SCHEDULABLE);

+

           SD_task_t comm_dst = *(dst->successors->begin());
           if (SD_task_get_state(comm_dst) == SD_NOT_SCHEDULED && comm_dst->predecessors->empty()){
             XBT_DEBUG("%s is a transfer, %s may be ready now if %zu=0",
           SD_task_t comm_dst = *(dst->successors->begin());
           if (SD_task_get_state(comm_dst) == SD_NOT_SCHEDULED && comm_dst->predecessors->empty()){
             XBT_DEBUG("%s is a transfer, %s may be ready now if %zu=0",


@@ -209,7 +196,6 @@ xbt_dynar_t SD_simulate(double how_long) {
           if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) {
             XBT_VERB("Executing task '%s'", SD_task_get_name(dst));
             SD_task_run(dst);
           if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) {
             XBT_VERB("Executing task '%s'", SD_task_get_name(dst));
             SD_task_run(dst);

-            xbt_dynar_push(sd_global->return_set, &dst);

           }
         }
         task->outputs->clear();
           }
         }
         task->outputs->clear();


@@ -218,26 +204,20 @@ xbt_dynar_t SD_simulate(double how_long) {
       /* let's see which tasks have just failed */
       while ((action = surf_model_extract_failed_action_set(model))) {
         task = static_cast<SD_task_t>(action->getData());
       /* let's see which tasks have just failed */
       while ((action = surf_model_extract_failed_action_set(model))) {
         task = static_cast<SD_task_t>(action->getData());

-        task->start_time = task->surf_action->getStartTime();
-        task->finish_time = surf_get_clock();

         XBT_VERB("Task '%s' failed", SD_task_get_name(task));
         SD_task_set_state(task, SD_FAILED);
         XBT_VERB("Task '%s' failed", SD_task_get_name(task));
         SD_task_set_state(task, SD_FAILED);

-        action->unref();
-        task->surf_action = nullptr;
-

         xbt_dynar_push(sd_global->return_set, &task);
       }
     }
   }
 
         xbt_dynar_push(sd_global->return_set, &task);
       }
     }
   }
 

-  if (!sd_global->watch_point_reached && how_long<0 && !sd_global->initial_tasks->empty()) {
+  if (!sd_global->watch_point_reached && how_long < 0 && !sd_global->initial_tasks->empty()) {

     XBT_WARN("Simulation is finished but %zu tasks are still not done", sd_global->initial_tasks->size());
     static const char* state_names[] =
       { "SD_NOT_SCHEDULED", "SD_SCHEDULABLE", "SD_SCHEDULED", "SD_RUNNABLE", "SD_RUNNING", "SD_DONE","SD_FAILED" };
     XBT_WARN("Simulation is finished but %zu tasks are still not done", sd_global->initial_tasks->size());
     static const char* state_names[] =
       { "SD_NOT_SCHEDULED", "SD_SCHEDULABLE", "SD_SCHEDULED", "SD_RUNNABLE", "SD_RUNNING", "SD_DONE","SD_FAILED" };

-    for (std::set<SD_task_t>::iterator it=sd_global->initial_tasks->begin();
-         it!=sd_global->initial_tasks->end(); ++it){
-      task = *it;
-      XBT_WARN("%s is in %s state", SD_task_get_name(task), state_names[SD_task_get_state(task)]);
+    for (std::set<SD_task_t>::iterator t = sd_global->initial_tasks->begin(); t != sd_global->initial_tasks->end();
+         ++t){
+      XBT_WARN("%s is in %s state", SD_task_get_name(*t), state_names[SD_task_get_state(*t)]);

     }
   }
 
     }
   }
 


@@ -271,7 +251,7 @@ void SD_exit()
 
   xbt_mallocator_free(sd_global->task_mallocator);
   delete sd_global->initial_tasks;
 
   xbt_mallocator_free(sd_global->task_mallocator);
   delete sd_global->initial_tasks;

-  delete sd_global->executable_tasks;
+  delete sd_global->runnable_tasks;

   delete sd_global->completed_tasks;
   xbt_dynar_free_container(&(sd_global->return_set));
   xbt_free(sd_global);
   delete sd_global->completed_tasks;
   xbt_dynar_free_container(&(sd_global->return_set));
   xbt_free(sd_global);

diff --git a/src/simdag/sd_task.cpp b/src/simdag/sd_task.cpp
index 49d888f..33d2b5d 100644 (file)
--- a/src/simdag/sd_task.cpp
+++ b/src/simdag/sd_task.cpp
@@ -322,22 +322,25 @@ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
   case SD_SCHEDULED:
     if (SD_task_get_state(task) == SD_RUNNABLE){
       sd_global->initial_tasks->insert(task);
   case SD_SCHEDULED:
     if (SD_task_get_state(task) == SD_RUNNABLE){
       sd_global->initial_tasks->insert(task);

-      sd_global->executable_tasks->erase(task);
+      sd_global->runnable_tasks->erase(task);

     }
     break;
   case SD_RUNNABLE:
     idx = sd_global->initial_tasks->find(task);
     if (idx != sd_global->initial_tasks->end()) {
     }
     break;
   case SD_RUNNABLE:
     idx = sd_global->initial_tasks->find(task);
     if (idx != sd_global->initial_tasks->end()) {

-      sd_global->executable_tasks->insert(*idx);
+      sd_global->runnable_tasks->insert(*idx);

       sd_global->initial_tasks->erase(idx);
     }
     break;
   case SD_RUNNING:
       sd_global->initial_tasks->erase(idx);
     }
     break;
   case SD_RUNNING:

-    sd_global->executable_tasks->erase(task);
+    sd_global->runnable_tasks->erase(task);

     break;
   case SD_DONE:
     sd_global->completed_tasks->insert(task);
     break;
   case SD_DONE:
     sd_global->completed_tasks->insert(task);

+    task->start_time = task->surf_action->getStartTime();

     task->finish_time = task->surf_action->getFinishTime();
     task->finish_time = task->surf_action->getFinishTime();

+    task->surf_action->unref();
+    task->surf_action = nullptr;

     task->remains = 0;
 #if HAVE_JEDULE
     jedule_log_sd_event(task);
     task->remains = 0;
 #if HAVE_JEDULE
     jedule_log_sd_event(task);


@@ -345,6 +348,10 @@ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
     break;
   case SD_FAILED:
     sd_global->completed_tasks->insert(task);
     break;
   case SD_FAILED:
     sd_global->completed_tasks->insert(task);

+    task->start_time = task->surf_action->getStartTime();
+    task->finish_time = surf_get_clock();
+    task->surf_action->unref();
+    task->surf_action = nullptr;

     break;
   default:
     xbt_die( "Invalid state");
     break;
   default:
     xbt_die( "Invalid state");


@@ -354,7 +361,7 @@ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
 
   if (task->watch_points & new_state) {
     XBT_VERB("Watch point reached with task '%s'!", SD_task_get_name(task));
 
   if (task->watch_points & new_state) {
     XBT_VERB("Watch point reached with task '%s'!", SD_task_get_name(task));

-    sd_global->watch_point_reached = 1;
+    sd_global->watch_point_reached = true;

     SD_task_unwatch(task, new_state);   /* remove the watch point */
   }
 }
     SD_task_unwatch(task, new_state);   /* remove the watch point */
   }
 }


@@ -903,6 +910,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);
 
   __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);

 }
 
 /**
 }
 
 /**

diff --git a/src/simdag/simdag_private.h b/src/simdag/simdag_private.h
index 0ce8109..906205e 100644 (file)
--- a/src/simdag/simdag_private.h
+++ b/src/simdag/simdag_private.h
@@ -23,7 +23,7 @@ typedef struct SD_global {
   bool watch_point_reached;      /* has a task just reached a watch point? */
 
   std::set<SD_task_t> *initial_tasks;
   bool watch_point_reached;      /* has a task just reached a watch point? */
 
   std::set<SD_task_t> *initial_tasks;

-  std::set<SD_task_t> *executable_tasks;
+  std::set<SD_task_t> *runnable_tasks;

   std::set<SD_task_t> *completed_tasks;
 
   xbt_dynar_t return_set;
   std::set<SD_task_t> *completed_tasks;
 
   xbt_dynar_t return_set;


@@ -69,7 +69,7 @@ XBT_PRIVATE bool acyclic_graph_detail(xbt_dynar_t dag);
 XBT_PRIVATE void uniq_transfer_task_name(SD_task_t task);
 
 /* Task mallocator functions */
 XBT_PRIVATE void uniq_transfer_task_name(SD_task_t task);
 
 /* Task mallocator functions */

-XBT_PRIVATE void* SD_task_new_f(void);
+XBT_PRIVATE void* SD_task_new_f();

 XBT_PRIVATE void SD_task_recycle_f(void *t);
 XBT_PRIVATE void SD_task_free_f(void *t);
 
 XBT_PRIVATE void SD_task_recycle_f(void *t);
 XBT_PRIVATE void SD_task_free_f(void *t);
 

diff --git a/src/surf/surf_routing.cpp b/src/surf/surf_routing.cpp
index 313b39d..e79fbb0 100644 (file)
--- a/src/surf/surf_routing.cpp
+++ b/src/surf/surf_routing.cpp
@@ -90,7 +90,7 @@ namespace routing {
  * \param route where to store the list of links.
  *              If *route=nullptr, create a short lived dynar. Else, fill the provided dynar
  * \param latency where to store the latency experienced on the path (or nullptr if not interested)
  * \param route where to store the list of links.
  *              If *route=nullptr, create a short lived dynar. Else, fill the provided dynar
  * \param latency where to store the latency experienced on the path (or nullptr if not interested)

- *                It is the caller responsability to initialize latency to 0 (we add to provided route)
+ *                It is the caller responsibility to initialize latency to 0 (we add to provided route)

  * \pre route!=nullptr
  *
  * walk through the routing components tree and find a route between hosts
  * \pre route!=nullptr
  *
  * walk through the routing components tree and find a route between hosts