X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/153998edbf873ca1ec4aeded8748f9e5465bf00e..178d9ca3560ec4b1e756970b888b4e36212ce670:/src/simdag/sd_task.c diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c index 237483a671..a19bd49c79 100644 --- a/src/simdag/sd_task.c +++ b/src/simdag/sd_task.c @@ -21,7 +21,7 @@ static void __SD_task_destroy_scheduling_data(SD_task_t task); SD_task_t SD_task_create(const char *name, void *data, double amount) { SD_CHECK_INIT_DONE(); - SD_task_t task = xbt_new0(s_SD_task_t, 1); + SD_task_t task = xbt_new(s_SD_task_t, 1); /* general information */ task->data = data; /* user data */ @@ -31,6 +31,7 @@ SD_task_t SD_task_create(const char *name, void *data, double amount) { task->name = NULL; task->state_set = sd_global->not_scheduled_task_set; + task->state = SD_NOT_SCHEDULED; xbt_swag_insert(task,task->state_set); task->amount = amount; @@ -52,6 +53,8 @@ SD_task_t SD_task_create(const char *name, void *data, double amount) { task->communication_amount = NULL; task->rate = 0; + sd_global->task_number++; + return task; } @@ -95,18 +98,7 @@ void SD_task_set_data(SD_task_t task, void *data) { e_SD_task_state_t SD_task_get_state(SD_task_t task) { SD_CHECK_INIT_DONE(); xbt_assert0(task != NULL, "Invalid parameter"); - - if (task->state_set == sd_global->scheduled_task_set) - return SD_SCHEDULED; - if (task->state_set == sd_global->done_task_set) - return SD_DONE; - if (task->state_set == sd_global->running_task_set) - return SD_RUNNING; - if (task->state_set == sd_global->ready_task_set) - return SD_READY; - if (task->state_set == sd_global->not_scheduled_task_set) - return SD_NOT_SCHEDULED; - return SD_FAILED; + return task->state; } /* Changes the state of a task. Updates the swags and the flag sd_global->watch_point_reached. @@ -123,6 +115,9 @@ void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state) { case SD_READY: task->state_set = sd_global->ready_task_set; break; + case SD_IN_FIFO: + task->state_set = sd_global->in_fifo_task_set; + break; case SD_RUNNING: task->state_set = sd_global->running_task_set; task->start_time = surf_workstation_resource->common_public-> @@ -141,6 +136,7 @@ void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state) { xbt_assert0(0, "Invalid state"); } xbt_swag_insert(task, task->state_set); + task->state = new_state; if (task->watch_points & new_state) { INFO1("Watch point reached with task '%s'!", SD_task_get_name(task)); @@ -265,7 +261,7 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task THROW2(arg_error, 0, "A dependency already exists between task '%s' and task '%s'", SD_task_get_name(src), SD_task_get_name(dst)); - dependency = xbt_new0(s_SD_dependency_t, 1); + dependency = xbt_new(s_SD_dependency_t, 1); if (name != NULL) dependency->name = xbt_strdup(name); @@ -496,19 +492,15 @@ void SD_task_schedule(SD_task_t task, int workstation_nb, task->workstation_nb = workstation_nb; task->rate = rate; - task->computation_amount = xbt_new0(double, workstation_nb); + task->computation_amount = xbt_new(double, workstation_nb); memcpy(task->computation_amount, computation_amount, sizeof(double) * workstation_nb); int communication_nb = workstation_nb * workstation_nb; - task->communication_amount = xbt_new0(double, communication_nb); + task->communication_amount = xbt_new(double, communication_nb); memcpy(task->communication_amount, communication_amount, sizeof(double) * communication_nb); - /* we have to create a Surf workstation array instead of the SimDag workstation array */ - task->workstation_list = xbt_new0(void*, workstation_nb); - int i; - for (i = 0; i < workstation_nb; i++) { - task->workstation_list[i] = workstation_list[i]->surf_workstation; - } + task->workstation_list = xbt_new(SD_workstation_t, workstation_nb); + memcpy(task->workstation_list, workstation_list, sizeof(SD_workstation_t) * workstation_nb); /* update the task state */ if (xbt_dynar_length(task->tasks_before) == 0) @@ -553,40 +545,235 @@ void SD_task_unschedule(SD_task_t task) { */ static void __SD_task_destroy_scheduling_data(SD_task_t task) { SD_CHECK_INIT_DONE(); - if (!__SD_task_is_scheduled_or_ready(task)) - THROW1(arg_error, 0, "Task '%s' must be SD_SCHEDULED or SD_READY", SD_task_get_name(task)); + if (!__SD_task_is_scheduled_or_ready(task) && !__SD_task_is_in_fifo(task)) + THROW1(arg_error, 0, "Task '%s' must be SD_SCHEDULED, SD_READY or SD_IN_FIFO", SD_task_get_name(task)); - xbt_free(task->workstation_list); xbt_free(task->computation_amount); xbt_free(task->communication_amount); } -/* Runs a task. This function is called by SD_simulate() when a scheduled task can start - * (ie when its dependencies are satisfied). +/* Runs a task. This function is directly called by __SD_task_try_to_run if the task + * doesn't have to wait in fifos. Otherwise, it is called by __SD_task_just_done when + * the task gets out of its fifos. */ -surf_action_t __SD_task_run(SD_task_t task) { +void __SD_task_really_run(SD_task_t task) { SD_CHECK_INIT_DONE(); xbt_assert0(task != NULL, "Invalid parameter"); - - if (!__SD_task_is_ready(task)) - THROW2(arg_error, 0, "Task '%s' is not ready! Task state: %d", + xbt_assert2(__SD_task_is_ready_or_in_fifo(task), "Task '%s' is not ready 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)); + + int i; + void **surf_workstations; + + DEBUG1("Really running task '%s'", SD_task_get_name(task)); + + /* set this task as current task for the workstations in sequential mode */ + for (i = 0; i < task->workstation_nb; i++) { + if (SD_workstation_get_access_mode(task->workstation_list[i]) == SD_WORKSTATION_SEQUENTIAL_ACCESS) { + task->workstation_list[i]->current_task = task; + xbt_assert0(__SD_workstation_is_busy(task->workstation_list[i]), "The workstation should be busy now"); + } + } + + DEBUG1("Task '%s' set as current task for its workstations", SD_task_get_name(task)); + /* start the task */ + + /* we have to create a Surf workstation array instead of the SimDag workstation array */ + surf_workstations = xbt_new(void*, task->workstation_nb); + + for (i = 0; i < task->workstation_nb; i++) { + surf_workstations[i] = task->workstation_list[i]->surf_workstation; + } + task->surf_action = surf_workstation_resource->extension_public-> execute_parallel_task(task->workstation_nb, - task->workstation_list, + surf_workstations, task->computation_amount, task->communication_amount, task->amount, task->rate); + surf_workstation_resource->common_public->action_set_data(task->surf_action, task); + task->state_changed = 1; DEBUG1("surf_action = %p", task->surf_action); + xbt_free(surf_workstations); __SD_task_destroy_scheduling_data(task); /* now the scheduling data are not useful anymore */ __SD_task_set_state(task, SD_RUNNING); + xbt_assert2(__SD_task_is_running(task), "Bad state of task '%s': %d", + SD_task_get_name(task), SD_task_get_state(task)); + +} + +/* Tries to run a task. This function is called by SD_simulate() when a scheduled task becomes SD_READY + * (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. + * Returns whether the task has started. + */ +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", + SD_task_get_name(task), SD_task_get_state(task)); + + int can_start = 1; + int i; + SD_workstation_t workstation; + + for (i = 0; i < task->workstation_nb; i++) { + can_start = !__SD_workstation_is_busy(task->workstation_list[i]); + } + + DEBUG2("Task '%s' can start: %d", SD_task_get_name(task), can_start); + + if (!can_start) { /* if the task cannot start and is not in the fifos yet*/ + for (i = 0; i < task->workstation_nb; i++) { + workstation = task->workstation_list[i]; + if (workstation->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) { + DEBUG2("Pushing task '%s' in the fifo of workstation '%s'", SD_task_get_name(task), + SD_workstation_get_name(workstation)); + xbt_fifo_push(workstation->task_fifo, task); + } + } + __SD_task_set_state(task, SD_IN_FIFO); + xbt_assert2(__SD_task_is_in_fifo(task), "Bad state of task '%s': %d", + SD_task_get_name(task), SD_task_get_state(task)); + DEBUG1("Task '%s' state is now SD_IN_FIFO", SD_task_get_name(task)); + } + else { + __SD_task_really_run(task); + } + + return can_start; +} + +/* This function is called by SD_simulate when a task is done. + * It updates task->state and task->action and executes if necessary the tasks + * which were waiting in fifos for the end of `task' + */ +void __SD_task_just_done(SD_task_t task) { + SD_CHECK_INIT_DONE(); + xbt_assert0(task != NULL, "Invalid parameter"); + xbt_assert1(__SD_task_is_running(task), "The task must be running! Task state: %d", SD_task_get_state(task)); + xbt_assert1(task->workstation_list != NULL, "Task '%s': workstation_list is NULL!", SD_task_get_name(task)); + + int i, j; + SD_workstation_t workstation; + + SD_task_t candidate; + int candidate_nb = 0; + int candidate_capacity = 8; + SD_task_t *candidates = xbt_new(SD_task_t, 8); + int can_start = 1; + + __SD_task_set_state(task, SD_DONE); + surf_workstation_resource->common_public->action_free(task->surf_action); + task->surf_action = NULL; + + DEBUG0("Looking for candidates"); + + /* if the task was executed on sequential workstations, + maybe we can execute the next task of the fifo for each workstation */ + for (i = 0; i < task->workstation_nb; i++) { + workstation = task->workstation_list[i]; + DEBUG2("Workstation '%s': access_mode = %d", SD_workstation_get_name(workstation), workstation->access_mode); + if (workstation->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) { + xbt_assert1(workstation->task_fifo != NULL, "Workstation '%s' has sequential access but no fifo!", + SD_workstation_get_name(workstation)); + xbt_assert2(workstation->current_task = task, "Workstation '%s': current task should be '%s'", + SD_workstation_get_name(workstation), SD_task_get_name(task)); + + /* the task is over so we can release the workstation */ + workstation->current_task = NULL; + + DEBUG0("Getting candidate in fifo"); + candidate = xbt_fifo_get_item_content(xbt_fifo_get_first_item(workstation->task_fifo)); + + if (candidate != NULL) { + DEBUG1("Candidate: '%s'", SD_task_get_name(candidate)); + xbt_assert2(__SD_task_is_in_fifo(candidate), "Bad state of candidate '%s': %d", + SD_task_get_name(candidate), SD_task_get_state(candidate)); + } + + DEBUG1("Candidate in fifo: %p", candidate); + + /* if there was a task waiting for my place */ + if (candidate != NULL) { + /* Unfortunately, we are not sure yet that we can execute the task now, + because the task can be waiting more deeply in some other workstation's fifos... + So we memorize all candidate tasks, and then we will check for each candidate + whether or not all its workstations are available. */ + + /* realloc if necessary */ + if (candidate_nb == candidate_capacity) { + candidate_capacity *= 2; + candidates = xbt_realloc(candidates, sizeof(SD_task_t) * candidate_capacity); + } + + /* register the candidate */ + candidates[candidate_nb++] = candidate; + candidate->fifo_checked = 0; + } + } + } + + DEBUG1("Candidates found: %d", candidate_nb); + + /* now we check every candidate task */ + for (i = 0; i < candidate_nb; i++) { + candidate = candidates[i]; + + if (candidate->fifo_checked) { + continue; /* we have already evaluated that task*/ + } - return task->surf_action; + xbt_assert2(__SD_task_is_in_fifo(candidate), "Bad state of candidate '%s': %d", + SD_task_get_name(candidate), SD_task_get_state(candidate)); + + for (j = 0; j < candidate->workstation_nb && can_start; j++) { + workstation = candidate->workstation_list[j]; + + /* I can start on this workstation if the workstation is shared + or if I am the first task in the fifo */ + can_start = workstation->access_mode == SD_WORKSTATION_SHARED_ACCESS || + candidate == xbt_fifo_get_item_content(xbt_fifo_get_first_item(workstation->task_fifo)); + } + + DEBUG2("Candidate '%s' can start: %d", SD_task_get_name(candidate), can_start); + + /* now we are sure that I can start! */ + if (can_start) { + for (j = 0; j < candidate->workstation_nb && can_start; j++) { + workstation = candidate->workstation_list[j]; + + /* update the fifo */ + if (workstation->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) { + candidate = xbt_fifo_shift(workstation->task_fifo); /* the return value is stored just for debugging */ + DEBUG1("Head of the fifo: '%s'", (candidate != NULL) ? SD_task_get_name(candidate) : "NULL"); + xbt_assert0(candidate == candidates[i], "Error in __SD_task_just_done: bad first task in the fifo"); + } + } /* for each workstation */ + + /* finally execute the task */ + DEBUG2("Task '%s' state: %d", SD_task_get_name(candidate), SD_task_get_state(candidate)); + __SD_task_really_run(candidate); + + DEBUG4("Calling __SD_task_is_running: task '%s', state set: %p, running_task_set: %p, is running: %d", + SD_task_get_name(candidate), candidate->state_set, sd_global->running_task_set, __SD_task_is_running(candidate)); + xbt_assert2(__SD_task_is_running(candidate), "Bad state of task '%s': %d", + SD_task_get_name(candidate), SD_task_get_state(candidate)); + DEBUG0("Okay, the task is running."); + + } /* can start */ + candidate->fifo_checked = 1; + } /* for each candidate */ + + xbt_free(candidates); } + /* Remove all dependencies associated with a task. This function is called when the task is destroyed. */ static void __SD_task_remove_dependencies(SD_task_t task) { @@ -668,9 +855,14 @@ void SD_task_destroy(SD_task_t task) { if (task->surf_action != NULL) surf_workstation_resource->common_public->action_free(task->surf_action); + if (task->workstation_list != NULL) + xbt_free(task->workstation_list); + xbt_dynar_free(&task->tasks_before); xbt_dynar_free(&task->tasks_after); xbt_free(task); + sd_global->task_number--; + DEBUG0("Task destroyed."); }