X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e1aab19126287838930239f1d9dabc6ebc873f3a..20f2291e7c83e26eebe9aeb61a91b76b5aed5a64:/src/simdag/sd_task.c diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c index 3b97116428..058e3bfb25 100644 --- a/src/simdag/sd_task.c +++ b/src/simdag/sd_task.c @@ -451,6 +451,20 @@ double SD_task_get_amount(SD_task_t task) return task->amount; } +/** + * \brief Returns the alpha parameter of a SD_TASK_COMP_PAR_AMDAH task + * + * \param task a parallel task assuming Amdahl's law as speedup model + * \return the alpha parameter (serial part of a task in percent) for this task + */ +double SD_task_get_alpha(SD_task_t task) +{ + xbt_assert(SD_task_get_kind(task) == SD_TASK_COMP_PAR_AMDAHL, + "Alpha parameter is not defined for this kink of task"); + return task->alpha; +} + + /** * \brief Returns the remaining amount work to do till the completion of a task * @@ -480,16 +494,16 @@ void SD_task_dump(SD_task_t task) XBT_INFO("Displaying task %s", SD_task_get_name(task)); statename = bprintf("%s %s %s %s %s %s %s %s", - (task->state & SD_NOT_SCHEDULED ? "not scheduled" : + (task->state == SD_NOT_SCHEDULED ? "not scheduled" : ""), - (task->state & SD_SCHEDULABLE ? "schedulable" : ""), - (task->state & SD_SCHEDULED ? "scheduled" : ""), - (task->state & SD_RUNNABLE ? "runnable" : + (task->state == SD_SCHEDULABLE ? "schedulable" : ""), + (task->state == SD_SCHEDULED ? "scheduled" : ""), + (task->state == SD_RUNNABLE ? "runnable" : "not runnable"), - (task->state & SD_IN_FIFO ? "in fifo" : ""), - (task->state & SD_RUNNING ? "running" : ""), - (task->state & SD_DONE ? "done" : ""), - (task->state & SD_FAILED ? "failed" : "")); + (task->state == SD_IN_FIFO ? "in fifo" : ""), + (task->state == SD_RUNNING ? "running" : ""), + (task->state == SD_DONE ? "done" : ""), + (task->state == SD_FAILED ? "failed" : "")); XBT_INFO(" - state: %s", statename); free(statename); @@ -640,6 +654,23 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, __SD_task_set_state(dst, SD_SCHEDULED); } } +/** + * \brief Returns the name given as input when dependency has been created.. + * + * \param src a task + * \param dst a task depending on \a src + * + */ +const char *SD_task_dependency_get_name(SD_task_t src, SD_task_t dst){ + unsigned int i; + SD_dependency_t dependency; + + xbt_dynar_foreach(src->tasks_after, i, dependency){ + if (dependency->dst == dst) + return dependency->name; + } + return NULL; +} /** * \brief Indicates whether there is a dependency between two tasks. @@ -1036,7 +1067,7 @@ void __SD_task_really_run(SD_task_t task) for (i = 0; i < workstation_nb; i++) { if (SD_workstation_get_access_mode(task->workstation_list[i]) == SD_WORKSTATION_SEQUENTIAL_ACCESS) { - task->workstation_list[i]->current_task = task; + SD_workstation_priv(task->workstation_list[i])->current_task = task; xbt_assert(__SD_workstation_is_busy(task->workstation_list[i]), "The workstation should be busy now"); } @@ -1052,7 +1083,7 @@ void __SD_task_really_run(SD_task_t task) surf_workstations = xbt_new(void *, workstation_nb); for (i = 0; i < workstation_nb; i++) - surf_workstations[i] = task->workstation_list[i]->surf_workstation; + surf_workstations[i] = task->workstation_list[i]; double *computation_amount = xbt_new0(double, workstation_nb); double *communication_amount = xbt_new0(double, workstation_nb * workstation_nb); @@ -1118,11 +1149,11 @@ int __SD_task_try_to_run(SD_task_t task) 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) { + if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) { XBT_DEBUG("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); + xbt_fifo_push(SD_workstation_priv(workstation)->task_fifo, task); } } __SD_task_set_state(task, SD_IN_FIFO); @@ -1172,23 +1203,23 @@ void __SD_task_just_done(SD_task_t task) for (i = 0; i < task->workstation_nb; i++) { workstation = task->workstation_list[i]; XBT_DEBUG("Workstation '%s': access_mode = %d", - SD_workstation_get_name(workstation), (int)workstation->access_mode); - if (workstation->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) { - xbt_assert(workstation->task_fifo != NULL, + SD_workstation_get_name(workstation), (int)SD_workstation_priv(workstation)->access_mode); + if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) { + xbt_assert(SD_workstation_priv(workstation)->task_fifo != NULL, "Workstation '%s' has sequential access but no FIFO!", SD_workstation_get_name(workstation)); - xbt_assert(workstation->current_task = + xbt_assert(SD_workstation_priv(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; + SD_workstation_priv(workstation)->current_task = NULL; XBT_DEBUG("Getting candidate in FIFO"); candidate = xbt_fifo_get_item_content(xbt_fifo_get_first_item - (workstation->task_fifo)); + (SD_workstation_priv(workstation)->task_fifo)); if (candidate != NULL) { XBT_DEBUG("Candidate: '%s'", SD_task_get_name(candidate)); @@ -1242,10 +1273,10 @@ void __SD_task_just_done(SD_task_t task) /* 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 + can_start = SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SHARED_ACCESS || candidate == xbt_fifo_get_item_content(xbt_fifo_get_first_item - (workstation->task_fifo)); + (SD_workstation_priv(workstation)->task_fifo)); } XBT_DEBUG("Candidate '%s' can start: %d", SD_task_get_name(candidate), @@ -1257,8 +1288,8 @@ void __SD_task_just_done(SD_task_t task) 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 */ + if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) { + candidate = xbt_fifo_shift(SD_workstation_priv(workstation)->task_fifo); /* the return value is stored just for debugging */ XBT_DEBUG("Head of the FIFO: '%s'", (candidate != NULL) ? SD_task_get_name(candidate) : "NULL"); @@ -1355,9 +1386,10 @@ void SD_task_distribute_comp_amdhal(SD_task_t task, int ws_count) "Task %s is not a SD_TASK_COMP_PAR_AMDAHL typed task." "Cannot use this function.", SD_task_get_name(task)); - task->computation_amount = xbt_new0(double, ws_count); task->communication_amount = xbt_new0(double, ws_count * ws_count); + if (task->workstation_list) + xbt_free(task->workstation_list); task->workstation_nb = ws_count; task->workstation_list = xbt_new0(SD_workstation_t, ws_count); @@ -1507,6 +1539,10 @@ void SD_task_schedulev(SD_task_t task, int count, task->workstation_list[i]; before->workstation_nb += count; + if (before->computation_amount) + xbt_free(before->computation_amount); + if (before->communication_amount) + xbt_free(before->communication_amount); before->computation_amount = xbt_new0(double, before->workstation_nb); @@ -1572,6 +1608,11 @@ void SD_task_schedulev(SD_task_t task, int count, after->workstation_nb += count; + if (after->computation_amount) + xbt_free(after->computation_amount); + if (after->communication_amount) + xbt_free(after->communication_amount); + after->computation_amount = xbt_new0(double, after->workstation_nb); after->communication_amount = xbt_new0(double, after->workstation_nb*