X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e15e517a25646bf11ea186ab7287b9df8280dae3..8f5616991169add56ea7c07404728ffd9bc45097:/src/simdag/sd_task.c diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c index 71d920598c..c098fd1f73 100644 --- a/src/simdag/sd_task.c +++ b/src/simdag/sd_task.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011. 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 @@ -91,7 +91,7 @@ SD_task_t SD_task_create(const char *name, void *data, double amount) sd_global->task_number++; #ifdef HAVE_TRACING - task->category = NULL; + TRACE_sd_task_create(task); #endif return task; @@ -125,6 +125,12 @@ SD_task_t SD_task_create_comm_e2e(const char *name, void *data, SD_task_t res = SD_task_create_sized(name, data, amount, 2); res->communication_amount[2] = amount; res->kind = SD_TASK_COMM_E2E; + +#ifdef HAVE_TRACING + TRACE_category("COMM_E2E"); + TRACE_sd_set_task_category(res, "COMM_E2E"); +#endif + return res; } @@ -149,7 +155,13 @@ SD_task_t SD_task_create_comp_seq(const char *name, void *data, SD_task_t res = SD_task_create_sized(name, data, amount, 1); res->computation_amount[0] = amount; res->kind = SD_TASK_COMP_SEQ; - return res; + +#ifdef HAVE_TRACING + TRACE_category("COMP_SEQ"); + TRACE_sd_set_task_category(res, "COMP_SEQ"); +#endif + +return res; } /** @brief create a parallel computation task that can then be auto-scheduled @@ -160,8 +172,8 @@ SD_task_t SD_task_create_comp_seq(const char *name, void *data, * 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) @@ -178,6 +190,12 @@ SD_task_t SD_task_create_comp_par_amdahl(const char *name, void *data, SD_task_t res = SD_task_create(name, data, amount); res->alpha = alpha; res->kind = SD_TASK_COMP_PAR_AMDAHL; + +#ifdef HAVE_TRACING + TRACE_category("COMP_PAR_AMDAHL"); + TRACE_sd_set_task_category(res, "COMP_PAR_AMDAHL"); +#endif + return res; } @@ -206,6 +224,12 @@ SD_task_t SD_task_create_comm_par_mxn_1d_block(const char *name, void *data, SD_task_t res = SD_task_create(name, data, amount); res->workstation_list=NULL; res->kind = SD_TASK_COMM_PAR_MXN_1D_BLOCK; + +#ifdef HAVE_TRACING + TRACE_category("COMM_PAR_MXN_1D_BLOCK"); + TRACE_sd_set_task_category(res, "COMM_PAR_MXN_1D_BLOCK"); +#endif + return res; } @@ -240,7 +264,7 @@ void SD_task_destroy(SD_task_t task) xbt_free(task->computation_amount); #ifdef HAVE_TRACING - if (task->category) xbt_free(task->category); + TRACE_sd_task_destroy(task); #endif xbt_mallocator_release(sd_global->task_mallocator,task); @@ -451,6 +475,40 @@ double SD_task_get_amount(SD_task_t task) return task->amount; } +/** + * \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 + */ +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 +538,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); @@ -511,6 +569,12 @@ void SD_task_dump(SD_task_t task) XBT_INFO(" - (unknown kind %d)", task->kind); } } + +#ifdef HAVE_TRACING + if (task->category) + XBT_INFO(" - tracing category: %s", task->category); +#endif + XBT_INFO(" - amount: %.0f", SD_task_get_amount(task)); if (task->kind == SD_TASK_COMP_PAR_AMDAHL) XBT_INFO(" - alpha: %.2f", task->alpha); @@ -577,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; @@ -608,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)); } @@ -640,6 +704,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. @@ -685,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 */ @@ -756,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; @@ -980,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; } @@ -1036,7 +1118,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 +1134,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 +1200,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 +1254,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 +1324,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 +1339,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"); @@ -1348,16 +1430,16 @@ 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, "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); + xbt_free(task->workstation_list); task->workstation_nb = ws_count; task->workstation_list = xbt_new0(SD_workstation_t, ws_count); @@ -1400,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, @@ -1477,20 +1559,24 @@ 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) { SD_task_t before = dep->src; if (before->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){ if (!before->workstation_list){ - XBT_VERB("Sender side of Task %s is not scheduled yet. Fill the workstation list with receiver side", + XBT_VERB("Sender side of Task %s is not scheduled yet", SD_task_get_name(before)); before->workstation_list = xbt_new0(SD_workstation_t, count); before->workstation_nb = count; + XBT_VERB("Fill the workstation list with list of Task '%s'", + SD_task_get_name(task)); for (i=0;iworkstation_list[i] = task->workstation_list[i]; } else { + XBT_VERB("Build communication matrix for task '%s'", + SD_task_get_name(before)); int src_nb, dst_nb; double src_start, src_end, dst_start, dst_end; src_nb = before->workstation_nb; @@ -1503,7 +1589,8 @@ void SD_task_schedulev(SD_task_t task, int count, task->workstation_list[i]; before->workstation_nb += count; - + 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, @@ -1545,10 +1632,12 @@ void SD_task_schedulev(SD_task_t task, int count, SD_task_t after = dep->dst; if (after->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){ if (!after->workstation_list){ - XBT_VERB("Receiver side of Task %s is not scheduled yet. Fill the workstation list with sender side", + XBT_VERB("Receiver side of Task '%s' is not scheduled yet", SD_task_get_name(after)); after->workstation_list = xbt_new0(SD_workstation_t, count); after->workstation_nb = count; + XBT_VERB("Fill the workstation list with list of Task '%s'", + SD_task_get_name(task)); for (i=0;iworkstation_list[i] = task->workstation_list[i]; } else { @@ -1566,6 +1655,9 @@ void SD_task_schedulev(SD_task_t task, int count, after->workstation_nb += count; + 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, after->workstation_nb* @@ -1622,50 +1714,3 @@ void SD_task_schedulel(SD_task_t task, int count, ...) SD_task_schedulev(task, count, list); free(list); } - -/** - * \brief Sets the tracing category of a task. - * - * This function should be called after the creation of a - * SimDAG task, to define the category of that task. The first - * parameter must contain a task that was created with the - * function #SD_task_create. The second parameter must contain - * a category that was previously declared with the function - * #TRACE_category. - * - * \param task The task to be considered - * \param category the name of the category to be associated to the task - * - * \see SD_task_get_category, TRACE_category, TRACE_category_with_color - */ -void SD_task_set_category (SD_task_t task, const char *category) -{ -#ifdef HAVE_TRACING - if (!TRACE_is_enabled()) return; - if (task == NULL) return; - if (category == NULL){ - if (task->category) xbt_free (task->category); - task->category = NULL; - }else{ - task->category = xbt_strdup (category); - } -#endif -} - -/** - * \brief Gets the current tracing category of a task. - * - * \param task The task to be considered - * - * \see SD_task_set_category - * - * \return Returns the name of the tracing category of the given task, NULL otherwise - */ -const char *SD_task_get_category (SD_task_t task) -{ -#ifdef HAVE_TRACING - return task->category; -#else - return NULL; -#endif -}