X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6a87962ff2bd64e3c863ea894dd745647e380c93..0e9c0448c6566825b170b98ecff716b098bda10e:/src/simdag/sd_task.c diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c index 744e562da7..c098fd1f73 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) @@ -476,7 +476,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 @@ -621,9 +641,9 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst) { xbt_dynar_t dynar; - int length; + unsigned long length; int found = 0; - int i; + unsigned long i; SD_dependency_t dependency; dynar = src->tasks_after; @@ -652,7 +672,7 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, for (i = 0; i < length && !found; i++) { xbt_dynar_get_cpy(dynar, i, &dependency); found = (dependency->dst == dst); - XBT_DEBUG("Dependency %d: dependency->dst = %s", i, + XBT_DEBUG("Dependency %lu: dependency->dst = %s", i, SD_task_get_name(dependency->dst)); } @@ -746,9 +766,9 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) { xbt_dynar_t dynar; - int length; + unsigned long length; int found = 0; - int i; + unsigned long i; SD_dependency_t dependency; /* remove the dependency from src->tasks_after */ @@ -817,9 +837,9 @@ void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst) { xbt_dynar_t dynar; - int length; + unsigned long length; int found = 0; - int i; + unsigned long i; SD_dependency_t dependency; dynar = src->tasks_after; @@ -1041,6 +1061,7 @@ 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; } @@ -1409,7 +1430,7 @@ double SD_task_get_finish_time(SD_task_t task) /** @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 +1439,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 +1482,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 +1559,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 +1589,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 +1655,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,