rename SD_READY in SD_SCHEDULABLE to prevent troubles for users that

were used to use SD_READY

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

diff --git a/ChangeLog b/ChangeLog
index 0f3cfdc..0f3775e 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -12,10 +12,10 @@ 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
-   scheduled) state in SD_RUNNABLE and define a new SD_READY (all
+   scheduled) state in SD_RUNNABLE and define a new SD_SCHEDULABLE (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
+   (SD_SCHEDULABLE) used in DAG scheduling and that of "ready to be
    simulated" (SD_RUNNABLE) used by the simulation kernel.
    
  XBT

diff --git a/include/simdag/datatypes.h b/include/simdag/datatypes.h
index 5fb6867..9a3f827 100644 (file)
--- a/include/simdag/datatypes.h
+++ b/include/simdag/datatypes.h
@@ -65,7 +65,7 @@ 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). */
-  SD_READY  = 0x0001,           /**< @brief A task becomes SD_READY as soon as its dependencies are satisfied */
+  SD_SCHEDULABLE  = 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. */

diff --git a/src/simdag/private.h b/src/simdag/private.h
index ace8048..9670695 100644 (file)
--- a/src/simdag/private.h
+++ b/src/simdag/private.h
@@ -36,7 +36,7 @@ typedef struct SD_global {
 
   /* task state sets */
   xbt_swag_t not_scheduled_task_set;
-  xbt_swag_t ready_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;
@@ -137,9 +137,9 @@ static XBT_INLINE int __SD_task_is_not_scheduled(SD_task_t task)
 }
 
 /* Returns whether the state of the given task is SD_SCHEDULED. */
-static XBT_INLINE int __SD_task_is_ready(SD_task_t task)
+static XBT_INLINE int __SD_task_is_schedulable(SD_task_t task)
 {
-  return task->state_set == sd_global->ready_task_set;
+  return task->state_set == sd_global->schedulable_task_set;
 }
 
 /* Returns whether the state of the given task is SD_SCHEDULED. */
@@ -148,7 +148,7 @@ 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_READY. */
+/* 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;
@@ -160,7 +160,7 @@ static XBT_INLINE int __SD_task_is_in_fifo(SD_task_t task)
   return task->state_set == sd_global->in_fifo_task_set;
 }
 
-/* Returns whether the state of the given task is SD_READY or SD_IN_FIFO. */
+/* 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 ||

diff --git a/src/simdag/sd_daxloader.c b/src/simdag/sd_daxloader.c
index 007b233..6eee634 100644 (file)
--- a/src/simdag/sd_daxloader.c
+++ b/src/simdag/sd_daxloader.c
@@ -81,8 +81,8 @@ 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);
-  /* by design the root task is always READY */
-  __SD_task_set_state(root_task, SD_READY);
+  /* by design the root task is always 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);

diff --git a/src/simdag/sd_global.c b/src/simdag/sd_global.c
index e7d4735..4d0dcc6 100644 (file)
--- a/src/simdag/sd_global.c
+++ b/src/simdag/sd_global.c
@@ -58,7 +58,7 @@ void SD_init(int *argc, char **argv)
 
   sd_global->not_scheduled_task_set =
     xbt_swag_new(xbt_swag_offset(task, state_hookup));
-  sd_global->ready_task_set =
+  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));
@@ -98,7 +98,7 @@ void SD_application_reinit(void)
   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->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);
@@ -108,7 +108,7 @@ void SD_application_reinit(void)
 
     sd_global->not_scheduled_task_set =
       xbt_swag_new(xbt_swag_offset(task, state_hookup));
-    sd_global->ready_task_set =
+    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));
@@ -266,7 +266,7 @@ xbt_dynar_t SD_simulate(double how_long)
                  if (__SD_task_is_scheduled(dst))
                          __SD_task_set_state(dst, SD_RUNNABLE);
                  else
-                         __SD_task_set_state(dst, SD_READY);
+                         __SD_task_set_state(dst, SD_SCHEDULABLE);
           }
 
           /* is dst runnable now? */
@@ -345,7 +345,7 @@ void SD_exit(void)
 
     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->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);

diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c
index 3d342ab..d7d1d07 100644 (file)
--- a/src/simdag/sd_task.c
+++ b/src/simdag/sd_task.c
@@ -120,8 +120,8 @@ 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_READY:
-    task->state_set = sd_global->ready_task_set;
+  case SD_SCHEDULABLE:
+    task->state_set = sd_global->schedulable_task_set;
     break;
   case SD_SCHEDULED:
     task->state_set = sd_global->scheduled_task_set;
@@ -295,7 +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":""),
-      (task->state&SD_READY?"ready":""),
+      (task->state&SD_SCHEDULABLE?"schedulable":""),
       (task->state&SD_SCHEDULED?"scheduled":""),
       (task->state&SD_RUNNABLE?"runnable":"not runnable"),
       (task->state&SD_IN_FIFO?"in fifo":""),
@@ -394,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));
 
-  if (!__SD_task_is_not_scheduled(src) && !__SD_task_is_ready(src)
+  if (!__SD_task_is_not_scheduled(src) && !__SD_task_is_schedulable(src)
       && !__SD_task_is_scheduled_or_runnable(src))
     THROW1(arg_error, 0,
-           "Task '%s' must be SD_NOT_SCHEDULED, SD_READY, SD_SCHEDULED or SD_RUNNABLE",
+           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED or SD_RUNNABLE",
            SD_task_get_name(src));
 
-  if (!__SD_task_is_not_scheduled(dst) && !__SD_task_is_ready(dst)
+  if (!__SD_task_is_not_scheduled(dst) && !__SD_task_is_schedulable(dst)
       && !__SD_task_is_scheduled_or_runnable(dst))
     THROW1(arg_error, 0,
-           "Task '%s' must be SD_NOT_SCHEDULED, SD_READY, SD_SCHEDULED or SD_RUNNABLE",
+           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED or SD_RUNNABLE",
            SD_task_get_name(dst));
 
   DEBUG2("SD_task_dependency_add: src = %s, dst = %s", SD_task_get_name(src),
@@ -539,7 +539,7 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst)
           if (__SD_task_is_scheduled(dst))
                   __SD_task_set_state(dst, SD_RUNNABLE);
           else
-                  __SD_task_set_state(dst, SD_READY);
+                  __SD_task_set_state(dst, SD_SCHEDULABLE);
    }
   /*  __SD_print_dependencies(src);
      __SD_print_dependencies(dst); */
@@ -583,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[] =
-    { SD_READY, SD_SCHEDULED, SD_RUNNING, SD_RUNNABLE, SD_DONE, SD_FAILED };
+    { SD_SCHEDULABLE, SD_SCHEDULED, SD_RUNNING, SD_RUNNABLE, SD_DONE, SD_FAILED };
   static const char *state_names[] =
-    { "ready", "scheduled", "running", "runnable", "done", "failed" };
+    { "schedulable", "scheduled", "running", "runnable", "done", "failed" };
   int i;
 
   INFO2("Task '%s' watch points (%x): ", SD_task_get_name(task),
@@ -694,7 +694,7 @@ double SD_task_get_execution_time(SD_task_t task,
 static XBT_INLINE void SD_task_do_schedule(SD_task_t task) {
   SD_CHECK_INIT_DONE();
 
-   if (!__SD_task_is_not_scheduled(task) && !__SD_task_is_ready(task) )
+   if (!__SD_task_is_not_scheduled(task) && !__SD_task_is_schedulable(task) )
      THROW1(arg_error, 0, "Task '%s' has already been scheduled",
             SD_task_get_name(task));
 
@@ -787,7 +787,7 @@ void SD_task_unschedule(SD_task_t task)
     surf_workstation_model->action_cancel(task->surf_action);
   else {
          if (task->unsatisfied_dependencies == 0)
-                 __SD_task_set_state(task, SD_READY);
+                 __SD_task_set_state(task, SD_SCHEDULABLE);
          else
                  __SD_task_set_state(task, SD_NOT_SCHEDULED);
   }
@@ -1315,7 +1315,7 @@ void SD_task_schedulev(SD_task_t task, int count, const SD_workstation_t*list) {
       SD_task_t before = dep->src;
       if (before->kind == SD_TASK_COMM_E2E) {
         before->workstation_list[1] = task->workstation_list[0];
-        if (before->workstation_list[0] && __SD_task_is_ready(before)) {
+        if (before->workstation_list[0] && __SD_task_is_schedulable(before)) {
           SD_task_do_schedule(before);
           VERB4("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes",
               SD_task_get_name(before),
@@ -1329,7 +1329,7 @@ void SD_task_schedulev(SD_task_t task, int count, const SD_workstation_t*list) {
       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_ready(after))) {
+                       __SD_task_is_schedulable(after))) {
           SD_task_do_schedule(after);
           VERB4("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes",
               SD_task_get_name(after),