Reintroduce a SD_READY state, which now means "ready" in a scheduling

sense, i.e., all dependencies are satisfied.

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@7852 48e7efb5-ca39-0410-a469-dd3cf9ba447f

diff --git a/ChangeLog b/ChangeLog
index af6817f..0f3cfdc 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -12,10 +12,12 @@ SimGrid (3.5) unstable; urgency=low
    xbt_dynar_t. This function was in handling a dynar internally and
    converted it into a NULL terminated array for historical reasons.
  * Rename the SD_READY (all dependencies are satisfied and task is
    xbt_dynar_t. This function was in handling a dynar internally and
    converted it into a NULL terminated array for historical reasons.
  * Rename the SD_READY (all dependencies are satisfied and task is

-   scheduled) state in SD_RUNNABLE. This prevents a confusion with
-   the notion of "ready" used in DAG scheduling (all dependencies are
-   satisfied) 
- 
+   scheduled) state in SD_RUNNABLE and define a new SD_READY (all
+   dependencies are satisfied) state. 
+   This prevents a confusion between the notion of "ready to schedule"
+   (SD_READY) used in DAG scheduling and that of "ready to be
+   simulated" (SD_RUNNABLE) used by the simulation kernel.
+   

  XBT
  * New data container: setset (set of sets of elements)
  * New module: mmalloc (mapped malloc)
  XBT
  * New data container: setset (set of sets of elements)
  * New module: mmalloc (mapped malloc)

diff --git a/include/simdag/datatypes.h b/include/simdag/datatypes.h
index fa06e97..5fb6867 100644 (file)
--- a/include/simdag/datatypes.h
+++ b/include/simdag/datatypes.h
@@ -65,13 +65,14 @@ typedef struct SD_task *SD_task_t;
     @see SD_task_management */
 typedef enum {
   SD_NOT_SCHEDULED = 0,      /**< @brief Initial state (not valid for SD_watch and SD_unwatch). */
     @see SD_task_management */
 typedef enum {
   SD_NOT_SCHEDULED = 0,      /**< @brief Initial state (not valid for SD_watch and SD_unwatch). */

-  SD_SCHEDULED = 0x0001,     /**< @brief A task becomes SD_SCHEDULED when you call function
-                               SD_task_schedule. SD_simulate will execute it when it becomes SD_RUNNABLE. */
-  SD_RUNNABLE = 0x0002,      /**< @brief A scheduled task becomes runnable is SD_simulate as soon as its dependencies are satisfied. */
-  SD_IN_FIFO = 0x0004,       /**< @brief A runnable task can have to wait in a workstation fifo if the workstation is sequential */
-  SD_RUNNING = 0x0008,       /**< @brief An SD_RUNNABLE or SD_IN_FIFO becomes SD_RUNNING when it is launched. */
-  SD_DONE = 0x0010,          /**< @brief The task is successfully finished. */
-  SD_FAILED = 0x0020         /**< @brief A problem occurred during the execution of the task. */
+  SD_READY  = 0x0001,           /**< @brief A task becomes SD_READY as soon as its dependencies are satisfied */
+  SD_SCHEDULED = 0x0002,     /**< @brief A task becomes SD_SCHEDULED when you call function
+                                                                 SD_task_schedule. SD_simulate will execute it when it becomes SD_RUNNABLE. */
+  SD_RUNNABLE = 0x0004,      /**< @brief A scheduled task becomes runnable is SD_simulate as soon as its dependencies are satisfied. */
+  SD_IN_FIFO = 0x0008,       /**< @brief A runnable task can have to wait in a workstation fifo if the workstation is sequential */
+  SD_RUNNING = 0x0010,       /**< @brief An SD_RUNNABLE or SD_IN_FIFO becomes SD_RUNNING when it is launched. */
+  SD_DONE = 0x0020,          /**< @brief The task is successfully finished. */
+  SD_FAILED = 0x0040         /**< @brief A problem occurred during the execution of the task. */

 } e_SD_task_state_t;
 
 /** @brief Task kinds
 } e_SD_task_state_t;
 
 /** @brief Task kinds

diff --git a/src/simdag/private.h b/src/simdag/private.h
index 80b6b70..ace8048 100644 (file)
--- a/src/simdag/private.h
+++ b/src/simdag/private.h
@@ -36,6 +36,7 @@ typedef struct SD_global {
 
   /* task state sets */
   xbt_swag_t not_scheduled_task_set;
 
   /* task state sets */
   xbt_swag_t not_scheduled_task_set;

+  xbt_swag_t ready_task_set;

   xbt_swag_t scheduled_task_set;
   xbt_swag_t runnable_task_set;
   xbt_swag_t in_fifo_task_set;
   xbt_swag_t scheduled_task_set;
   xbt_swag_t runnable_task_set;
   xbt_swag_t in_fifo_task_set;


@@ -135,6 +136,12 @@ static XBT_INLINE int __SD_task_is_not_scheduled(SD_task_t task)
   return task->state_set == sd_global->not_scheduled_task_set;
 }
 
   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_ready(SD_task_t task)
+{
+  return task->state_set == sd_global->ready_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)
 {
 /* Returns whether the state of the given task is SD_SCHEDULED. */
 static XBT_INLINE int __SD_task_is_scheduled(SD_task_t task)
 {

diff --git a/src/simdag/sd_daxloader.c b/src/simdag/sd_daxloader.c
index 6d6c0d9..007b233 100644 (file)
--- a/src/simdag/sd_daxloader.c
+++ b/src/simdag/sd_daxloader.c
@@ -81,6 +81,9 @@ xbt_dynar_t SD_daxload(const char*filename) {
   files=xbt_dict_new();
   jobs=xbt_dict_new();
   root_task = SD_task_create_comp_seq("root",NULL,0);
   files=xbt_dict_new();
   jobs=xbt_dict_new();
   root_task = SD_task_create_comp_seq("root",NULL,0);

+  /* by design the root task is always READY */
+  __SD_task_set_state(root_task, SD_READY);
+

   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.c b/src/simdag/sd_global.c
index 26d4a1c..e7d4735 100644 (file)
--- a/src/simdag/sd_global.c
+++ b/src/simdag/sd_global.c
@@ -58,8 +58,10 @@ void SD_init(int *argc, char **argv)
 
   sd_global->not_scheduled_task_set =
     xbt_swag_new(xbt_swag_offset(task, state_hookup));
 
   sd_global->not_scheduled_task_set =
     xbt_swag_new(xbt_swag_offset(task, state_hookup));

-  sd_global->scheduled_task_set =
+  sd_global->ready_task_set =

     xbt_swag_new(xbt_swag_offset(task, state_hookup));
     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 =
   sd_global->runnable_task_set =
     xbt_swag_new(xbt_swag_offset(task, state_hookup));
   sd_global->in_fifo_task_set =


@@ -96,6 +98,7 @@ void SD_application_reinit(void)
   if (SD_INITIALISED()) {
     DEBUG0("Recreating the swags...");
     xbt_swag_free(sd_global->not_scheduled_task_set);
   if (SD_INITIALISED()) {
     DEBUG0("Recreating the swags...");
     xbt_swag_free(sd_global->not_scheduled_task_set);

+    xbt_swag_free(sd_global->ready_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->scheduled_task_set);
     xbt_swag_free(sd_global->runnable_task_set);
     xbt_swag_free(sd_global->in_fifo_task_set);


@@ -105,6 +108,8 @@ void SD_application_reinit(void)
 
     sd_global->not_scheduled_task_set =
       xbt_swag_new(xbt_swag_offset(task, state_hookup));
 
     sd_global->not_scheduled_task_set =
       xbt_swag_new(xbt_swag_offset(task, state_hookup));

+    sd_global->ready_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 =
     sd_global->scheduled_task_set =
       xbt_swag_new(xbt_swag_offset(task, state_hookup));
     sd_global->runnable_task_set =


@@ -257,8 +262,12 @@ xbt_dynar_t SD_simulate(double how_long)
           if (dst->unsatisfied_dependencies>0)
                  dst->unsatisfied_dependencies--;
 
           if (dst->unsatisfied_dependencies>0)
                  dst->unsatisfied_dependencies--;
 

-          if (!(dst->unsatisfied_dependencies) && __SD_task_is_scheduled(dst))
-                 __SD_task_set_state(dst, SD_RUNNABLE);
+          if (!(dst->unsatisfied_dependencies)){
+                 if (__SD_task_is_scheduled(dst))
+                         __SD_task_set_state(dst, SD_RUNNABLE);
+                 else
+                         __SD_task_set_state(dst, SD_READY);
+          }

 
           /* is dst runnable now? */
           if (__SD_task_is_runnable(dst) && !sd_global->watch_point_reached) {
 
           /* is dst runnable now? */
           if (__SD_task_is_runnable(dst) && !sd_global->watch_point_reached) {


@@ -336,6 +345,7 @@ void SD_exit(void)
 
     DEBUG0("Destroying the swags...");
     xbt_swag_free(sd_global->not_scheduled_task_set);
 
     DEBUG0("Destroying the swags...");
     xbt_swag_free(sd_global->not_scheduled_task_set);

+    xbt_swag_free(sd_global->ready_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->scheduled_task_set);
     xbt_swag_free(sd_global->runnable_task_set);
     xbt_swag_free(sd_global->in_fifo_task_set);

diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c
index 62db688..0736d06 100644 (file)
--- a/src/simdag/sd_task.c
+++ b/src/simdag/sd_task.c
@@ -120,6 +120,9 @@ void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
   case SD_NOT_SCHEDULED:
     task->state_set = sd_global->not_scheduled_task_set;
     break;
   case SD_NOT_SCHEDULED:
     task->state_set = sd_global->not_scheduled_task_set;
     break;

+  case SD_READY:
+    task->state_set = sd_global->ready_task_set;
+    break;

   case SD_SCHEDULED:
     task->state_set = sd_global->scheduled_task_set;
     break;
   case SD_SCHEDULED:
     task->state_set = sd_global->scheduled_task_set;
     break;


@@ -292,6 +295,7 @@ void SD_task_dump(SD_task_t task)
   INFO1("Displaying task %s",SD_task_get_name(task));
   statename=bprintf("%s %s %s %s %s %s %s",
       (task->state&SD_NOT_SCHEDULED?"not scheduled":""),
   INFO1("Displaying task %s",SD_task_get_name(task));
   statename=bprintf("%s %s %s %s %s %s %s",
       (task->state&SD_NOT_SCHEDULED?"not scheduled":""),

+      (task->state&SD_READY?"ready":""),

       (task->state&SD_SCHEDULED?"scheduled":""),
       (task->state&SD_RUNNABLE?"runnable":"not runnable"),
       (task->state&SD_IN_FIFO?"in fifo":""),
       (task->state&SD_SCHEDULED?"scheduled":""),
       (task->state&SD_RUNNABLE?"runnable":"not runnable"),
       (task->state&SD_IN_FIFO?"in fifo":""),


@@ -390,16 +394,16 @@ 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)
+  if (!__SD_task_is_not_scheduled(src) && !__SD_task_is_ready(src)

       && !__SD_task_is_scheduled_or_runnable(src))
     THROW1(arg_error, 0,
       && !__SD_task_is_scheduled_or_runnable(src))
     THROW1(arg_error, 0,

-           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULED or SD_RUNNABLE",
+           "Task '%s' must be SD_NOT_SCHEDULED, SD_READY, SD_SCHEDULED or SD_RUNNABLE",

            SD_task_get_name(src));
 
            SD_task_get_name(src));
 

-  if (!__SD_task_is_not_scheduled(dst)
+  if (!__SD_task_is_not_scheduled(dst) && !__SD_task_is_ready(dst)

       && !__SD_task_is_scheduled_or_runnable(dst))
     THROW1(arg_error, 0,
       && !__SD_task_is_scheduled_or_runnable(dst))
     THROW1(arg_error, 0,

-           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULED or SD_RUNNABLE",
+           "Task '%s' must be SD_NOT_SCHEDULED, SD_READY, SD_SCHEDULED or SD_RUNNABLE",

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


@@ -531,9 +535,12 @@ 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 the task was scheduled and dst->tasks_before is empty now, we can make it runnable */
 

-   if (dst->unsatisfied_dependencies == 0 && __SD_task_is_scheduled(dst))
-    __SD_task_set_state(dst, SD_RUNNABLE);
-
+   if (dst->unsatisfied_dependencies == 0){
+          if (__SD_task_is_scheduled(dst))
+                  __SD_task_set_state(dst, SD_RUNNABLE);
+          else
+                  __SD_task_set_state(dst, SD_READY);
+   }

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


@@ -576,9 +583,9 @@ void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst)
 static void __SD_print_watch_points(SD_task_t task)
 {
   static const int state_masks[] =
 static void __SD_print_watch_points(SD_task_t task)
 {
   static const int state_masks[] =

-    { SD_SCHEDULED, SD_RUNNING, SD_RUNNABLE, SD_DONE, SD_FAILED };
+    { SD_READY, SD_SCHEDULED, SD_RUNNING, SD_RUNNABLE, SD_DONE, SD_FAILED };

   static const char *state_names[] =
   static const char *state_names[] =

-    { "scheduled", "running", "runnable", "done", "failed" };
+    { "ready", "scheduled", "running", "runnable", "done", "failed" };

   int i;
 
   INFO2("Task '%s' watch points (%x): ", SD_task_get_name(task),
   int i;
 
   INFO2("Task '%s' watch points (%x): ", SD_task_get_name(task),


@@ -778,8 +785,12 @@ void SD_task_unschedule(SD_task_t task)
 
   if (__SD_task_is_running(task))       /* the task should become SD_FAILED */
     surf_workstation_model->action_cancel(task->surf_action);
 
   if (__SD_task_is_running(task))       /* the task should become SD_FAILED */
     surf_workstation_model->action_cancel(task->surf_action);

-  else
-    __SD_task_set_state(task, SD_NOT_SCHEDULED);
+  else {
+         if (task->unsatisfied_dependencies == 0)
+                 __SD_task_set_state(task, SD_READY);
+         else
+                 __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;
 }