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)

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

diff --git a/ChangeLog b/ChangeLog
index f44f226..af6817f 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -11,6 +11,10 @@ SimGrid (3.5) unstable; urgency=low
  * Change the return type of SD_Simulate from (SD_task_t*) into
    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) 
  
  XBT
  * New data container: setset (set of sets of elements)

diff --git a/include/simdag/datatypes.h b/include/simdag/datatypes.h
index 5a9c6a2..fa06e97 100644 (file)
--- a/include/simdag/datatypes.h
+++ b/include/simdag/datatypes.h
@@ -66,12 +66,12 @@ typedef struct SD_task *SD_task_t;
 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_READY. */
-  SD_READY = 0x0002,         /**< @brief A scheduled task becomes ready is SD_simulate as soon as its dependencies are satisfied. */
-  SD_IN_FIFO = 0x0004,       /**< @brief A ready task can have to wait in a workstation fifo if the workstation is sequential */
-  SD_RUNNING = 0x0008,       /**< @brief An SD_READY or SD_IN_FIFO becomes SD_RUNNING when it is launched. */
-  SD_DONE = 0x0010,          /**< @brief The task is successfuly finished. */
-  SD_FAILED = 0x0020         /**< @brief A problem occured during the execution of the task. */
+                               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. */
 } e_SD_task_state_t;
 
 /** @brief Task kinds

diff --git a/src/simdag/private.h b/src/simdag/private.h
index 0d5223e..80b6b70 100644 (file)
--- a/src/simdag/private.h
+++ b/src/simdag/private.h
@@ -37,7 +37,7 @@ typedef struct SD_global {
   /* task state sets */
   xbt_swag_t not_scheduled_task_set;
   xbt_swag_t scheduled_task_set;
-  xbt_swag_t ready_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;
@@ -122,11 +122,11 @@ void __SD_task_just_done(SD_task_t task);
 
 /* Functions to test if the task is in a given state. */
 
-/* Returns whether the given task is scheduled or ready. */
-static XBT_INLINE int __SD_task_is_scheduled_or_ready(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->ready_task_set;
+    task->state_set == sd_global->runnable_task_set;
 }
 
 /* Returns whether the state of the given task is SD_NOT_SCHEDULED. */
@@ -142,9 +142,9 @@ static XBT_INLINE int __SD_task_is_scheduled(SD_task_t task)
 }
 
 /* Returns whether the state of the given task is SD_READY. */
-static XBT_INLINE int __SD_task_is_ready(SD_task_t task)
+static XBT_INLINE int __SD_task_is_runnable(SD_task_t task)
 {
-  return task->state_set == sd_global->ready_task_set;
+  return task->state_set == sd_global->runnable_task_set;
 }
 
 /* Returns whether the state of the given task is SD_IN_FIFO. */
@@ -154,9 +154,9 @@ static XBT_INLINE int __SD_task_is_in_fifo(SD_task_t task)
 }
 
 /* Returns whether the state of the given task is SD_READY or SD_IN_FIFO. */
-static XBT_INLINE int __SD_task_is_ready_or_in_fifo(SD_task_t task)
+static XBT_INLINE int __SD_task_is_runnable_or_in_fifo(SD_task_t task)
 {
-  return task->state_set == sd_global->ready_task_set ||
+  return task->state_set == sd_global->runnable_task_set ||
     task->state_set == sd_global->in_fifo_task_set;
 }
 

diff --git a/src/simdag/sd_global.c b/src/simdag/sd_global.c
index b44630c..26d4a1c 100644 (file)
--- a/src/simdag/sd_global.c
+++ b/src/simdag/sd_global.c
@@ -60,7 +60,7 @@ void SD_init(int *argc, char **argv)
     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->ready_task_set =
+  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));
@@ -97,7 +97,7 @@ void SD_application_reinit(void)
     DEBUG0("Recreating the swags...");
     xbt_swag_free(sd_global->not_scheduled_task_set);
     xbt_swag_free(sd_global->scheduled_task_set);
-    xbt_swag_free(sd_global->ready_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);
@@ -107,7 +107,7 @@ void SD_application_reinit(void)
       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->ready_task_set =
+    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));
@@ -175,7 +175,7 @@ void SD_create_environment(const char *platform_file)
 /**
  * \brief Launches the simulation.
  *
- * The function will execute the \ref SD_READY ready tasks.
+ * The function will execute the \ref SD_RUNNABLE runnable tasks.
  * The simulation will be stopped when its time reaches \a how_long,
  * when a watch point is reached, or when no more task can be executed.
  * Then you can call SD_simulate() again.
@@ -210,8 +210,8 @@ xbt_dynar_t SD_simulate(double how_long)
   }
   sd_global->watch_point_reached = 0;
 
-  /* explore the ready tasks */
-  xbt_swag_foreach_safe(task, task_safe, sd_global->ready_task_set) {
+  /* explore the runnable tasks */
+  xbt_swag_foreach_safe(task, task_safe, sd_global->runnable_task_set) {
     VERB1("Executing task '%s'", SD_task_get_name(task));
     if (__SD_task_try_to_run(task) && !xbt_dynar_member(changed_tasks, &task))
       xbt_dynar_push(changed_tasks, &task);
@@ -258,10 +258,10 @@ xbt_dynar_t SD_simulate(double how_long)
                  dst->unsatisfied_dependencies--;
 
           if (!(dst->unsatisfied_dependencies) && __SD_task_is_scheduled(dst))
-                 __SD_task_set_state(dst, SD_READY);
+                 __SD_task_set_state(dst, SD_RUNNABLE);
 
-          /* is dst ready now? */
-          if (__SD_task_is_ready(dst) && !sd_global->watch_point_reached) {
+          /* is dst runnable now? */
+          if (__SD_task_is_runnable(dst) && !sd_global->watch_point_reached) {
             VERB1("Executing task '%s'", SD_task_get_name(dst));
             if (__SD_task_try_to_run(dst) &&
                 !xbt_dynar_member(changed_tasks, &task))
@@ -337,7 +337,7 @@ void SD_exit(void)
     DEBUG0("Destroying the swags...");
     xbt_swag_free(sd_global->not_scheduled_task_set);
     xbt_swag_free(sd_global->scheduled_task_set);
-    xbt_swag_free(sd_global->ready_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);

diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c
index edd85d0..62db688 100644 (file)
--- a/src/simdag/sd_task.c
+++ b/src/simdag/sd_task.c
@@ -101,7 +101,7 @@ void SD_task_set_data(SD_task_t task, void *data)
  *
  * \param task a task
  * \return the current \ref e_SD_task_state_t "state" of this task:
- * #SD_NOT_SCHEDULED, #SD_SCHEDULED, #SD_READY, #SD_RUNNING, #SD_DONE or #SD_FAILED
+ * #SD_NOT_SCHEDULED, #SD_SCHEDULED, #SD_RUNNABLE, #SD_RUNNING, #SD_DONE or #SD_FAILED
  * \see e_SD_task_state_t
  */
 e_SD_task_state_t SD_task_get_state(SD_task_t task)
@@ -123,8 +123,8 @@ void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
   case SD_SCHEDULED:
     task->state_set = sd_global->scheduled_task_set;
     break;
-  case SD_READY:
-    task->state_set = sd_global->ready_task_set;
+  case SD_RUNNABLE:
+    task->state_set = sd_global->runnable_task_set;
     break;
   case SD_IN_FIFO:
     task->state_set = sd_global->in_fifo_task_set;
@@ -293,7 +293,7 @@ void SD_task_dump(SD_task_t task)
   statename=bprintf("%s %s %s %s %s %s %s",
       (task->state&SD_NOT_SCHEDULED?"not scheduled":""),
       (task->state&SD_SCHEDULED?"scheduled":""),
-      (task->state&SD_READY?"ready":"not ready"),
+      (task->state&SD_RUNNABLE?"runnable":"not runnable"),
       (task->state&SD_IN_FIFO?"in fifo":""),
       (task->state&SD_RUNNING?"running":""),
       (task->state&SD_DONE?"done":""),
@@ -362,7 +362,7 @@ static void __SD_task_dependency_destroy(void *dependency)
  * \brief Adds a dependency between two tasks
  *
  * \a dst will depend on \a src, ie \a dst will not start before \a src is finished.
- * Their \ref e_SD_task_state_t "state" must be #SD_NOT_SCHEDULED, #SD_SCHEDULED or #SD_READY.
+ * Their \ref e_SD_task_state_t "state" must be #SD_NOT_SCHEDULED, #SD_SCHEDULED or #SD_RUNNABLE.
  *
  * \param name the name of the new dependency (can be \c NULL)
  * \param data the user data you want to associate with this dependency (can be \c NULL)
@@ -391,15 +391,15 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src,
            SD_task_get_name(src));
 
   if (!__SD_task_is_not_scheduled(src)
-      && !__SD_task_is_scheduled_or_ready(src))
+      && !__SD_task_is_scheduled_or_runnable(src))
     THROW1(arg_error, 0,
-           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULED or SD_READY",
+           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULED or SD_RUNNABLE",
            SD_task_get_name(src));
 
   if (!__SD_task_is_not_scheduled(dst)
-      && !__SD_task_is_scheduled_or_ready(dst))
+      && !__SD_task_is_scheduled_or_runnable(dst))
     THROW1(arg_error, 0,
-           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULED or SD_READY",
+           "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULED or SD_RUNNABLE",
            SD_task_get_name(dst));
 
   DEBUG2("SD_task_dependency_add: src = %s, dst = %s", SD_task_get_name(src),
@@ -429,10 +429,10 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src,
 
   dst->unsatisfied_dependencies++;
 
-  /* if the task was ready, then dst->tasks_before is not empty anymore,
+  /* 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_ready(dst)) {
-    DEBUG1("SD_task_dependency_add: %s was ready and becomes scheduled!",
+  if (__SD_task_is_runnable(dst)) {
+    DEBUG1("SD_task_dependency_add: %s was runnable and becomes scheduled!",
            SD_task_get_name(dst));
     __SD_task_set_state(dst, SD_SCHEDULED);
   }
@@ -529,10 +529,10 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst)
               SD_task_get_name(dst), SD_task_get_name(src),
               SD_task_get_name(src), SD_task_get_name(dst));
 
-  /* if the task was scheduled and dst->tasks_before is empty now, we can make it ready */
+  /* 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_READY);
+    __SD_task_set_state(dst, SD_RUNNABLE);
 
   /*  __SD_print_dependencies(src);
      __SD_print_dependencies(dst); */
@@ -576,9 +576,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_SCHEDULED, SD_RUNNING, SD_READY, SD_DONE, SD_FAILED };
+    { SD_SCHEDULED, SD_RUNNING, SD_RUNNABLE, SD_DONE, SD_FAILED };
   static const char *state_names[] =
-    { "scheduled", "running", "ready", "done", "failed" };
+    { "scheduled", "running", "runnable", "done", "failed" };
   int i;
 
   INFO2("Task '%s' watch points (%x): ", SD_task_get_name(task),
@@ -693,7 +693,7 @@ static XBT_INLINE void SD_task_do_schedule(SD_task_t task) {
 
  /* update the task state */
   if (task->unsatisfied_dependencies == 0)
-    __SD_task_set_state(task, SD_READY);
+    __SD_task_set_state(task, SD_RUNNABLE);
   else
     __SD_task_set_state(task, SD_SCHEDULED);
 }
@@ -752,7 +752,7 @@ void SD_task_schedule(SD_task_t task, int workstation_count,
 /**
  * \brief Unschedules a task
  *
- * The task state must be #SD_SCHEDULED, #SD_READY, #SD_RUNNING or #SD_FAILED.
+ * The task state must be #SD_SCHEDULED, #SD_RUNNABLE, #SD_RUNNING or #SD_FAILED.
  * If you call this function, the task state becomes #SD_NOT_SCHEDULED.
  * Call SD_task_schedule() to schedule it again.
  *
@@ -765,14 +765,14 @@ void SD_task_unschedule(SD_task_t task)
   xbt_assert0(task != NULL, "Invalid parameter");
 
   if (task->state_set != sd_global->scheduled_task_set &&
-      task->state_set != sd_global->ready_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)
     THROW1(arg_error, 0,
-           "Task %s: the state must be SD_SCHEDULED, SD_READY, SD_RUNNING or SD_FAILED",
+           "Task %s: the state must be SD_SCHEDULED, SD_RUNNABLE, SD_RUNNING or SD_FAILED",
            SD_task_get_name(task));
 
-  if (__SD_task_is_scheduled_or_ready(task) /* if the task is scheduled or ready */
+  if (__SD_task_is_scheduled_or_runnable(task) /* if the task is scheduled or runnable */
       && task->kind == SD_TASK_NOT_TYPED) /* Don't free scheduling data for typed tasks */
     __SD_task_destroy_scheduling_data(task);
 
@@ -784,14 +784,14 @@ void SD_task_unschedule(SD_task_t task)
   task->start_time = -1.0;
 }
 
-/* Destroys the data memorised by SD_task_schedule. Task state must be SD_SCHEDULED or SD_READY.
+/* Destroys the data memorised by SD_task_schedule. Task state must be SD_SCHEDULED or SD_RUNNABLE.
  */
 static void __SD_task_destroy_scheduling_data(SD_task_t task)
 {
   SD_CHECK_INIT_DONE();
-  if (!__SD_task_is_scheduled_or_ready(task) && !__SD_task_is_in_fifo(task))
+  if (!__SD_task_is_scheduled_or_runnable(task) && !__SD_task_is_in_fifo(task))
     THROW1(arg_error, 0,
-           "Task '%s' must be SD_SCHEDULED, SD_READY or SD_IN_FIFO",
+           "Task '%s' must be SD_SCHEDULED, SD_RUNNABLE or SD_IN_FIFO",
            SD_task_get_name(task));
 
   xbt_free(task->computation_amount);
@@ -811,8 +811,8 @@ void __SD_task_really_run(SD_task_t task)
 
   SD_CHECK_INIT_DONE();
   xbt_assert0(task != NULL, "Invalid parameter");
-  xbt_assert2(__SD_task_is_ready_or_in_fifo(task),
-              "Task '%s' is not ready or in a fifo! Task state: %d",
+  xbt_assert2(__SD_task_is_runnable_or_in_fifo(task),
+              "Task '%s' is not runnable or in a fifo! Task state: %d",
               SD_task_get_name(task), SD_task_get_state(task));
   xbt_assert1(task->workstation_list != NULL,
               "Task '%s': workstation_list is NULL!", SD_task_get_name(task));
@@ -909,7 +909,7 @@ void __SD_task_really_run(SD_task_t task)
 
 }
 
-/* Tries to run a task. This function is called by SD_simulate() when a scheduled task becomes SD_READY
+/* Tries to run a task. This function is called by SD_simulate() when a scheduled task becomes SD_RUNNABLE
  * (ie when its dependencies are satisfied).
  * If one of the workstations where the task is scheduled on is busy (in sequential mode),
  * the task doesn't start.
@@ -924,8 +924,8 @@ int __SD_task_try_to_run(SD_task_t task)
 
   SD_CHECK_INIT_DONE();
   xbt_assert0(task != NULL, "Invalid parameter");
-  xbt_assert2(__SD_task_is_ready(task),
-              "Task '%s' is not ready! Task state: %d",
+  xbt_assert2(__SD_task_is_runnable(task),
+              "Task '%s' is not runnable! Task state: %d",
               SD_task_get_name(task), SD_task_get_state(task));
 
 
@@ -1180,8 +1180,8 @@ void SD_task_destroy(SD_task_t task)
   DEBUG1("Destroying task %s...", SD_task_get_name(task));
 
   __SD_task_remove_dependencies(task);
-  /* if the task was scheduled or ready we have to free the scheduling parameters */
-  if (__SD_task_is_scheduled_or_ready(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);
   xbt_swag_remove(task,task->state_set);
 
@@ -1294,7 +1294,7 @@ void SD_task_schedulev(SD_task_t task, int count, const SD_workstation_t*list) {
         task->communication_amount[2]);
 
   }
-  /* Iterate over all childs and parent being COMM_E2E to say where I am located (and start them if ready) */
+  /* Iterate over all childs and parent being COMM_E2E to say where I am located (and start them if runnable) */
   if (task->kind == SD_TASK_COMP_SEQ) {
     VERB3("Schedule computation task %s on %s. It costs %.f flops",
         SD_task_get_name(task),SD_workstation_get_name(task->workstation_list[0]),