From 24ec872003d83bec617dd6aca30aa67bddeadd61 Mon Sep 17 00:00:00 2001 From: suter Date: Mon, 14 Jun 2010 09:21:06 +0000 Subject: [PATCH 1/1] 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 --- ChangeLog | 4 +++ include/simdag/datatypes.h | 12 +++---- src/simdag/private.h | 16 +++++----- src/simdag/sd_global.c | 20 ++++++------ src/simdag/sd_task.c | 64 +++++++++++++++++++------------------- 5 files changed, 60 insertions(+), 56 deletions(-) diff --git a/ChangeLog b/ChangeLog index f44f2268c6..af6817f2c1 100644 --- 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 5a9c6a26dc..fa06e97770 100644 --- 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 0d5223ea54..80b6b709e4 100644 --- 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 b44630cf67..26d4a1ca9d 100644 --- 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 edd85d0c88..62db6880b5 100644 --- 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]), -- 2.20.1