From 138b84b858c3fb81578a31446ea8e1d2cabdfd31 Mon Sep 17 00:00:00 2001 From: suter Date: Tue, 15 Jun 2010 20:18:56 +0000 Subject: [PATCH] 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 --- ChangeLog | 4 ++-- include/simdag/datatypes.h | 2 +- src/simdag/private.h | 10 +++++----- src/simdag/sd_daxloader.c | 4 ++-- src/simdag/sd_global.c | 10 +++++----- src/simdag/sd_task.c | 28 ++++++++++++++-------------- 6 files changed, 29 insertions(+), 29 deletions(-) diff --git a/ChangeLog b/ChangeLog index 0f3cfdce50..0f3775ea37 100644 --- 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 5fb6867015..9a3f827598 100644 --- 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 ace80489e4..9670695fd4 100644 --- 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 007b233097..6eee634090 100644 --- 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 e7d4735526..4d0dcc6d0a 100644 --- 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 3d342ab362..d7d1d07e35 100644 --- 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), -- 2.20.1