modify the way states are handled (get rid of swags)

1 test to revalidate (foreach order changes)

diff --git a/src/simdag/sd_daxloader.cpp b/src/simdag/sd_daxloader.cpp
index c1b80d2..b844ca8 100644 (file)
--- a/src/simdag/sd_daxloader.cpp
+++ b/src/simdag/sd_daxloader.cpp
@@ -271,7 +271,7 @@ xbt_dynar_t SD_daxload(const char *filename)
   jobs = xbt_dict_new_homogeneous(NULL);
   root_task = SD_task_create_comp_seq("root", NULL, 0);
   /* by design the root task is always SCHEDULABLE */
   jobs = xbt_dict_new_homogeneous(NULL);
   root_task = SD_task_create_comp_seq("root", NULL, 0);
   /* by design the root task is always SCHEDULABLE */

-  __SD_task_set_state(root_task, SD_SCHEDULABLE);
+  SD_task_set_state(root_task, SD_SCHEDULABLE);

 
   xbt_dynar_push(result, &root_task);
   end_task = SD_task_create_comp_seq("end", NULL, 0);
 
   xbt_dynar_push(result, &root_task);
   end_task = SD_task_create_comp_seq("end", NULL, 0);

diff --git a/src/simdag/sd_global.cpp b/src/simdag/sd_global.cpp
index f2726b1..0687a02 100644 (file)
--- a/src/simdag/sd_global.cpp
+++ b/src/simdag/sd_global.cpp
@@ -59,22 +59,10 @@ 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->task_mallocator=xbt_mallocator_new(65536, SD_task_new_f,SD_task_free_f,SD_task_recycle_f);
 

-  sd_global->not_scheduled_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->schedulable_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->scheduled_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->runnable_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->in_fifo_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->running_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->done_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->failed_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+  sd_global->initial_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL);
+  sd_global->executable_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL);
+  sd_global->completed_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL);
+

   sd_global->return_set =
       xbt_swag_new(xbt_swag_offset(task, return_hookup));
   sd_global->task_number = 0;
   sd_global->return_set =
       xbt_swag_new(xbt_swag_offset(task, return_hookup));
   sd_global->task_number = 0;


@@ -125,52 +113,27 @@ void SD_config(const char *key, const char *value){
 void SD_application_reinit(void)
 {
 
 void SD_application_reinit(void)
 {
 

-  s_SD_task_t task;
+//  s_SD_task_t task;

 
 

-  SD_task_t done_task, next_done_task;
+//  SD_task_t done_task, next_done_task;

   xbt_die("This function is not working since the C++ links and others. Please report the problem if you really need that function.");
 
    XBT_DEBUG("Recreating the swags...");
   xbt_die("This function is not working since the C++ links and others. Please report the problem if you really need that function.");
 
    XBT_DEBUG("Recreating the swags...");

-  xbt_swag_free(sd_global->not_scheduled_task_set);
-  xbt_swag_free(sd_global->schedulable_task_set);
-  xbt_swag_free(sd_global->scheduled_task_set);
-  xbt_swag_free(sd_global->runnable_task_set);
-  xbt_swag_free(sd_global->in_fifo_task_set);
-  xbt_swag_free(sd_global->running_task_set);
-  xbt_swag_free(sd_global->failed_task_set);
-
-  sd_global->not_scheduled_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->schedulable_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  xbt_swag_foreach_safe(done_task, next_done_task, sd_global->done_task_set){
-    if (xbt_dynar_is_empty(done_task->tasks_before)){
-      __SD_task_set_state(done_task, SD_SCHEDULABLE);
-    } else{
-      __SD_task_set_state(done_task, SD_NOT_SCHEDULED);
-      done_task->unsatisfied_dependencies =
-        xbt_dynar_length(done_task->tasks_before);
-      done_task->is_not_ready = done_task->unsatisfied_dependencies;
-    }
-    free(done_task->workstation_list);
-    done_task->workstation_list = NULL;
-    done_task->workstation_nb = 0;
-  }

 
 

-  xbt_swag_free(sd_global->done_task_set);
-
-  sd_global->scheduled_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->runnable_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->in_fifo_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->running_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->done_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->failed_task_set =
-      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+//  xbt_swag_foreach_safe(done_task, next_done_task, sd_global->done_task_set){
+//    if (xbt_dynar_is_empty(done_task->tasks_before)){
+//      __SD_task_set_state(done_task, SD_SCHEDULABLE);
+//    } else{
+//      __SD_task_set_state(done_task, SD_NOT_SCHEDULED);
+//      done_task->unsatisfied_dependencies =
+//        xbt_dynar_length(done_task->tasks_before);
+//      done_task->is_not_ready = done_task->unsatisfied_dependencies;
+//    }
+//    free(done_task->workstation_list);
+//    done_task->workstation_list = NULL;
+//    done_task->workstation_nb = 0;
+//  }
+

   sd_global->task_number = 0;
 
 
   sd_global->task_number = 0;
 
 


@@ -260,7 +223,7 @@ xbt_dynar_t SD_simulate(double how_long) {
 xbt_swag_t SD_simulate_swag(double how_long) {
   double total_time = 0.0;      /* we stop the simulation when total_time >= how_long */
   double elapsed_time = 0.0;
 xbt_swag_t SD_simulate_swag(double how_long) {
   double total_time = 0.0;      /* we stop the simulation when total_time >= how_long */
   double elapsed_time = 0.0;

-  SD_task_t task, task_safe, dst;
+  SD_task_t task, dst;

   SD_dependency_t dependency;
   surf_action_t action;
   unsigned int iter, depcnt;
   SD_dependency_t dependency;
   surf_action_t action;
   unsigned int iter, depcnt;


@@ -279,10 +242,12 @@ xbt_swag_t SD_simulate_swag(double how_long) {
   xbt_swag_reset(sd_global->return_set);
 
   /* explore the runnable tasks */
   xbt_swag_reset(sd_global->return_set);
 
   /* explore the runnable tasks */

-  xbt_swag_foreach_safe(task, task_safe, sd_global->runnable_task_set) {
+  xbt_dynar_foreach(sd_global->executable_task_set , iter, task) {

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

-    if (__SD_task_try_to_run(task))
+    if (__SD_task_try_to_run(task)){

       xbt_swag_insert(task,sd_global->return_set);
       xbt_swag_insert(task,sd_global->return_set);

+      iter--;
+    }

   }
 
   /* main loop */
   }
 
   /* main loop */


@@ -330,14 +295,15 @@ xbt_swag_t SD_simulate_swag(double how_long) {
              dst->is_not_ready);
 
           if (!(dst->unsatisfied_dependencies)) {
              dst->is_not_ready);
 
           if (!(dst->unsatisfied_dependencies)) {

-            if (__SD_task_is_scheduled(dst))
-              __SD_task_set_state(dst, SD_RUNNABLE);
+            if (SD_task_get_state(dst) == SD_SCHEDULED)
+              SD_task_set_state(dst, SD_RUNNABLE);

             else
             else

-              __SD_task_set_state(dst, SD_SCHEDULABLE);
+              SD_task_set_state(dst, SD_SCHEDULABLE);

           }
 
           }
 

-          if (__SD_task_is_not_scheduled(dst) && !(dst->is_not_ready)) {
-            __SD_task_set_state(dst, SD_SCHEDULABLE);
+          if (SD_task_get_state(dst) == SD_NOT_SCHEDULED &&
+              !(dst->is_not_ready)) {
+            SD_task_set_state(dst, SD_SCHEDULABLE);

           }
 
           if (SD_task_get_kind(dst) == SD_TASK_COMM_E2E) {
           }
 
           if (SD_task_get_kind(dst) == SD_TASK_COMM_E2E) {


@@ -345,7 +311,7 @@ xbt_swag_t SD_simulate_swag(double how_long) {
             SD_task_t comm_dst;
             xbt_dynar_get_cpy(dst->tasks_after, 0, &comm_dep);
             comm_dst = comm_dep->dst;
             SD_task_t comm_dst;
             xbt_dynar_get_cpy(dst->tasks_after, 0, &comm_dep);
             comm_dst = comm_dep->dst;

-            if (__SD_task_is_not_scheduled(comm_dst) &&
+            if (SD_task_get_state(comm_dst) == SD_NOT_SCHEDULED &&

                 comm_dst->is_not_ready > 0) {
               comm_dst->is_not_ready--;
 
                 comm_dst->is_not_ready > 0) {
               comm_dst->is_not_ready--;
 


@@ -354,13 +320,13 @@ xbt_swag_t SD_simulate_swag(double how_long) {
                comm_dst->is_not_ready);
 
               if (!(comm_dst->is_not_ready)) {
                comm_dst->is_not_ready);
 
               if (!(comm_dst->is_not_ready)) {

-                __SD_task_set_state(comm_dst, SD_SCHEDULABLE);
+                SD_task_set_state(comm_dst, SD_SCHEDULABLE);

               }
             }
           }
 
           /* is dst runnable now? */
               }
             }
           }
 
           /* is dst runnable now? */

-          if (__SD_task_is_runnable(dst)
+          if (SD_task_get_state(dst) == SD_RUNNABLE

               && !sd_global->watch_point_reached) {
             XBT_VERB("Executing task '%s'", SD_task_get_name(dst));
             if (__SD_task_try_to_run(dst))
               && !sd_global->watch_point_reached) {
             XBT_VERB("Executing task '%s'", SD_task_get_name(dst));
             if (__SD_task_try_to_run(dst))


@@ -375,7 +341,7 @@ xbt_swag_t SD_simulate_swag(double how_long) {
         task->start_time = surf_action_get_start_time(task->surf_action);
         task->finish_time = surf_get_clock();
         XBT_VERB("Task '%s' failed", SD_task_get_name(task));
         task->start_time = surf_action_get_start_time(task->surf_action);
         task->finish_time = surf_get_clock();
         XBT_VERB("Task '%s' failed", SD_task_get_name(task));

-        __SD_task_set_state(task, SD_FAILED);
+        SD_task_set_state(task, SD_FAILED);

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


@@ -385,18 +351,19 @@ xbt_swag_t SD_simulate_swag(double how_long) {
   }
 
   if (!sd_global->watch_point_reached && how_long<0){
   }
 
   if (!sd_global->watch_point_reached && how_long<0){

-    if (xbt_swag_size(sd_global->done_task_set) < sd_global->task_number){
+    if ((int) xbt_dynar_length(sd_global->completed_task_set) <
+         sd_global->task_number){

         XBT_WARN("Simulation is finished but %d tasks are still not done",
         XBT_WARN("Simulation is finished but %d tasks are still not done",

-            (sd_global->task_number - xbt_swag_size(sd_global->done_task_set)));
-        xbt_swag_foreach_safe (task, task_safe,sd_global->not_scheduled_task_set){
-                XBT_WARN("%s is in SD_NOT_SCHEDULED state", SD_task_get_name(task));
-    }
-      xbt_swag_foreach_safe (task, task_safe,sd_global->schedulable_task_set){
-                XBT_WARN("%s is in SD_SCHEDULABLE state", SD_task_get_name(task));
-  }
-        xbt_swag_foreach_safe (task, task_safe,sd_global->scheduled_task_set){
-                XBT_WARN("%s is in SD_SCHEDULED state", SD_task_get_name(task));
-         }
+            (sd_global->task_number -
+             (int) xbt_dynar_length(sd_global->completed_task_set)));
+        static const char* state_names[] =
+              { "SD_NOT_SCHEDULED", "SD_SCHEDULABLE", "SD_SCHEDULED",
+                "SD_RUNNABLE", "SD_IN_INFO", "SD_RUNNING", "SD_DONE",
+                "SD_FAILED" };
+        xbt_dynar_foreach(sd_global->initial_task_set, iter, task){
+          XBT_WARN("%s is in %s state", SD_task_get_name(task),
+                   state_names[SD_task_get_state(task)]);
+        }

     }
   }
 
     }
   }
 


@@ -436,14 +403,9 @@ void SD_exit(void)
   xbt_free(sd_global->recyclable_route);
 
   XBT_DEBUG("Destroying the swags...");
   xbt_free(sd_global->recyclable_route);
 
   XBT_DEBUG("Destroying the swags...");

-  xbt_swag_free(sd_global->not_scheduled_task_set);
-  xbt_swag_free(sd_global->schedulable_task_set);
-  xbt_swag_free(sd_global->scheduled_task_set);
-  xbt_swag_free(sd_global->runnable_task_set);
-  xbt_swag_free(sd_global->in_fifo_task_set);
-  xbt_swag_free(sd_global->running_task_set);
-  xbt_swag_free(sd_global->done_task_set);
-  xbt_swag_free(sd_global->failed_task_set);
+  xbt_dynar_free_container(&(sd_global->initial_task_set));
+  xbt_dynar_free_container(&(sd_global->executable_task_set));
+  xbt_dynar_free_container(&(sd_global->completed_task_set));

   xbt_swag_free(sd_global->return_set);
 
   TRACE_end();
   xbt_swag_free(sd_global->return_set);
 
   TRACE_end();

diff --git a/src/simdag/sd_task.cpp b/src/simdag/sd_task.cpp
index 2a96efa..89c3c78 100644 (file)
--- a/src/simdag/sd_task.cpp
+++ b/src/simdag/sd_task.cpp
@@ -33,11 +33,8 @@ void SD_task_recycle_f(void *t)
 
   /* Reset the content */
   task->kind = SD_TASK_NOT_TYPED;
 
   /* Reset the content */
   task->kind = SD_TASK_NOT_TYPED;

-  task->state_hookup.prev = NULL;
-  task->state_hookup.next = NULL;
-  task->state_set = sd_global->not_scheduled_task_set;
-  xbt_swag_insert(task, task->state_set);
-  task->state = SD_NOT_SCHEDULED;
+  task->state= SD_NOT_SCHEDULED;
+  xbt_dynar_push(sd_global->initial_task_set,&task);

   task->return_hookup.prev = NULL;
   task->return_hookup.next = NULL;
 
   task->return_hookup.prev = NULL;
   task->return_hookup.next = NULL;
 


@@ -241,8 +238,6 @@ void SD_task_destroy(SD_task_t task)
   /* if the task was scheduled or runnable we have to free the scheduling parameters */
   if (__SD_task_is_scheduled_or_runnable(task))
     __SD_task_destroy_scheduling_data(task);
   /* if the task was scheduled or runnable we have to free the scheduling parameters */
   if (__SD_task_is_scheduled_or_runnable(task))
     __SD_task_destroy_scheduling_data(task);

-  if (task->state_set != NULL) /* would be null if just created */
-    xbt_swag_remove(task, task->state_set);

 
   xbt_swag_remove(task, sd_global->return_set);
 
 
   xbt_swag_remove(task, sd_global->return_set);
 


@@ -331,31 +326,50 @@ e_SD_task_state_t SD_task_get_state(SD_task_t task)
 
 /* Changes the state of a task. Updates the swags and the flag sd_global->watch_point_reached.
  */
 
 /* Changes the state of a task. Updates the swags and the flag sd_global->watch_point_reached.
  */

-void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
+void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)

 {
 {

-  xbt_swag_remove(task, task->state_set);
+  int idx;

   switch (new_state) {
   case SD_NOT_SCHEDULED:
   switch (new_state) {
   case SD_NOT_SCHEDULED:

-    task->state_set = sd_global->not_scheduled_task_set;
-    break;

   case SD_SCHEDULABLE:
   case SD_SCHEDULABLE:

-    task->state_set = sd_global->schedulable_task_set;
+    if (SD_task_get_state(task) == SD_FAILED){
+        xbt_dynar_remove_at(sd_global->completed_task_set,
+            xbt_dynar_search(sd_global->completed_task_set, &task), &task);
+        xbt_dynar_push(sd_global->initial_task_set,&task);
+    }

     break;
   case SD_SCHEDULED:
     break;
   case SD_SCHEDULED:

-    task->state_set = sd_global->scheduled_task_set;
-    break;
-  case SD_RUNNABLE:
-    task->state_set = sd_global->runnable_task_set;
+    if (SD_task_get_state(task) == SD_RUNNABLE){
+      xbt_dynar_remove_at(sd_global->executable_task_set,
+          xbt_dynar_search(sd_global->executable_task_set, &task), &task);
+      xbt_dynar_push(sd_global->initial_task_set,&task);
+    }

     break;
   case SD_IN_FIFO:
     break;
   case SD_IN_FIFO:

-    task->state_set = sd_global->in_fifo_task_set;
+    xbt_dynar_remove_at(sd_global->executable_task_set,
+       xbt_dynar_search(sd_global->executable_task_set, &task), &task);
+    xbt_dynar_push(sd_global->initial_task_set,&task);
+    break;
+  case SD_RUNNABLE:
+    idx = xbt_dynar_search_or_negative(sd_global->initial_task_set, &task);
+    if (idx >= 0) {
+      xbt_dynar_remove_at(sd_global->initial_task_set, idx, &task);
+      xbt_dynar_push(sd_global->executable_task_set,&task);
+    }

     break;
   case SD_RUNNING:
     break;
   case SD_RUNNING:

-    task->state_set = sd_global->running_task_set;
-    task->start_time = task->surf_action->getStartTime();
+    if (SD_task_get_state(task) == SD_RUNNABLE){
+      xbt_dynar_remove_at(sd_global->executable_task_set,
+         xbt_dynar_search(sd_global->executable_task_set, &task), &task);
+    } else {
+      if (SD_task_get_state(task) == SD_IN_FIFO){
+        xbt_dynar_remove_at(sd_global->initial_task_set,
+            xbt_dynar_search(sd_global->initial_task_set, &task), &task);
+      }
+    }

     break;
   case SD_DONE:
     break;
   case SD_DONE:

-    task->state_set = sd_global->done_task_set;
+    xbt_dynar_push(sd_global->completed_task_set,&task);

     task->finish_time = task->surf_action->getFinishTime();
     task->remains = 0;
 #ifdef HAVE_JEDULE
     task->finish_time = task->surf_action->getFinishTime();
     task->remains = 0;
 #ifdef HAVE_JEDULE


@@ -363,12 +377,12 @@ void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
 #endif
     break;
   case SD_FAILED:
 #endif
     break;
   case SD_FAILED:

-    task->state_set = sd_global->failed_task_set;
+    xbt_dynar_push(sd_global->completed_task_set,&task);

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

-  xbt_swag_insert(task, task->state_set);
+

   task->state = new_state;
 
   if (task->watch_points & new_state) {
   task->state = new_state;
 
   if (task->watch_points & new_state) {


@@ -636,6 +650,7 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src,
   int found = 0;
   unsigned long i;
   SD_dependency_t dependency;
   int found = 0;
   unsigned long i;
   SD_dependency_t dependency;

+  e_SD_task_state_t state;

 
   dynar = src->tasks_after;
   length = xbt_dynar_length(dynar);
 
   dynar = src->tasks_after;
   length = xbt_dynar_length(dynar);


@@ -645,18 +660,19 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src,
            "Cannot add a dependency between task '%s' and itself",
            SD_task_get_name(src));
 
            "Cannot add a dependency between task '%s' and itself",
            SD_task_get_name(src));
 

-  if (!__SD_task_is_not_scheduled(src) && !__SD_task_is_schedulable(src)
-      && !__SD_task_is_scheduled_or_runnable(src) && !__SD_task_is_running(src))
+  state = SD_task_get_state(src);
+  if (state != SD_NOT_SCHEDULED && state != SD_SCHEDULABLE &&
+      state != SD_RUNNING && !__SD_task_is_scheduled_or_runnable(src))

     THROWF(arg_error, 0,
     THROWF(arg_error, 0,

-           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED or SD_RUNNABLE"
-     " or SD_RUNNING",
-           SD_task_get_name(src));
+           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED,"
+           " SD_RUNNABLE or SD_RUNNING", SD_task_get_name(src));

 
 

-  if (!__SD_task_is_not_scheduled(dst) && !__SD_task_is_schedulable(dst)
-      && !__SD_task_is_scheduled_or_runnable(dst))
+  state = SD_task_get_state(dst);
+  if (state != SD_NOT_SCHEDULED && state != SD_SCHEDULABLE &&
+      !__SD_task_is_scheduled_or_runnable(dst))

     THROWF(arg_error, 0,
     THROWF(arg_error, 0,

-           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED or SD_RUNNABLE",
-           SD_task_get_name(dst));
+           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED,"
+           "or SD_RUNNABLE", SD_task_get_name(dst));

 
   XBT_DEBUG("SD_task_dependency_add: src = %s, dst = %s",
          SD_task_get_name(src), SD_task_get_name(dst));
 
   XBT_DEBUG("SD_task_dependency_add: src = %s, dst = %s",
          SD_task_get_name(src), SD_task_get_name(dst));


@@ -688,11 +704,11 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src,
 
   /* if the task was runnable, then dst->tasks_before is not empty anymore,
      so we must go back to state SD_SCHEDULED */
 
   /* if the task was runnable, then dst->tasks_before is not empty anymore,
      so we must go back to state SD_SCHEDULED */

-  if (__SD_task_is_runnable(dst)) {
+  if (SD_task_get_state(dst) == SD_RUNNABLE) {

     XBT_DEBUG
         ("SD_task_dependency_add: %s was runnable and becomes scheduled!",
          SD_task_get_name(dst));
     XBT_DEBUG
         ("SD_task_dependency_add: %s was runnable and becomes scheduled!",
          SD_task_get_name(dst));

-    __SD_task_set_state(dst, SD_SCHEDULED);
+    SD_task_set_state(dst, SD_SCHEDULED);

   }
 }
 /**
   }
 }
 /**


@@ -803,14 +819,14 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst)
   /* if the task was scheduled and dst->tasks_before is empty now, we can make it runnable */
 
   if (dst->unsatisfied_dependencies == 0) {
   /* if the task was scheduled and dst->tasks_before is empty now, we can make it runnable */
 
   if (dst->unsatisfied_dependencies == 0) {

-    if (__SD_task_is_scheduled(dst))
-      __SD_task_set_state(dst, SD_RUNNABLE);
+    if (SD_task_get_state(dst) == SD_SCHEDULED)
+      SD_task_set_state(dst, SD_RUNNABLE);

     else
     else

-      __SD_task_set_state(dst, SD_SCHEDULABLE);
+      SD_task_set_state(dst, SD_SCHEDULABLE);

   }
 
   if (dst->is_not_ready == 0)
   }
 
   if (dst->is_not_ready == 0)

-    __SD_task_set_state(dst, SD_SCHEDULABLE);
+    SD_task_set_state(dst, SD_SCHEDULABLE);

 
   /*  __SD_print_dependencies(src);
      __SD_print_dependencies(dst); */
 
   /*  __SD_print_dependencies(src);
      __SD_print_dependencies(dst); */


@@ -846,29 +862,6 @@ void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst)
   return dependency->data;
 }
 
   return dependency->data;
 }
 

-/* temporary function for debugging */
-static void __SD_print_watch_points(SD_task_t task)
-{
-  static const int state_masks[] =
-      { SD_SCHEDULABLE, SD_SCHEDULED, SD_RUNNING, SD_RUNNABLE, SD_DONE,
-    SD_FAILED
-  };
-  static const char *state_names[] =
-      { "schedulable", "scheduled", "running", "runnable", "done",
-    "failed"
-  };
-  int i;
-
-  XBT_INFO("Task '%s' watch points (%x): ", SD_task_get_name(task),
-        task->watch_points);
-
-
-  for (i = 0; i < 5; i++) {
-    if (task->watch_points & state_masks[i])
-      XBT_INFO("%s ", state_names[i]);
-  }
-}
-

 /**
  * \brief Adds a watch point to a task
  *
 /**
  * \brief Adds a watch point to a task
  *


@@ -888,7 +881,6 @@ void SD_task_watch(SD_task_t task, e_SD_task_state_t state)
            "Cannot add a watch point for state SD_NOT_SCHEDULED");
 
   task->watch_points = task->watch_points | state;
            "Cannot add a watch point for state SD_NOT_SCHEDULED");
 
   task->watch_points = task->watch_points | state;

-  /*  __SD_print_watch_points(task); */

 }
 
 /**
 }
 
 /**


@@ -904,7 +896,6 @@ void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state)
               "SimDag error: Cannot have a watch point for state SD_NOT_SCHEDULED");
 
   task->watch_points = task->watch_points & ~state;
               "SimDag error: Cannot have a watch point for state SD_NOT_SCHEDULED");
 
   task->watch_points = task->watch_points & ~state;

-  /*  __SD_print_watch_points(task); */

 }
 
 /**
 }
 
 /**


@@ -959,15 +950,15 @@ double SD_task_get_execution_time(SD_task_t task,
 
 static XBT_INLINE void SD_task_do_schedule(SD_task_t task)
 {
 
 static XBT_INLINE void SD_task_do_schedule(SD_task_t task)
 {

-  if (!__SD_task_is_not_scheduled(task) && !__SD_task_is_schedulable(task))
+  if (SD_task_get_state(task) > SD_SCHEDULABLE)

     THROWF(arg_error, 0, "Task '%s' has already been scheduled",
            SD_task_get_name(task));
 
   /* update the task state */
   if (task->unsatisfied_dependencies == 0)
     THROWF(arg_error, 0, "Task '%s' has already been scheduled",
            SD_task_get_name(task));
 
   /* update the task state */
   if (task->unsatisfied_dependencies == 0)

-    __SD_task_set_state(task, SD_RUNNABLE);
+    SD_task_set_state(task, SD_RUNNABLE);

   else
   else

-    __SD_task_set_state(task, SD_SCHEDULED);
+    SD_task_set_state(task, SD_SCHEDULED);

 }
 
 /**
 }
 
 /**


@@ -1037,10 +1028,10 @@ void SD_task_schedule(SD_task_t task, int workstation_count,
  */
 void SD_task_unschedule(SD_task_t task)
 {
  */
 void SD_task_unschedule(SD_task_t task)
 {

-  if (task->state_set != sd_global->scheduled_task_set &&
-      task->state_set != sd_global->runnable_task_set &&
-      task->state_set != sd_global->running_task_set &&
-      task->state_set != sd_global->failed_task_set)
+  if (task->state != SD_SCHEDULED &&
+      task->state != SD_RUNNABLE &&
+      task->state != SD_RUNNING &&
+      task->state != SD_FAILED)

     THROWF(arg_error, 0,
            "Task %s: the state must be SD_SCHEDULED, SD_RUNNABLE, SD_RUNNING or SD_FAILED",
            SD_task_get_name(task));
     THROWF(arg_error, 0,
            "Task %s: the state must be SD_SCHEDULED, SD_RUNNABLE, SD_RUNNING or SD_FAILED",
            SD_task_get_name(task));


@@ -1054,13 +1045,14 @@ void SD_task_unschedule(SD_task_t task)
     task->workstation_nb = 0;
   }
 
     task->workstation_nb = 0;
   }
 

-  if (__SD_task_is_running(task))       /* the task should become SD_FAILED */
-       task->surf_action->cancel();
+  if (SD_task_get_state(task) == SD_RUNNING)
+    /* the task should become SD_FAILED */
+    task->surf_action->cancel();

   else {
     if (task->unsatisfied_dependencies == 0)
   else {
     if (task->unsatisfied_dependencies == 0)

-      __SD_task_set_state(task, SD_SCHEDULABLE);
+      SD_task_set_state(task, SD_SCHEDULABLE);

     else
     else

-      __SD_task_set_state(task, SD_NOT_SCHEDULED);
+      SD_task_set_state(task, SD_NOT_SCHEDULED);

   }
   task->remains = task->amount;
   task->start_time = -1.0;
   }
   task->remains = task->amount;
   task->start_time = -1.0;


@@ -1072,7 +1064,7 @@ void SD_task_unschedule(SD_task_t task)
 static void __SD_task_destroy_scheduling_data(SD_task_t task)
 {
   if (!__SD_task_is_scheduled_or_runnable(task)
 static void __SD_task_destroy_scheduling_data(SD_task_t task)
 {
   if (!__SD_task_is_scheduled_or_runnable(task)

-      && !__SD_task_is_in_fifo(task))
+      && SD_task_get_state(task) != SD_IN_FIFO)

     THROWF(arg_error, 0,
            "Task '%s' must be SD_SCHEDULED, SD_RUNNABLE or SD_IN_FIFO",
            SD_task_get_name(task));
     THROWF(arg_error, 0,
            "Task '%s' must be SD_SCHEDULED, SD_RUNNABLE or SD_IN_FIFO",
            SD_task_get_name(task));


@@ -1145,8 +1137,9 @@ void __SD_task_really_run(SD_task_t task)
     TRACE_surf_action(task->surf_action, task->category);
 
   __SD_task_destroy_scheduling_data(task);      /* now the scheduling data are not useful anymore */
     TRACE_surf_action(task->surf_action, task->category);
 
   __SD_task_destroy_scheduling_data(task);      /* now the scheduling data are not useful anymore */

-  __SD_task_set_state(task, SD_RUNNING);
-  xbt_assert(__SD_task_is_running(task), "Bad state of task '%s': %d",
+  SD_task_set_state(task, SD_RUNNING);
+  xbt_assert(SD_task_get_state(task) == SD_RUNNING,
+             "Bad state of task '%s': %d",

              SD_task_get_name(task), (int)SD_task_get_state(task));
 
 }
              SD_task_get_name(task), (int)SD_task_get_state(task));
 
 }


@@ -1165,7 +1158,7 @@ int __SD_task_try_to_run(SD_task_t task)
   int i;
   SD_workstation_t workstation;
 
   int i;
   SD_workstation_t workstation;
 

-  xbt_assert(__SD_task_is_runnable(task),
+  xbt_assert(SD_task_get_state(task) == SD_RUNNABLE,

               "Task '%s' is not runnable! Task state: %d",
              SD_task_get_name(task), (int)SD_task_get_state(task));
 
               "Task '%s' is not runnable! Task state: %d",
              SD_task_get_name(task), (int)SD_task_get_state(task));
 


@@ -1187,9 +1180,7 @@ int __SD_task_try_to_run(SD_task_t task)
         xbt_fifo_push(sg_host_sd(workstation)->task_fifo, task);
       }
     }
         xbt_fifo_push(sg_host_sd(workstation)->task_fifo, task);
       }
     }

-    __SD_task_set_state(task, SD_IN_FIFO);
-    xbt_assert(__SD_task_is_in_fifo(task), "Bad state of task '%s': %d",
-               SD_task_get_name(task), (int)SD_task_get_state(task));
+    SD_task_set_state(task, SD_IN_FIFO);

     XBT_DEBUG("Task '%s' state is now SD_IN_FIFO", SD_task_get_name(task));
   } else {
     __SD_task_really_run(task);
     XBT_DEBUG("Task '%s' state is now SD_IN_FIFO", SD_task_get_name(task));
   } else {
     __SD_task_really_run(task);


@@ -1213,7 +1204,7 @@ void __SD_task_just_done(SD_task_t task)
   SD_task_t *candidates;
   int can_start = 1;
 
   SD_task_t *candidates;
   int can_start = 1;
 

-  xbt_assert(__SD_task_is_running(task),
+  xbt_assert(SD_task_get_state(task)== SD_RUNNING,

               "The task must be running! Task state: %d",
               (int)SD_task_get_state(task));
   xbt_assert(task->workstation_list != NULL,
               "The task must be running! Task state: %d",
               (int)SD_task_get_state(task));
   xbt_assert(task->workstation_list != NULL,


@@ -1223,7 +1214,7 @@ void __SD_task_just_done(SD_task_t task)
 
   candidates = xbt_new(SD_task_t, 8);
 
 
   candidates = xbt_new(SD_task_t, 8);
 

-  __SD_task_set_state(task, SD_DONE);
+  SD_task_set_state(task, SD_DONE);

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


@@ -1234,8 +1225,10 @@ 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",
   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)sg_host_sd(workstation)->access_mode);
-    if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+              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(sg_host_sd(workstation)->task_fifo != NULL,
                   "Workstation '%s' has sequential access but no FIFO!",
                   SD_workstation_get_name(workstation));


@@ -1254,7 +1247,7 @@ void __SD_task_just_done(SD_task_t task)
 
       if (candidate != NULL) {
         XBT_DEBUG("Candidate: '%s'", SD_task_get_name(candidate));
 
       if (candidate != NULL) {
         XBT_DEBUG("Candidate: '%s'", SD_task_get_name(candidate));

-        xbt_assert(__SD_task_is_in_fifo(candidate),
+        xbt_assert(SD_task_get_state(candidate) == SD_IN_FIFO,

                     "Bad state of candidate '%s': %d",
                     SD_task_get_name(candidate),
                     (int)SD_task_get_state(candidate));
                     "Bad state of candidate '%s': %d",
                     SD_task_get_name(candidate),
                     (int)SD_task_get_state(candidate));


@@ -1295,7 +1288,7 @@ void __SD_task_just_done(SD_task_t task)
       continue;                 /* we have already evaluated that task */
     }
 
       continue;                 /* we have already evaluated that task */
     }
 

-    xbt_assert(__SD_task_is_in_fifo(candidate),
+    xbt_assert(SD_task_get_state(candidate) == SD_IN_FIFO,

                 "Bad state of candidate '%s': %d",
                SD_task_get_name(candidate), (int)SD_task_get_state(candidate));
 
                 "Bad state of candidate '%s': %d",
                SD_task_get_name(candidate), (int)SD_task_get_state(candidate));
 


@@ -1321,11 +1314,14 @@ void __SD_task_just_done(SD_task_t task)
         /* update the FIFO */
         if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
           candidate = (SD_task_t)xbt_fifo_shift(sg_host_sd(workstation)->task_fifo);   /* the return value is stored just for debugging */
         /* update the FIFO */
         if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
           candidate = (SD_task_t)xbt_fifo_shift(sg_host_sd(workstation)->task_fifo);   /* the return value is stored just for debugging */

-          XBT_DEBUG("Head of the FIFO: '%s'",
+          XBT_DEBUG("Head of the FIFO: '%s' on workstation %s (%d task left)",

                  (candidate !=
                  (candidate !=

-                  NULL) ? SD_task_get_name(candidate) : "NULL");
+                  NULL) ? SD_task_get_name(candidate) : "NULL",
+                  SD_workstation_get_name(workstation),
+                  xbt_fifo_size(sg_host_sd(workstation)->task_fifo));

           xbt_assert(candidate == candidates[i],
                       "Error in __SD_task_just_done: bad first task in the FIFO");
           xbt_assert(candidate == candidates[i],
                       "Error in __SD_task_just_done: bad first task in the FIFO");

+

         }
       }                         /* for each workstation */
 
         }
       }                         /* for each workstation */
 


@@ -1335,10 +1331,9 @@ void __SD_task_just_done(SD_task_t task)
       __SD_task_really_run(candidate);
 
       XBT_DEBUG
       __SD_task_really_run(candidate);
 
       XBT_DEBUG

-          ("Calling __SD_task_is_running: task '%s', state set: %p, running_task_set: %p, is running: %d",
-           SD_task_get_name(candidate), candidate->state_set,
-           sd_global->running_task_set, __SD_task_is_running(candidate));
-      xbt_assert(__SD_task_is_running(candidate),
+          ("Calling __SD_task_is_running: task '%s', state set: %d",
+           SD_task_get_name(candidate), candidate->state);
+      xbt_assert(SD_task_get_state(candidate) == SD_RUNNING,

                   "Bad state of task '%s': %d",
                   SD_task_get_name(candidate),
                  (int)SD_task_get_state(candidate));
                   "Bad state of task '%s': %d",
                   SD_task_get_name(candidate),
                  (int)SD_task_get_state(candidate));


@@ -1502,8 +1497,7 @@ void SD_task_schedulev(SD_task_t task, int count,
         before->workstation_list[1] = task->workstation_list[0];
 
         if (before->workstation_list[0] &&
         before->workstation_list[1] = task->workstation_list[0];
 
         if (before->workstation_list[0] &&

-            (__SD_task_is_schedulable(before)
-             || __SD_task_is_not_scheduled(before))) {
+            (SD_task_get_state(before)< SD_SCHEDULED)) {

           SD_task_do_schedule(before);
           XBT_VERB
               ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes",
           SD_task_do_schedule(before);
           XBT_VERB
               ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes",


@@ -1519,8 +1513,7 @@ void SD_task_schedulev(SD_task_t task, int count,
       if (after->kind == SD_TASK_COMM_E2E) {
         after->workstation_list[0] = task->workstation_list[0];
         if (after->workstation_list[1]
       if (after->kind == SD_TASK_COMM_E2E) {
         after->workstation_list[0] = task->workstation_list[0];
         if (after->workstation_list[1]

-            && (__SD_task_is_not_scheduled(after)
-                || __SD_task_is_schedulable(after))) {
+            && (SD_task_get_state(after)< SD_SCHEDULED)) {

           SD_task_do_schedule(after);
           XBT_VERB
               ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes",
           SD_task_do_schedule(after);
           XBT_VERB
               ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes",


@@ -1596,8 +1589,7 @@ void SD_task_schedulev(SD_task_t task, int count,
             }
           }
 
             }
           }
 

-          if (__SD_task_is_schedulable(before) ||
-              __SD_task_is_not_scheduled(before)) {
+          if (SD_task_get_state(before)< SD_SCHEDULED) {

             SD_task_do_schedule(before);
             XBT_VERB
               ("Auto-Schedule redistribution task %s. Send %.f bytes from %d hosts to %d hosts.",
             SD_task_do_schedule(before);
             XBT_VERB
               ("Auto-Schedule redistribution task %s. Send %.f bytes from %d hosts to %d hosts.",


@@ -1660,8 +1652,7 @@ void SD_task_schedulev(SD_task_t task, int count,
             }
           }
 
             }
           }
 

-          if (__SD_task_is_schedulable(after) ||
-              __SD_task_is_not_scheduled(after)) {
+          if (SD_task_get_state(after)< SD_SCHEDULED) {

             SD_task_do_schedule(after);
             XBT_VERB
             ("Auto-Schedule redistribution task %s. Send %.f bytes from %d hosts to %d hosts.",
             SD_task_do_schedule(after);
             XBT_VERB
             ("Auto-Schedule redistribution task %s. Send %.f bytes from %d hosts to %d hosts.",

diff --git a/src/simdag/simdag_private.h b/src/simdag/simdag_private.h
index 0a3bc8c..193e278 100644 (file)
--- a/src/simdag/simdag_private.h
+++ b/src/simdag/simdag_private.h
@@ -33,15 +33,9 @@ typedef struct SD_global {
 
   int watch_point_reached;      /* has a task just reached a watch point? */
 
 
   int watch_point_reached;      /* has a task just reached a watch point? */
 

-  /* task state sets */
-  xbt_swag_t not_scheduled_task_set;
-  xbt_swag_t schedulable_task_set;
-  xbt_swag_t scheduled_task_set;
-  xbt_swag_t runnable_task_set;
-  xbt_swag_t in_fifo_task_set;
-  xbt_swag_t running_task_set;
-  xbt_swag_t done_task_set;
-  xbt_swag_t failed_task_set;
+  xbt_dynar_t initial_task_set;
+  xbt_dynar_t executable_task_set;
+  xbt_dynar_t completed_task_set;

 
   xbt_swag_t return_set;
   int task_number;
 
   xbt_swag_t return_set;
   int task_number;


@@ -72,9 +66,7 @@ static inline SD_storage_priv_t SD_storage_priv(SD_storage_t storage){
 
 /* Task */
 typedef struct SD_task {
 
 /* Task */
 typedef struct SD_task {

-  s_xbt_swag_hookup_t state_hookup;

   s_xbt_swag_hookup_t return_hookup;
   s_xbt_swag_hookup_t return_hookup;

-  xbt_swag_t state_set;

   e_SD_task_state_t state;
   void *data;                   /* user data */
   char *name;
   e_SD_task_state_t state;
   void *data;                   /* user data */
   char *name;


@@ -125,7 +117,7 @@ XBT_PRIVATE SD_workstation_t __SD_workstation_create(const char* name);
 XBT_PRIVATE void __SD_workstation_destroy(void *workstation);
 XBT_PRIVATE int __SD_workstation_is_busy(SD_workstation_t workstation);
 
 XBT_PRIVATE void __SD_workstation_destroy(void *workstation);
 XBT_PRIVATE int __SD_workstation_is_busy(SD_workstation_t workstation);
 

-XBT_PRIVATE void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state);
+XBT_PRIVATE void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state);

 XBT_PRIVATE void __SD_task_really_run(SD_task_t task);
 XBT_PRIVATE void __SD_task_just_done(SD_task_t task);
 XBT_PRIVATE int __SD_task_try_to_run(SD_task_t task);
 XBT_PRIVATE void __SD_task_really_run(SD_task_t task);
 XBT_PRIVATE void __SD_task_just_done(SD_task_t task);
 XBT_PRIVATE int __SD_task_try_to_run(SD_task_t task);


@@ -141,58 +133,19 @@ XBT_PRIVATE void SD_task_free_f(void *t);
 /* Returns whether the given task is scheduled or runnable. */
 static XBT_INLINE int __SD_task_is_scheduled_or_runnable(SD_task_t task)
 {
 /* Returns whether the given task is scheduled or runnable. */
 static XBT_INLINE int __SD_task_is_scheduled_or_runnable(SD_task_t task)
 {

-  return task->state_set == sd_global->scheduled_task_set ||
-      task->state_set == sd_global->runnable_task_set;
+  return task->state == SD_SCHEDULED || task->state == SD_RUNNABLE;

 }
 
 /* Returns whether the given task is scheduled or runnable. */
 static XBT_INLINE int __SD_task_is_schedulable_or_done(SD_task_t task)
 {
 }
 
 /* Returns whether the given task is scheduled or runnable. */
 static XBT_INLINE int __SD_task_is_schedulable_or_done(SD_task_t task)
 {

-  return task->state_set == sd_global->schedulable_task_set ||
-      task->state_set == sd_global->done_task_set;
-}
-
-/* Returns whether the state of the given task is SD_NOT_SCHEDULED. */
-static XBT_INLINE int __SD_task_is_not_scheduled(SD_task_t task)
-{
-  return task->state_set == sd_global->not_scheduled_task_set;
-}
-
-/* Returns whether the state of the given task is SD_SCHEDULED. */
-static XBT_INLINE int __SD_task_is_schedulable(SD_task_t task)
-{
-  return task->state_set == sd_global->schedulable_task_set;
-}
-
-/* Returns whether the state of the given task is SD_SCHEDULED. */
-static XBT_INLINE int __SD_task_is_scheduled(SD_task_t task)
-{
-  return task->state_set == sd_global->scheduled_task_set;
-}
-
-/* Returns whether the state of the given task is SD_RUNNABLE. */
-static XBT_INLINE int __SD_task_is_runnable(SD_task_t task)
-{
-  return task->state_set == sd_global->runnable_task_set;
-}
-
-/* Returns whether the state of the given task is SD_IN_FIFO. */
-static XBT_INLINE int __SD_task_is_in_fifo(SD_task_t task)
-{
-  return task->state_set == sd_global->in_fifo_task_set;
+  return task->state == SD_SCHEDULABLE || task->state == SD_DONE;

 }
 
 /* Returns whether the state of the given task is SD_RUNNABLE or SD_IN_FIFO. */
 static XBT_INLINE int __SD_task_is_runnable_or_in_fifo(SD_task_t task)
 {
 }
 
 /* Returns whether the state of the given task is SD_RUNNABLE or SD_IN_FIFO. */
 static XBT_INLINE int __SD_task_is_runnable_or_in_fifo(SD_task_t task)
 {

-  return task->state_set == sd_global->runnable_task_set ||
-      task->state_set == sd_global->in_fifo_task_set;
-}
-
-/* Returns whether the state of the given task is SD_RUNNING. */
-static XBT_INLINE int __SD_task_is_running(SD_task_t task)
-{
-  return task->state_set == sd_global->running_task_set;
+  return task->state == SD_RUNNABLE || task->state == SD_IN_FIFO;

 }
 
 /********** Storage **********/
 }
 
 /********** Storage **********/

diff --git a/teshsuite/simdag/incomplete/incomplete.tesh b/teshsuite/simdag/incomplete/incomplete.tesh
index e98ada5..4ecdc50 100644 (file)
--- a/teshsuite/simdag/incomplete/incomplete.tesh
+++ b/teshsuite/simdag/incomplete/incomplete.tesh
@@ -1,7 +1,7 @@
 $ ${bindir:=.}/incomplete ../../../examples/platforms/two_hosts_platform_shared.xml "--log=root.fmt:[%10.6r]%e%m%n"
 > [  0.000000] Switching to the L07 model to handle parallel tasks.
 > [  8.000100] Simulation is finished but 3 tasks are still not done
 $ ${bindir:=.}/incomplete ../../../examples/platforms/two_hosts_platform_shared.xml "--log=root.fmt:[%10.6r]%e%m%n"
 > [  0.000000] Switching to the L07 model to handle parallel tasks.
 > [  8.000100] Simulation is finished but 3 tasks are still not done

-> [  8.000100] Task C is in SD_NOT_SCHEDULED state

 > [  8.000100] Task B is in SD_SCHEDULABLE state
 > [  8.000100] Task B is in SD_SCHEDULABLE state

+> [  8.000100] Task C is in SD_NOT_SCHEDULED state

 > [  8.000100] Task D is in SD_SCHEDULED state
 > [  8.000100] Simulation time: 8.000100
 > [  8.000100] Task D is in SD_SCHEDULED state
 > [  8.000100] Simulation time: 8.000100