X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e37c1e4bba9bb89cd2842f08cde998eb7f941d04..a243b4c3535f516d05259cac06963c422d4aadc0:/src/simdag/sd_task.c diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c index 52c078ec67..ea42489323 100644 --- a/src/simdag/sd_task.c +++ b/src/simdag/sd_task.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2006 - 2013. The SimGrid Team. +/* Copyright (c) 2006-2013. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -172,8 +172,8 @@ return res; * mandatory power. * * A parallel computation can be scheduled on any number of host. - * The underlying speedup model is Amdahl's law. - * To be auto-scheduled, \see SD_task_distribute_comp_amdhal has to be called + * The underlying speedup model is Amdahl's law. + * To be auto-scheduled, \see SD_task_distribute_comp_amdahl has to be called * first. * \param name the name of the task (can be \c NULL) * \param data the user data you want to associate with the task (can be \c NULL) @@ -257,7 +257,7 @@ void SD_task_destroy(SD_task_t task) xbt_free(task->name); if (task->surf_action != NULL) - surf_workstation_model->action_unref(task->surf_action); + surf_action_unref(task->surf_action); xbt_free(task->workstation_list); xbt_free(task->communication_amount); @@ -358,13 +358,11 @@ void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state) break; case SD_RUNNING: task->state_set = sd_global->running_task_set; - task->start_time = - surf_workstation_model->action_get_start_time(task->surf_action); + task->start_time = surf_action_get_start_time(task->surf_action); break; case SD_DONE: task->state_set = sd_global->done_task_set; - task->finish_time = - surf_workstation_model->action_get_finish_time(task->surf_action); + task->finish_time = surf_action_get_finish_time(task->surf_action); task->remains = 0; #ifdef HAVE_JEDULE jedule_log_sd_event(task); @@ -476,7 +474,27 @@ double SD_task_get_amount(SD_task_t task) } /** - * \brief Returns the alpha parameter of a SD_TASK_COMP_PAR_AMDAH task + * \brief Sets the total amount of work of a task + * For sequential typed tasks (COMP_SEQ and COMM_E2E), it also sets the + * appropriate values in the computation_amount and communication_amount arrays + * respectively. Nothing more than modifying task->amount is done for paralle + * typed tasks (COMP_PAR_AMDAHL and COMM_PAR_MXN_1D_BLOCK) as the distribution + * of the amount of work is done at scheduling time. + * + * \param task a task + * \param amount the new amount of work to execute + */ +void SD_task_set_amount(SD_task_t task, double amount) +{ + task->amount = amount; + if (task->kind == SD_TASK_COMP_SEQ) + task->computation_amount[0] = amount; + if (task->kind == SD_TASK_COMM_E2E) + task->communication_amount[2] = amount; +} + +/** + * \brief Returns the alpha parameter of a SD_TASK_COMP_PAR_AMDAHL 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 @@ -499,7 +517,7 @@ double SD_task_get_alpha(SD_task_t task) double SD_task_get_remaining_amount(SD_task_t task) { if (task->surf_action) - return surf_workstation_model->get_remains(task->surf_action); + return surf_action_get_remains(task->surf_action); else return task->remains; } @@ -1041,12 +1059,13 @@ void SD_task_unschedule(SD_task_t task) && ((task->kind == SD_TASK_COMP_PAR_AMDAHL) || (task->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK))) { /* Don't free scheduling data for typed tasks */ __SD_task_destroy_scheduling_data(task); + xbt_free(task->workstation_list); task->workstation_list=NULL; task->workstation_nb = 0; } if (__SD_task_is_running(task)) /* the task should become SD_FAILED */ - surf_workstation_model->action_cancel(task->surf_action); + surf_action_cancel(task->surf_action); else { if (task->unsatisfied_dependencies == 0) __SD_task_set_state(task, SD_SCHEDULABLE); @@ -1113,7 +1132,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_workstations[i] = surf_workstation_resource_priv(task->workstation_list[i]); double *computation_amount = xbt_new0(double, workstation_nb); double *communication_amount = xbt_new0(double, workstation_nb * workstation_nb); @@ -1126,15 +1145,14 @@ void __SD_task_really_run(SD_task_t task) memcpy(communication_amount, task->communication_amount, sizeof(double) * workstation_nb * workstation_nb); - task->surf_action = - surf_workstation_model->extension. - workstation.execute_parallel_task(workstation_nb, - surf_workstations, - computation_amount, - communication_amount, - task->rate); + task->surf_action = surf_workstation_model_execute_parallel_task((surf_workstation_model_t)surf_workstation_model, + workstation_nb, + surf_workstations, + computation_amount, + communication_amount, + task->rate); - surf_workstation_model->action_data_set(task->surf_action, task); + surf_action_set_data(task->surf_action, task); XBT_DEBUG("surf_action = %p", task->surf_action); @@ -1223,7 +1241,7 @@ void __SD_task_just_done(SD_task_t task) candidates = xbt_new(SD_task_t, 8); __SD_task_set_state(task, SD_DONE); - surf_workstation_model->action_unref(task->surf_action); + surf_action_unref(task->surf_action); task->surf_action = NULL; XBT_DEBUG("Looking for candidates"); @@ -1381,8 +1399,7 @@ static void __SD_task_remove_dependencies(SD_task_t task) double SD_task_get_start_time(SD_task_t task) { if (task->surf_action) - return surf_workstation_model-> - action_get_start_time(task->surf_action); + return surf_action_get_start_time(task->surf_action); else return task->start_time; } @@ -1401,15 +1418,14 @@ double SD_task_get_start_time(SD_task_t task) double SD_task_get_finish_time(SD_task_t task) { if (task->surf_action) /* should never happen as actions are destroyed right after their completion */ - return surf_workstation_model-> - action_get_finish_time(task->surf_action); + return surf_action_get_finish_time(task->surf_action); else return task->finish_time; } /** @brief Blah * */ -void SD_task_distribute_comp_amdhal(SD_task_t task, int ws_count) +void SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count) { int i; xbt_assert(task->kind == SD_TASK_COMP_PAR_AMDAHL, @@ -1418,8 +1434,7 @@ void SD_task_distribute_comp_amdhal(SD_task_t task, int ws_count) 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); + xbt_free(task->workstation_list); task->workstation_nb = ws_count; task->workstation_list = xbt_new0(SD_workstation_t, ws_count); @@ -1462,7 +1477,7 @@ void SD_task_schedulev(SD_task_t task, int count, SD_task_get_name(task)); switch (task->kind) { case SD_TASK_COMP_PAR_AMDAHL: - SD_task_distribute_comp_amdhal(task, count); + SD_task_distribute_comp_amdahl(task, count); case SD_TASK_COMM_E2E: case SD_TASK_COMP_SEQ: xbt_assert(task->workstation_nb == count, @@ -1539,7 +1554,7 @@ void SD_task_schedulev(SD_task_t task, int count, * located (and start them if runnable) */ if (task->kind == SD_TASK_COMP_PAR_AMDAHL) { XBT_VERB("Schedule computation task %s on %d workstations. %.f flops" - " will be distributed following Amdahl'Law", + " will be distributed following Amdahl's Law", SD_task_get_name(task), task->workstation_nb, task->computation_amount[0]); xbt_dynar_foreach(task->tasks_before, cpt, dep) { @@ -1569,11 +1584,8 @@ 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); - + xbt_free(before->computation_amount); + xbt_free(before->communication_amount); before->computation_amount = xbt_new0(double, before->workstation_nb); before->communication_amount = xbt_new0(double, @@ -1638,10 +1650,8 @@ 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); + xbt_free(after->computation_amount); + xbt_free(after->communication_amount); after->computation_amount = xbt_new0(double, after->workstation_nb); after->communication_amount = xbt_new0(double,