From 3ea83ea4df243d13bba5982959d9bc2232f3e113 Mon Sep 17 00:00:00 2001 From: Frederic Suter Date: Fri, 29 Jan 2016 15:31:57 +0100 Subject: [PATCH] don't count tasks in a global raised a bug in daxloader reindent while at it --- examples/simdag/dax/smalldax.tesh | 4 +- src/simdag/sd_daxloader.cpp | 42 ++- src/simdag/sd_global.cpp | 85 ++---- src/simdag/sd_task.cpp | 434 ++++++++++-------------------- src/simdag/simdag_private.h | 1 - 5 files changed, 180 insertions(+), 386 deletions(-) diff --git a/examples/simdag/dax/smalldax.tesh b/examples/simdag/dax/smalldax.tesh index ad30fd67fe..48d4ed4c11 100644 --- a/examples/simdag/dax/smalldax.tesh +++ b/examples/simdag/dax/smalldax.tesh @@ -3,8 +3,8 @@ p Test the DAX loader on a small DAX instance $ $SG_TEST_EXENV ${bindir:=.}/dax_test --log=no_loc ../2clusters.xml ./smalldax.xml > [0.000000] [xbt_cfg/INFO] Switching to the L07 model to handle parallel tasks. -> [0.000000] [sd_daxparse/WARNING] Ignoring file o1 size redefinition from 1000000 to 304 -> [0.000000] [sd_daxparse/WARNING] Ignoring file o2 size redefinition from 1000000 to 304 +> [0.000000] [sd_daxparse/WARNING] Ignore file o1 size redefinition from 1000000 to 304 +> [0.000000] [sd_daxparse/WARNING] Ignore file o2 size redefinition from 1000000 to 304 > [0.000000] [test/INFO] ------------------- Display all tasks of the loaded DAG --------------------------- > [0.000000] [sd_task/INFO] Displaying task root > [0.000000] [sd_task/INFO] - state: schedulable not runnable diff --git a/src/simdag/sd_daxloader.cpp b/src/simdag/sd_daxloader.cpp index bafe5f86d8..2141196814 100644 --- a/src/simdag/sd_daxloader.cpp +++ b/src/simdag/sd_daxloader.cpp @@ -29,13 +29,11 @@ static double dax_parse_double(const char *string) double value; ret = sscanf(string, "%lg", &value); - xbt_assert (ret == 1, "Parse error on line %d: %s is not a double", - dax_lineno, string); + xbt_assert (ret == 1, "Parse error on line %d: %s is not a double", dax_lineno, string); return value; } -/* Ensure that transfer tasks have unique names even though a file is used - * several times */ +/* Ensure that transfer tasks have unique names even though a file is used several times */ void uniq_transfer_task_name(SD_task_t task) { @@ -49,9 +47,7 @@ void uniq_transfer_task_name(SD_task_t task) xbt_dynar_get_cpy(children, 0, &child); xbt_dynar_get_cpy(parents, 0, &parent); - new_name = bprintf("%s_%s_%s", - SD_task_get_name(parent), - SD_task_get_name(task), SD_task_get_name(child)); + new_name = bprintf("%s_%s_%s", SD_task_get_name(parent), SD_task_get_name(task), SD_task_get_name(child)); SD_task_set_name(task, new_name); @@ -247,8 +243,7 @@ static void dax_task_free(void *task) /** @brief loads a DAX file describing a DAG * - * See https://confluence.pegasus.isi.edu/display/pegasus/WorkflowGenerator - * for more details. + * See https://confluence.pegasus.isi.edu/display/pegasus/WorkflowGenerator for more details. */ xbt_dynar_t SD_daxload(const char *filename) { @@ -308,8 +303,8 @@ xbt_dynar_t SD_daxload(const char *filename) xbt_dynar_foreach(file->tasks_after, cpt2, depafter) { if (depbefore->src == depafter->dst) { XBT_WARN - ("File %s is produced and consumed by task %s. This loop dependency will prevent the execution of the task.", - file->name, depbefore->src->name); + ("File %s is produced and consumed by task %s." + "This loop dependency will prevent the execution of the task.", file->name, depbefore->src->name); } newfile = SD_task_create_comm_e2e(file->name, NULL, file->amount); SD_task_dependency_add(NULL, NULL, depbefore->src, newfile); @@ -343,11 +338,10 @@ xbt_dynar_t SD_daxload(const char *filename) } if (!acyclic_graph_detail(result)){ - XBT_ERROR("The DAX described in %s is not a DAG. It contains a cycle.", - xbt_basename(filename)); + XBT_ERROR("The DAX described in %s is not a DAG. It contains a cycle.", xbt_basename(filename)); xbt_dynar_foreach(result, cpt, file) SD_task_destroy(file); - xbt_dynar_free_container(&result); + xbt_dynar_free_container(&result); return NULL; } else { return result; @@ -359,9 +353,7 @@ void STag_dax__adag(void) XBT_ATTRIB_UNUSED double version; version = dax_parse_double(A_dax__adag_version); - xbt_assert(version == 2.1, - "Expected version 2.1 in tag, got %f. Fix the parser or your file", - version); + xbt_assert(version == 2.1, "Expected version 2.1 in tag, got %f. Fix the parser or your file", version); } void STag_dax__job(void) @@ -386,11 +378,11 @@ void STag_dax__uses(void) file = (SD_task_t)xbt_dict_get_or_null(files, A_dax__uses_file); if (file == NULL) { file = SD_task_create_comm_e2e(A_dax__uses_file, NULL, size); + xbt_dynar_pop(sd_global->initial_task_set,NULL); xbt_dict_set(files, A_dax__uses_file, file, NULL); } else { if (SD_task_get_amount(file) != size) { - XBT_WARN("Ignoring file %s size redefinition from %.0f to %.0f", - A_dax__uses_file, SD_task_get_amount(file), size); + XBT_WARN("Ignore file %s size redefinition from %.0f to %.0f", A_dax__uses_file, SD_task_get_amount(file), size); } } if (is_input) { @@ -407,8 +399,7 @@ static SD_task_t current_child; void STag_dax__child(void) { current_child = (SD_task_t)xbt_dict_get_or_null(jobs, A_dax__child_ref); - xbt_assert(current_child != NULL,"Parse error on line %d:" - "Asked to add dependencies to the non-existent %s task", + xbt_assert(current_child != NULL,"Parse error on line %d: Asked to add dependencies to the non-existent %s task", dax_lineno, A_dax__child_ref); } @@ -420,13 +411,10 @@ void ETag_dax__child(void) void STag_dax__parent(void) { SD_task_t parent = (SD_task_t)xbt_dict_get_or_null(jobs, A_dax__parent_ref); - xbt_assert(parent != NULL, "Parse error on line %d: " - "Asked to add a dependency from %s to %s, but %s does not exist", - dax_lineno, current_child->name, A_dax__parent_ref, - A_dax__parent_ref); + xbt_assert(parent != NULL, "Parse error on line %d: Asked to add a dependency from %s to %s, but %s does not exist", + dax_lineno, current_child->name, A_dax__parent_ref, A_dax__parent_ref); SD_task_dependency_add(NULL, NULL, parent, current_child); - XBT_DEBUG("Control-flow dependency from %s to %s", current_child->name, - parent->name); + XBT_DEBUG("Control-flow dependency from %s to %s", current_child->name, parent->name); } void ETag_dax__adag(void) diff --git a/src/simdag/sd_global.cpp b/src/simdag/sd_global.cpp index f278ae154b..053a0fc0fe 100644 --- a/src/simdag/sd_global.cpp +++ b/src/simdag/sd_global.cpp @@ -23,16 +23,14 @@ #endif XBT_LOG_NEW_CATEGORY(sd, "Logging specific to SimDag"); -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_kernel, sd, - "Logging specific to SimDag (kernel)"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_kernel, sd, "Logging specific to SimDag (kernel)"); SD_global_t sd_global = NULL; /** * \brief Initializes SD internal data * - * This function must be called before any other SD function. Then you - * should call SD_create_environment(). + * This function must be called before any other SD function. Then you should call SD_create_environment(). * * \param argc argument number * \param argv argument list @@ -47,17 +45,13 @@ void SD_init(int *argc, char **argv) sd_global = xbt_new(s_SD_global_t, 1); sd_global->watch_point_reached = 0; - sd_global->task_mallocator=xbt_mallocator_new(65536, SD_task_new_f, - SD_task_free_f, - SD_task_recycle_f); + sd_global->task_mallocator=xbt_mallocator_new(65536, SD_task_new_f, SD_task_free_f, SD_task_recycle_f); sd_global->initial_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL); sd_global->executable_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL); sd_global->completed_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL); sd_global->return_set = xbt_dynar_new(sizeof(SD_task_t), NULL); - sd_global->task_number = 0; - surf_init(argc, argv); xbt_cfg_setdefault_string(_sg_cfg_set, "host/model", @@ -101,31 +95,8 @@ void SD_config(const char *key, const char *value){ */ void SD_application_reinit(void) { - -// s_SD_task_t task; - -// SD_task_t done_task, next_done_task; xbt_die("This function is not working since the C++ links and others. Please report the problem if you really need that function."); - XBT_DEBUG("Recreating the swags..."); - -// xbt_swag_foreach_safe(done_task, next_done_task, sd_global->done_task_set){ -// if (xbt_dynar_is_empty(done_task->tasks_before)){ -// __SD_task_set_state(done_task, SD_SCHEDULABLE); -// } else{ -// __SD_task_set_state(done_task, SD_NOT_SCHEDULED); -// done_task->unsatisfied_dependencies = -// xbt_dynar_length(done_task->tasks_before); -// done_task->is_not_ready = done_task->unsatisfied_dependencies; -// } -// free(done_task->workstation_list); -// done_task->workstation_list = NULL; -// done_task->workstation_nb = 0; -// } - - sd_global->task_number = 0; - - #ifdef HAVE_JEDULE jedule_sd_cleanup(); jedule_sd_init(); @@ -135,9 +106,8 @@ void SD_application_reinit(void) /** * \brief Creates the environment * - * The environment (i.e. the \ref sg_host_management "hosts" - * and the \ref SD_link_management "links") is created with the data stored - * in the given XML platform file. + * The environment (i.e. the \ref sg_host_management "hosts" and the \ref SD_link_management "links") is created with + * the data stored in the given XML platform file. * * \param platform_file name of an XML file describing the environment to create * \see sg_host_management, SD_link_management @@ -154,8 +124,7 @@ void SD_create_environment(const char *platform_file) { parse_platform_file(platform_file); - XBT_DEBUG("Workstation number: %zu, link number: %d", - sg_host_count(), sg_link_count()); + XBT_DEBUG("Workstation number: %zu, link number: %d", sg_host_count(), sg_link_count()); #ifdef HAVE_JEDULE jedule_setup_platform(); #endif @@ -165,15 +134,13 @@ void SD_create_environment(const char *platform_file) * \brief Launches the simulation. * * The function will execute the \ref SD_RUNNABLE runnable tasks. - * If \a how_long is positive, then the simulation will be stopped either - * when time reaches \a how_long or when a watch point is reached. - * A non-positive value for \a how_long means no time limit, in which case - * the simulation will be stopped either when a watch point is reached or - * when no more task can be executed. + * If \a how_long is positive, then the simulation will be stopped either when time reaches \a how_long or when a watch + * point is reached. + * A non-positive value for \a how_long means no time limit, in which case the simulation will be stopped either when a + * watch point is reached or when no more task can be executed. * Then you can call SD_simulate() again. * - * \param how_long maximum duration of the simulation (a negative value means - * no time limit) + * \param how_long maximum duration of the simulation (a negative value means no time limit) * \return a dynar of \ref SD_task_t whose state has changed. * \see SD_task_schedule(), SD_task_watch() */ @@ -210,8 +177,7 @@ xbt_dynar_t SD_simulate(double how_long) { /* main loop */ elapsed_time = 0.0; - while (elapsed_time >= 0.0 && - (how_long < 0.0 || 0.00001 < (how_long -total_time)) && + while (elapsed_time >= 0.0 && (how_long < 0.0 || 0.00001 < (how_long -total_time)) && !sd_global->watch_point_reached) { surf_model_t model = NULL; /* dumb variables */ @@ -260,8 +226,7 @@ xbt_dynar_t SD_simulate(double how_long) { SD_task_set_state(dst, SD_SCHEDULABLE); } - if (SD_task_get_state(dst) == SD_NOT_SCHEDULED && - !(dst->is_not_ready)) { + if (SD_task_get_state(dst) == SD_NOT_SCHEDULED && !(dst->is_not_ready)) { SD_task_set_state(dst, SD_SCHEDULABLE); } @@ -270,13 +235,11 @@ xbt_dynar_t SD_simulate(double how_long) { SD_task_t comm_dst; xbt_dynar_get_cpy(dst->tasks_after, 0, &comm_dep); comm_dst = comm_dep->dst; - if (SD_task_get_state(comm_dst) == SD_NOT_SCHEDULED && - comm_dst->is_not_ready > 0) { + if (SD_task_get_state(comm_dst) == SD_NOT_SCHEDULED && comm_dst->is_not_ready > 0) { comm_dst->is_not_ready--; XBT_DEBUG("%s is a transfer, %s may be ready now if %d=0", - SD_task_get_name(dst), SD_task_get_name(comm_dst), - comm_dst->is_not_ready); + SD_task_get_name(dst), SD_task_get_name(comm_dst), comm_dst->is_not_ready); if (!(comm_dst->is_not_ready)) { SD_task_set_state(comm_dst, SD_SCHEDULABLE); @@ -285,8 +248,7 @@ xbt_dynar_t SD_simulate(double how_long) { } /* is dst runnable now? */ - if (SD_task_get_state(dst) == SD_RUNNABLE - && !sd_global->watch_point_reached) { + if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) { XBT_VERB("Executing task '%s'", SD_task_get_name(dst)); SD_task_run(dst); xbt_dynar_push(sd_global->return_set, &dst); @@ -310,18 +272,13 @@ xbt_dynar_t SD_simulate(double how_long) { } if (!sd_global->watch_point_reached && how_long<0){ - if ((int) xbt_dynar_length(sd_global->completed_task_set) < - sd_global->task_number){ - XBT_WARN("Simulation is finished but %d tasks are still not done", - (sd_global->task_number - - (int) xbt_dynar_length(sd_global->completed_task_set))); + if (!xbt_dynar_is_empty(sd_global->initial_task_set)) { + XBT_WARN("Simulation is finished but %zu tasks are still not done", + xbt_dynar_length(sd_global->initial_task_set)); static const char* state_names[] = - { "SD_NOT_SCHEDULED", "SD_SCHEDULABLE", "SD_SCHEDULED", - "SD_RUNNABLE", "SD_RUNNING", "SD_DONE", - "SD_FAILED" }; + { "SD_NOT_SCHEDULED", "SD_SCHEDULABLE", "SD_SCHEDULED", "SD_RUNNABLE", "SD_RUNNING", "SD_DONE","SD_FAILED" }; xbt_dynar_foreach(sd_global->initial_task_set, iter, task){ - XBT_WARN("%s is in %s state", SD_task_get_name(task), - state_names[SD_task_get_state(task)]); + XBT_WARN("%s is in %s state", SD_task_get_name(task), state_names[SD_task_get_state(task)]); } } } diff --git a/src/simdag/sd_task.cpp b/src/simdag/sd_task.cpp index 278ee1abfb..c5e72f2ae4 100644 --- a/src/simdag/sd_task.cpp +++ b/src/simdag/sd_task.cpp @@ -12,8 +12,7 @@ #include "xbt/dynar.h" #include "src/instr/instr_private.h" -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_task, sd, - "Logging specific to SimDag (task)"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_task, sd, "Logging specific to SimDag (task)"); static void __SD_task_remove_dependencies(SD_task_t task); static void __SD_task_destroy_scheduling_data(SD_task_t task); @@ -36,6 +35,7 @@ void SD_task_recycle_f(void *t) task->state= SD_NOT_SCHEDULED; xbt_dynar_push(sd_global->initial_task_set,&task); + task->marked = 0; task->start_time = -1.0; @@ -85,14 +85,10 @@ SD_task_t SD_task_create(const char *name, void *data, double amount) task->amount = amount; task->remains = amount; - sd_global->task_number++; - return task; } -static XBT_INLINE SD_task_t SD_task_create_sized(const char *name, - void *data, double amount, - int ws_count) +static XBT_INLINE SD_task_t SD_task_create_sized(const char *name, void *data, double amount, int ws_count) { SD_task_t task = SD_task_create(name, data, amount); task->bytes_amount = xbt_new0(double, ws_count * ws_count); @@ -104,16 +100,14 @@ static XBT_INLINE SD_task_t SD_task_create_sized(const char *name, /** @brief create a end-to-end communication task that can then be auto-scheduled * - * Auto-scheduling mean that the task can be used with SD_task_schedulev(). This - * allows to specify the task costs at creation, and decouple them from the - * scheduling process where you just specify which resource should deliver the + * Auto-scheduling mean that the task can be used with SD_task_schedulev(). This allows to specify the task costs at + * creation, and decouple them from the scheduling process where you just specify which resource should deliver the * mandatory power. * - * A end-to-end communication must be scheduled on 2 hosts, and the amount - * specified at creation is sent from hosts[0] to hosts[1]. + * A end-to-end communication must be scheduled on 2 hosts, and the amount specified at creation is sent from hosts[0] + * to hosts[1]. */ -SD_task_t SD_task_create_comm_e2e(const char *name, void *data, - double amount) +SD_task_t SD_task_create_comm_e2e(const char *name, void *data, double amount) { SD_task_t res = SD_task_create_sized(name, data, amount, 2); res->bytes_amount[2] = amount; @@ -124,21 +118,18 @@ SD_task_t SD_task_create_comm_e2e(const char *name, void *data, /** @brief create a sequential computation task that can then be auto-scheduled * - * Auto-scheduling mean that the task can be used with SD_task_schedulev(). This - * allows to specify the task costs at creation, and decouple them from the - * scheduling process where you just specify which resource should deliver the + * Auto-scheduling mean that the task can be used with SD_task_schedulev(). This allows to specify the task costs at + * creation, and decouple them from the scheduling process where you just specify which resource should deliver the * mandatory power. * - * A sequential computation must be scheduled on 1 host, and the amount - * specified at creation to be run on hosts[0]. + * A sequential computation must be scheduled on 1 host, and the amount specified at creation to be run on hosts[0]. * * \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) * \param flops_amount amount of compute work to be done by the task * \return the new SD_TASK_COMP_SEQ typed task */ -SD_task_t SD_task_create_comp_seq(const char *name, void *data, - double flops_amount) +SD_task_t SD_task_create_comp_seq(const char *name, void *data, double flops_amount) { SD_task_t res = SD_task_create_sized(name, data, flops_amount, 1); res->flops_amount[0] = flops_amount; @@ -149,26 +140,22 @@ SD_task_t SD_task_create_comp_seq(const char *name, void *data, /** @brief create a parallel computation task that can then be auto-scheduled * - * Auto-scheduling mean that the task can be used with SD_task_schedulev(). This - * allows to specify the task costs at creation, and decouple them from the - * scheduling process where you just specify which resource should deliver the + * Auto-scheduling mean that the task can be used with SD_task_schedulev(). This allows to specify the task costs at + * creation, and decouple them from the scheduling process where you just specify which resource should deliver the * 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_amdahl has to be called - * first. + * 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) * \param flops_amount amount of compute work to be done by the task * \param alpha purely serial fraction of the work to be done (in [0.;1.[) * \return the new task */ -SD_task_t SD_task_create_comp_par_amdahl(const char *name, void *data, - double flops_amount, double alpha) +SD_task_t SD_task_create_comp_par_amdahl(const char *name, void *data, double flops_amount, double alpha) { - xbt_assert(alpha < 1. && alpha >= 0., - "Invalid parameter: alpha must be in [0.;1.["); + xbt_assert(alpha < 1. && alpha >= 0., "Invalid parameter: alpha must be in [0.;1.["); SD_task_t res = SD_task_create(name, data, flops_amount); res->alpha = alpha; @@ -177,27 +164,21 @@ SD_task_t SD_task_create_comp_par_amdahl(const char *name, void *data, return res; } -/** @brief create a complex data redistribution task that can then be - * auto-scheduled +/** @brief create a complex data redistribution task that can then be auto-scheduled * * Auto-scheduling mean that the task can be used with SD_task_schedulev(). - * This allows to specify the task costs at creation, and decouple them from - * the scheduling process where you just specify which resource should - * communicate. + * This allows to specify the task costs at creation, and decouple them from the scheduling process where you just + * specify which resource should communicate. * * A data redistribution can be scheduled on any number of host. - * The assumed distribution is a 1D block distribution. Each host owns the same - * share of the \see amount. - * To be auto-scheduled, \see SD_task_distribute_comm_mxn_1d_block has to be - * called first. + * The assumed distribution is a 1D block distribution. Each host owns the same share of the \see amount. + * To be auto-scheduled, \see SD_task_distribute_comm_mxn_1d_block 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) + * \param data the user data you want to associate with the task (can be \c NULL) * \param amount amount of data to redistribute by the task * \return the new task */ -SD_task_t SD_task_create_comm_par_mxn_1d_block(const char *name, void *data, - double amount) +SD_task_t SD_task_create_comm_par_mxn_1d_block(const char *name, void *data, double amount) { SD_task_t res = SD_task_create(name, data, amount); res->host_list=NULL; @@ -239,7 +220,6 @@ void SD_task_destroy(SD_task_t task) xbt_free(task->flops_amount); xbt_mallocator_release(sd_global->task_mallocator,task); - sd_global->task_number--; XBT_DEBUG("Task destroyed."); } @@ -274,11 +254,9 @@ void SD_task_set_data(SD_task_t task, void *data) /** * \brief Sets the rate of a task * - * This will change the network bandwidth a task can use. This rate - * cannot be dynamically changed. Once the task has started, this call - * is ineffective. This rate depends on both the nominal bandwidth on - * the route onto which the task is scheduled (\see - * SD_task_get_current_bandwidth) and the amount of data to transfer. + * This will change the network bandwidth a task can use. This rate cannot be dynamically changed. Once the task has + * started, this call is ineffective. This rate depends on both the nominal bandwidth on the route onto which the task + * is scheduled (\see SD_task_get_current_bandwidth) and the amount of data to transfer. * * To divide the nominal bandwidth by 2, the rate then has to be : * rate = bandwidth/(2*amount) @@ -288,8 +266,7 @@ void SD_task_set_data(SD_task_t task, void *data) */ void SD_task_set_rate(SD_task_t task, double rate) { - xbt_assert(task->kind == SD_TASK_COMM_E2E, - "The rate can be modified for end-to-end communications only."); + xbt_assert(task->kind == SD_TASK_COMM_E2E, "The rate can be modified for end-to-end communications only."); if(task->start_time<0) { task->rate = rate; } else { @@ -310,7 +287,7 @@ e_SD_task_state_t SD_task_get_state(SD_task_t task) return task->state; } -/* Changes the state of a task. Updates the swags and the flag sd_global->watch_point_reached. +/* Changes the state of a task. Updates the sd_global->watch_point_reached flag. */ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state) { @@ -455,13 +432,10 @@ 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 flops_amount and bytes_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. +/** @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 flops_amount and + * bytes_amount arrays respectively. Nothing more than modifying task->amount is done for parallel 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 @@ -483,8 +457,7 @@ void SD_task_set_amount(SD_task_t task, double amount) */ 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"); + xbt_assert(SD_task_get_kind(task) == SD_TASK_COMP_PAR_AMDAHL, "Alpha parameter is not defined for this kind of task"); return task->alpha; } @@ -499,7 +472,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_action_get_remains(task->surf_action); + return surf_action_get_remains(task->surf_action); else return task->remains; } @@ -518,12 +491,10 @@ 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", - (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" : - " not runnable"), + (task->state == SD_RUNNABLE ? " runnable" : " not runnable"), (task->state == SD_RUNNING ? " running" : ""), (task->state == SD_DONE ? " done" : ""), (task->state == SD_FAILED ? " failed" : "")); @@ -615,8 +586,7 @@ static void __SD_task_dependency_destroy(void *dependency) * \param dst the task you want to make depend on \a src * \see SD_task_dependency_remove() */ -void SD_task_dependency_add(const char *name, void *data, SD_task_t src, - SD_task_t dst) +void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst) { xbt_dynar_t dynar; unsigned long length; @@ -629,36 +599,28 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, length = xbt_dynar_length(dynar); if (src == dst) - THROWF(arg_error, 0, - "Cannot add a dependency between task '%s' and itself", - SD_task_get_name(src)); + THROWF(arg_error, 0, "Cannot add a dependency between task '%s' and itself", SD_task_get_name(src)); state = SD_task_get_state(src); - if (state != SD_NOT_SCHEDULED && state != SD_SCHEDULABLE && - state != SD_RUNNING && state != SD_SCHEDULED && state != SD_RUNNABLE) - THROWF(arg_error, 0, - "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED," - " SD_RUNNABLE or SD_RUNNING", SD_task_get_name(src)); + if (state != SD_NOT_SCHEDULED && state != SD_SCHEDULABLE && state != SD_RUNNING && state != SD_SCHEDULED && + state != SD_RUNNABLE) + THROWF(arg_error, 0, "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED, SD_RUNNABLE, or SD_RUNNING", + SD_task_get_name(src)); state = SD_task_get_state(dst); - if (state != SD_NOT_SCHEDULED && state != SD_SCHEDULABLE && - state != SD_SCHEDULED && state != SD_RUNNABLE) - THROWF(arg_error, 0, - "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED," - "or SD_RUNNABLE", SD_task_get_name(dst)); - - XBT_DEBUG("SD_task_dependency_add: src = %s, dst = %s", - SD_task_get_name(src), SD_task_get_name(dst)); + if (state != SD_NOT_SCHEDULED && state != SD_SCHEDULABLE && state != SD_SCHEDULED && state != SD_RUNNABLE) + THROWF(arg_error, 0, "Task '%s' must be SD_NOT_SCHEDULED, SD_SCHEDULABLE, SD_SCHEDULED, or SD_RUNNABLE", + SD_task_get_name(dst)); + + XBT_DEBUG("SD_task_dependency_add: src = %s, dst = %s", SD_task_get_name(src), SD_task_get_name(dst)); for (i = 0; i < length && !found; i++) { xbt_dynar_get_cpy(dynar, i, &dependency); found = (dependency->dst == dst); - XBT_DEBUG("Dependency %lu: dependency->dst = %s", i, - SD_task_get_name(dependency->dst)); + XBT_DEBUG("Dependency %lu: dependency->dst = %s", i, SD_task_get_name(dependency->dst)); } if (found) - THROWF(arg_error, 0, - "A dependency already exists between task '%s' and task '%s'", + THROWF(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_new(s_SD_dependency_t, 1); @@ -675,12 +637,9 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, dst->unsatisfied_dependencies++; dst->is_not_ready++; - /* if the task was runnable, then dst->tasks_before is not empty anymore, - so we must go back to state SD_SCHEDULED */ + /* if the task was runnable, then dst->tasks_before is not empty anymore, so we must go back to state SD_SCHEDULED */ if (SD_task_get_state(dst) == SD_RUNNABLE) { - XBT_DEBUG - ("SD_task_dependency_add: %s was runnable and becomes scheduled!", - SD_task_get_name(dst)); + XBT_DEBUG("SD_task_dependency_add: %s was runnable and becomes scheduled!", SD_task_get_name(dst)); SD_task_set_state(dst, SD_SCHEDULED); } } @@ -716,9 +675,7 @@ int SD_task_dependency_exists(SD_task_t src, SD_task_t dst) unsigned int counter; SD_dependency_t dependency; - xbt_assert(src != NULL - || dst != NULL, - "Invalid parameter: both src and dst are NULL"); + xbt_assert(src != NULL || dst != NULL, "Invalid parameter: both src and dst are NULL"); if (src) { if (dst) { @@ -744,7 +701,6 @@ int SD_task_dependency_exists(SD_task_t src, SD_task_t dst) */ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) { - xbt_dynar_t dynar; unsigned long length; int found = 0; @@ -763,10 +719,8 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) } } if (!found) - THROWF(arg_error, 0, - "No dependency found between task '%s' and '%s': task '%s' is not a successor of task '%s'", - SD_task_get_name(src), SD_task_get_name(dst), - SD_task_get_name(dst), SD_task_get_name(src)); + THROWF(arg_error, 0, "No dependency found between task '%s' and '%s': task '%s' is not a successor of task '%s'", + SD_task_get_name(src), SD_task_get_name(dst), SD_task_get_name(dst), SD_task_get_name(src)); /* remove the dependency from dst->tasks_before */ dynar = dst->tasks_before; @@ -784,10 +738,8 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) } } /* should never happen... */ - xbt_assert(found, - "SimDag error: task '%s' is a successor of '%s' but task '%s' is not a predecessor of task '%s'", - SD_task_get_name(dst), SD_task_get_name(src), - SD_task_get_name(src), SD_task_get_name(dst)); + xbt_assert(found, "SimDag error: task '%s' is a successor of '%s' but task '%s' is not a predecessor of task '%s'", + SD_task_get_name(dst), SD_task_get_name(src), SD_task_get_name(src), SD_task_get_name(dst)); /* if the task was scheduled and dst->tasks_before is empty now, we can make it runnable */ @@ -800,9 +752,6 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) if (dst->is_not_ready == 0) SD_task_set_state(dst, SD_SCHEDULABLE); - - /* __SD_print_dependencies(src); - __SD_print_dependencies(dst); */ } /** @@ -815,7 +764,6 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) */ void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst) { - xbt_dynar_t dynar; unsigned long length; int found = 0; @@ -838,9 +786,8 @@ void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst) /** * \brief Adds a watch point to a task * - * SD_simulate() will stop as soon as the \ref e_SD_task_state_t "state" of this - * task becomes the one given in argument. The - * watch point is then automatically removed. + * SD_simulate() will stop as soon as the \ref e_SD_task_state_t "state" of this task becomes the one given in argument. + * The watch point is then automatically removed. * * \param task a task * \param state the \ref e_SD_task_state_t "state" you want to watch @@ -850,8 +797,7 @@ void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst) void SD_task_watch(SD_task_t task, e_SD_task_state_t state) { if (state & SD_NOT_SCHEDULED) - THROWF(arg_error, 0, - "Cannot add a watch point for state SD_NOT_SCHEDULED"); + THROWF(arg_error, 0, "Cannot add a watch point for state SD_NOT_SCHEDULED"); task->watch_points = task->watch_points | state; } @@ -865,8 +811,7 @@ void SD_task_watch(SD_task_t task, e_SD_task_state_t state) */ void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state) { - xbt_assert(state != SD_NOT_SCHEDULED, - "SimDag error: Cannot have a watch point for state SD_NOT_SCHEDULED"); + xbt_assert(state != SD_NOT_SCHEDULED, "SimDag error: Cannot have a watch point for state SD_NOT_SCHEDULED"); task->watch_points = task->watch_points & ~state; } @@ -874,8 +819,8 @@ void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state) /** * \brief Returns an approximative estimation of the execution time of a task. * - * The estimation is very approximative because the value returned is the time - * the task would take if it was executed now and if it was the only task. + * The estimation is very approximative because the value returned is the time the task would take if it was executed + * now and if it was the only task. * * \param task the task to evaluate * \param workstation_nb number of workstations on which the task would be executed @@ -884,12 +829,8 @@ void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state) * \param bytes_amount communication amount between each pair of workstations * \see SD_schedule() */ -double SD_task_get_execution_time(SD_task_t task, - int workstation_nb, - const sg_host_t * - workstation_list, - const double *flops_amount, - const double *bytes_amount) +double SD_task_get_execution_time(SD_task_t task, int workstation_nb, const sg_host_t *workstation_list, + const double *flops_amount, const double *bytes_amount) { double time, max_time = 0.0; int i, j; @@ -905,11 +846,9 @@ double SD_task_get_execution_time(SD_task_t task, if (bytes_amount != NULL) for (j = 0; j < workstation_nb; j++) { if (bytes_amount[i * workstation_nb + j] !=0 ) { - time += (SD_route_get_latency(workstation_list[i], - workstation_list[j]) + + time += (SD_route_get_latency(workstation_list[i], workstation_list[j]) + bytes_amount[i * workstation_nb + j] / - SD_route_get_bandwidth(workstation_list[i], - workstation_list[j])); + SD_route_get_bandwidth(workstation_list[i], workstation_list[j])); } } @@ -923,8 +862,7 @@ double SD_task_get_execution_time(SD_task_t task, static XBT_INLINE void SD_task_do_schedule(SD_task_t task) { if (SD_task_get_state(task) > SD_SCHEDULABLE) - THROWF(arg_error, 0, "Task '%s' has already been scheduled", - SD_task_get_name(task)); + THROWF(arg_error, 0, "Task '%s' has already been scheduled", SD_task_get_name(task)); /* update the task state */ if (task->unsatisfied_dependencies == 0) @@ -937,8 +875,7 @@ static XBT_INLINE void SD_task_do_schedule(SD_task_t task) * \brief Schedules a task * * The task state must be #SD_NOT_SCHEDULED. - * Once scheduled, a task will be executed as soon as possible in SD_simulate(), - * i.e. when its dependencies are satisfied. + * Once scheduled, a task is executed as soon as possible in \see SD_simulate, i.e. when its dependencies are satisfied. * * \param task the task you want to schedule * \param workstation_count number of workstations on which the task will be executed @@ -948,10 +885,8 @@ static XBT_INLINE void SD_task_do_schedule(SD_task_t task) * \param rate task execution speed rate * \see SD_task_unschedule() */ -void SD_task_schedule(SD_task_t task, int workstation_count, - const sg_host_t * workstation_list, - const double *flops_amount, - const double *bytes_amount, double rate) +void SD_task_schedule(SD_task_t task, int workstation_count, const sg_host_t * workstation_list, + const double *flops_amount, const double *bytes_amount, double rate) { xbt_assert(workstation_count > 0, "workstation_nb must be positive"); @@ -959,10 +894,8 @@ void SD_task_schedule(SD_task_t task, int workstation_count, task->rate = rate; if (flops_amount) { - task->flops_amount = (double*)xbt_realloc(task->flops_amount, - sizeof(double) * workstation_count); - memcpy(task->flops_amount, flops_amount, - sizeof(double) * workstation_count); + task->flops_amount = (double*)xbt_realloc(task->flops_amount, sizeof(double) * workstation_count); + memcpy(task->flops_amount, flops_amount, sizeof(double) * workstation_count); } else { xbt_free(task->flops_amount); task->flops_amount = NULL; @@ -970,20 +903,15 @@ void SD_task_schedule(SD_task_t task, int workstation_count, int communication_nb = workstation_count * workstation_count; if (bytes_amount) { - task->bytes_amount = (double*)xbt_realloc(task->bytes_amount, - sizeof(double) * communication_nb); - memcpy(task->bytes_amount, bytes_amount, - sizeof(double) * communication_nb); + task->bytes_amount = (double*)xbt_realloc(task->bytes_amount, sizeof(double) * communication_nb); + memcpy(task->bytes_amount, bytes_amount, sizeof(double) * communication_nb); } else { xbt_free(task->bytes_amount); task->bytes_amount = NULL; } - task->host_list = (sg_host_t*) - xbt_realloc(task->host_list, - sizeof(sg_host_t) * workstation_count); - memcpy(task->host_list, workstation_list, - sizeof(sg_host_t) * workstation_count); + task->host_list = (sg_host_t*) xbt_realloc(task->host_list, sizeof(sg_host_t) * workstation_count); + memcpy(task->host_list, workstation_list, sizeof(sg_host_t) * workstation_count); SD_task_do_schedule(task); } @@ -1000,18 +928,15 @@ void SD_task_schedule(SD_task_t task, int workstation_count, */ void SD_task_unschedule(SD_task_t task) { - if (task->state != SD_SCHEDULED && - task->state != SD_RUNNABLE && - task->state != SD_RUNNING && + if (task->state != SD_SCHEDULED && task->state != SD_RUNNABLE && task->state != SD_RUNNING && task->state != SD_FAILED) - THROWF(arg_error, 0, - "Task %s: the state must be SD_SCHEDULED, SD_RUNNABLE, SD_RUNNING or SD_FAILED", + THROWF(arg_error, 0, "Task %s: the state must be SD_SCHEDULED, SD_RUNNABLE, SD_RUNNING or SD_FAILED", SD_task_get_name(task)); if ((task->state == SD_SCHEDULED || task->state == SD_RUNNABLE) /* if the task is scheduled or runnable */ - && ((task->kind == SD_TASK_COMP_PAR_AMDAHL) || - (task->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK))) { /* Don't free scheduling data for typed tasks */ + && ((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->host_list); task->host_list=NULL; @@ -1031,37 +956,27 @@ void SD_task_unschedule(SD_task_t task) task->start_time = -1.0; } -/* Destroys the data memorized by SD_task_schedule. - * Task state must be SD_SCHEDULED or SD_RUNNABLE. +/* Destroys the data memorized by SD_task_schedule. Task state must be SD_SCHEDULED or SD_RUNNABLE. */ static void __SD_task_destroy_scheduling_data(SD_task_t task) { if (task->state != SD_SCHEDULED && task->state != SD_RUNNABLE) - THROWF(arg_error, 0, - "Task '%s' must be SD_SCHEDULED or SD_RUNNABLE", - SD_task_get_name(task)); + THROWF(arg_error, 0, "Task '%s' must be SD_SCHEDULED or SD_RUNNABLE", SD_task_get_name(task)); xbt_free(task->flops_amount); xbt_free(task->bytes_amount); task->flops_amount = task->bytes_amount = NULL; } -/* 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. - */ +/* Runs a task. */ void SD_task_run(SD_task_t task) { - int i; sg_host_t *hosts; - xbt_assert(SD_task_get_state(task) == SD_RUNNABLE, - "Task '%s' is not runnable! Task state: %d", + xbt_assert(SD_task_get_state(task) == SD_RUNNABLE, "Task '%s' is not runnable! Task state: %d", SD_task_get_name(task), (int)SD_task_get_state(task)); - xbt_assert(task->host_list != NULL, - "Task '%s': workstation_list is NULL!", - SD_task_get_name(task)); + xbt_assert(task->host_list != NULL, "Task '%s': workstation_list is NULL!", SD_task_get_name(task)); XBT_DEBUG("Running task '%s'", SD_task_get_name(task)); @@ -1078,11 +993,9 @@ void SD_task_run(SD_task_t task) if(task->flops_amount) memcpy(flops_amount, task->flops_amount, sizeof(double) * host_nb); if(task->bytes_amount) - memcpy(bytes_amount, task->bytes_amount, - sizeof(double) * host_nb * host_nb); + memcpy(bytes_amount, task->bytes_amount, sizeof(double) * host_nb * host_nb); - task->surf_action = surf_host_model->executeParallelTask( - host_nb, hosts, flops_amount, bytes_amount, task->rate); + task->surf_action = surf_host_model->executeParallelTask(host_nb, hosts, flops_amount, bytes_amount, task->rate); task->surf_action->setData(task); @@ -1093,20 +1006,17 @@ void SD_task_run(SD_task_t task) __SD_task_destroy_scheduling_data(task); /* now the scheduling data are not useful anymore */ SD_task_set_state(task, SD_RUNNING); - xbt_assert(SD_task_get_state(task) == SD_RUNNING, - "Bad state of task '%s': %d", + xbt_assert(SD_task_get_state(task) == SD_RUNNING, "Bad state of task '%s': %d", SD_task_get_name(task), (int)SD_task_get_state(task)); } /* - * Remove all dependencies associated with a task. This function is called - * when the task is destroyed. + * 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) { - /* we must destroy the dependencies carefuly (with SD_dependency_remove) - because each one is stored twice */ + /* we must destroy the dependencies carefuly (with SD_dependency_remove) because each one is stored twice */ SD_dependency_t dependency; while (!xbt_dynar_is_empty(task->tasks_before)) { xbt_dynar_get_cpy(task->tasks_before, 0, &dependency); @@ -1139,9 +1049,8 @@ double SD_task_get_start_time(SD_task_t task) * \brief Returns the finish time of a task * * The task state must be SD_RUNNING, SD_DONE or SD_FAILED. - * If the state is not completed yet, the returned value is an - * estimation of the task finish time. This value can fluctuate - * until the task is completed. + * If the state is not completed yet, the returned value is an estimation of the task finish time. This value can + * vary until the task is completed. * * \param task: a task * \return the start time of this task @@ -1153,16 +1062,12 @@ double SD_task_get_finish_time(SD_task_t task) else return task->finish_time; } -/** @brief Blah - * - */ + 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)); + 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->flops_amount = xbt_new0(double, ws_count); task->bytes_amount = xbt_new0(double, ws_count * ws_count); xbt_free(task->host_list); @@ -1170,50 +1075,39 @@ void SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count) task->host_list = xbt_new0(sg_host_t, ws_count); for(i=0;iflops_amount[i] = - (task->alpha + (1 - task->alpha)/ws_count) * task->amount; + task->flops_amount[i] = (task->alpha + (1 - task->alpha)/ws_count) * task->amount; } } /** @brief Auto-schedules a task. * - * Auto-scheduling mean that the task can be used with SD_task_schedulev(). This - * allows to specify the task costs at creation, and decouple them from the - * scheduling process where you just specify which resource should deliver the + * Auto-scheduling mean that the task can be used with SD_task_schedulev(). This allows to specify the task costs at + * creation, and decouple them from the scheduling process where you just specify which resource should deliver the * mandatory power. * - * To be auto-schedulable, a task must be created with SD_task_create_comm_e2e() - * or SD_task_create_comp_seq(). Check their definitions for the exact semantic - * of each of them. + * To be auto-schedulable, a task must be type and created with one of the specialized creation functions. * * @todo * We should create tasks kind for the following categories: * - Point to point communication (done) * - Sequential computation (done) * - group communication (redistribution, several kinds) - * - parallel tasks with no internal communication (one kind per speedup - * model such as Amdahl) - * - idem+ internal communication. Task type not enough since we cannot store - * comm cost alongside to comp one) + * - parallel tasks with no internal communication (one kind per speedup model such as Amdahl) + * - idem+ internal communication. Task type not enough since we cannot store comm cost alongside to comp one) */ -void SD_task_schedulev(SD_task_t task, int count, - const sg_host_t * list) +void SD_task_schedulev(SD_task_t task, int count, const sg_host_t * list) { int i, j; SD_dependency_t dep; unsigned int cpt; - xbt_assert(task->kind != 0, - "Task %s is not typed. Cannot automatically schedule it.", - SD_task_get_name(task)); + xbt_assert(task->kind != 0, "Task %s is not typed. Cannot automatically schedule it.", SD_task_get_name(task)); switch (task->kind) { case SD_TASK_COMP_PAR_AMDAHL: SD_task_distribute_comp_amdahl(task, count); case SD_TASK_COMM_E2E: case SD_TASK_COMP_SEQ: - xbt_assert(task->host_count == count, - "Got %d locations, but were expecting %d locations", - count,task->host_count); + xbt_assert(task->host_count == count, "Got %d locations, but were expecting %d locations", count,task->host_count); for (i = 0; i < count; i++) task->host_list[i] = list[i]; if (SD_task_get_kind(task)== SD_TASK_COMP_SEQ && !task->flops_amount){ @@ -1224,40 +1118,28 @@ void SD_task_schedulev(SD_task_t task, int count, SD_task_do_schedule(task); break; default: - xbt_die("Kind of task %s not supported by SD_task_schedulev()", - SD_task_get_name(task)); + xbt_die("Kind of task %s not supported by SD_task_schedulev()", SD_task_get_name(task)); } if (task->kind == SD_TASK_COMM_E2E) { - XBT_VERB("Schedule comm task %s between %s -> %s. It costs %.f bytes", - SD_task_get_name(task), - sg_host_get_name(task->host_list[0]), - sg_host_get_name(task->host_list[1]), - task->bytes_amount[2]); + XBT_VERB("Schedule comm task %s between %s -> %s. It costs %.f bytes", SD_task_get_name(task), + sg_host_get_name(task->host_list[0]), sg_host_get_name(task->host_list[1]), task->bytes_amount[2]); } - /* Iterate over all children and parents being COMM_E2E to say where I am - * located (and start them if runnable) */ + /* Iterate over all children and parents being COMM_E2E to say where I am located (and start them if runnable) */ if (task->kind == SD_TASK_COMP_SEQ) { - XBT_VERB("Schedule computation task %s on %s. It costs %.f flops", - SD_task_get_name(task), - sg_host_get_name(task->host_list[0]), - task->flops_amount[0]); + XBT_VERB("Schedule computation task %s on %s. It costs %.f flops", SD_task_get_name(task), + sg_host_get_name(task->host_list[0]), task->flops_amount[0]); xbt_dynar_foreach(task->tasks_before, cpt, dep) { SD_task_t before = dep->src; if (before->kind == SD_TASK_COMM_E2E) { before->host_list[1] = task->host_list[0]; - if (before->host_list[0] && - (SD_task_get_state(before)< SD_SCHEDULED)) { + if (before->host_list[0] && (SD_task_get_state(before) < SD_SCHEDULED)) { SD_task_do_schedule(before); - XBT_VERB - ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes", - SD_task_get_name(before), - sg_host_get_name(before->host_list[0]), - sg_host_get_name(before->host_list[1]), - before->bytes_amount[2]); + XBT_VERB ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes", SD_task_get_name(before), + sg_host_get_name(before->host_list[0]), sg_host_get_name(before->host_list[1]), before->bytes_amount[2]); } } } @@ -1265,61 +1147,43 @@ void SD_task_schedulev(SD_task_t task, int count, SD_task_t after = dep->dst; if (after->kind == SD_TASK_COMM_E2E) { after->host_list[0] = task->host_list[0]; - if (after->host_list[1] - && (SD_task_get_state(after)< SD_SCHEDULED)) { + if (after->host_list[1] && (SD_task_get_state(after) < SD_SCHEDULED)) { SD_task_do_schedule(after); - XBT_VERB - ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes", - SD_task_get_name(after), - sg_host_get_name(after->host_list[0]), - sg_host_get_name(after->host_list[1]), - after->bytes_amount[2]); - + XBT_VERB ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes", SD_task_get_name(after), + sg_host_get_name(after->host_list[0]), sg_host_get_name(after->host_list[1]), after->bytes_amount[2]); } } } } - /* Iterate over all children and parents being MXN_1D_BLOCK to say where I am - * located (and start them if runnable) */ + /* Iterate over all children and parents being MXN_1D_BLOCK to say where I am 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's Law", - SD_task_get_name(task), task->host_count, - task->flops_amount[0]); + XBT_VERB("Schedule computation task %s on %d workstations. %.f flops will be distributed following Amdahl's Law", + SD_task_get_name(task), task->host_count, task->flops_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->host_list){ - XBT_VERB("Sender side of Task %s is not scheduled yet", - SD_task_get_name(before)); + XBT_VERB("Sender side of Task %s is not scheduled yet", SD_task_get_name(before)); before->host_list = xbt_new0(sg_host_t, count); before->host_count = count; - XBT_VERB("Fill the workstation list with list of Task '%s'", - SD_task_get_name(task)); + XBT_VERB("Fill the workstation list with list of Task '%s'", SD_task_get_name(task)); for (i=0;ihost_list[i] = task->host_list[i]; } else { - XBT_VERB("Build communication matrix for task '%s'", - SD_task_get_name(before)); + 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->host_count; dst_nb = count; - before->host_list = (sg_host_t*) xbt_realloc( - before->host_list, - (before->host_count+count)*sizeof(sg_host_t)); + before->host_list = (sg_host_t*) xbt_realloc(before->host_list, (before->host_count+count)*sizeof(sg_host_t)); for(i=0; ihost_list[before->host_count+i] = - task->host_list[i]; + before->host_list[before->host_count+i] = task->host_list[i]; before->host_count += count; xbt_free(before->flops_amount); xbt_free(before->bytes_amount); - before->flops_amount = xbt_new0(double, - before->host_count); - before->bytes_amount = xbt_new0(double, - before->host_count* - before->host_count); + before->flops_amount = xbt_new0(double, before->host_count); + before->bytes_amount = xbt_new0(double, before->host_count* before->host_count); for(i=0;iamount/src_nb; @@ -1327,18 +1191,14 @@ void SD_task_schedulev(SD_task_t task, int count, for(j=0; jamount/dst_nb; dst_end = dst_start + before->amount/dst_nb; - XBT_VERB("(%s->%s): (%.2f, %.2f)-> (%.2f, %.2f)", - sg_host_get_name(before->host_list[i]), - sg_host_get_name(before->host_list[src_nb+j]), - src_start, src_end, dst_start, dst_end); + XBT_VERB("(%s->%s): (%.2f, %.2f)-> (%.2f, %.2f)", sg_host_get_name(before->host_list[i]), + sg_host_get_name(before->host_list[src_nb+j]), src_start, src_end, dst_start, dst_end); if ((src_end <= dst_start) || (dst_end <= src_start)) { before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0; } else { - before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j] = - MIN(src_end, dst_end) - MAX(src_start, dst_start); + before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j] = MIN(src_end, dst_end) - MAX(src_start, dst_start); } - XBT_VERB("==> %.2f", - before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]); + XBT_VERB("==> %.2f", before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]); } } @@ -1355,12 +1215,10 @@ 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->host_list){ - XBT_VERB("Receiver side of Task '%s' is not scheduled yet", - SD_task_get_name(after)); + XBT_VERB("Receiver side of Task '%s' is not scheduled yet", SD_task_get_name(after)); after->host_list = xbt_new0(sg_host_t, count); after->host_count = count; - XBT_VERB("Fill the workstation list with list of Task '%s'", - SD_task_get_name(task)); + XBT_VERB("Fill the workstation list with list of Task '%s'", SD_task_get_name(task)); for (i=0;ihost_list[i] = task->host_list[i]; } else { @@ -1368,9 +1226,7 @@ void SD_task_schedulev(SD_task_t task, int count, double src_start, src_end, dst_start, dst_end; src_nb = count; dst_nb = after->host_count; - after->host_list = (sg_host_t*) xbt_realloc( - after->host_list, - (after->host_count+count)*sizeof(sg_host_t)); + after->host_list = (sg_host_t*) xbt_realloc(after->host_list, (after->host_count+count)*sizeof(sg_host_t)); for(i=after->host_count - 1; i>=0; i--) after->host_list[count+i] = after->host_list[i]; for(i=0; ibytes_amount); after->flops_amount = xbt_new0(double, after->host_count); - after->bytes_amount = xbt_new0(double, - after->host_count* - after->host_count); + after->bytes_amount = xbt_new0(double, after->host_count* after->host_count); for(i=0;iamount/src_nb; @@ -1392,26 +1246,22 @@ void SD_task_schedulev(SD_task_t task, int count, for(j=0; jamount/dst_nb; dst_end = dst_start + after->amount/dst_nb; - XBT_VERB("(%d->%d): (%.2f, %.2f)-> (%.2f, %.2f)", - i, j, src_start, src_end, dst_start, dst_end); + XBT_VERB("(%d->%d): (%.2f, %.2f)-> (%.2f, %.2f)", i, j, src_start, src_end, dst_start, dst_end); if ((src_end <= dst_start) || (dst_end <= src_start)) { after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0; } else { - after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j] = - MIN(src_end, dst_end)- MAX(src_start, dst_start); + after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j] = MIN(src_end, dst_end)- MAX(src_start, dst_start); } - XBT_VERB("==> %.2f", - after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]); + XBT_VERB("==> %.2f", after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]); } } if (SD_task_get_state(after)< SD_SCHEDULED) { SD_task_do_schedule(after); - XBT_VERB - ("Auto-Schedule redistribution task %s. Send %.f bytes from %d hosts to %d hosts.", + XBT_VERB ("Auto-Schedule redistribution task %s. Send %.f bytes from %d hosts to %d hosts.", SD_task_get_name(after),after->amount, src_nb, dst_nb); } - } + } } } } @@ -1419,8 +1269,8 @@ void SD_task_schedulev(SD_task_t task, int count, /** @brief autoschedule a task on a list of workstations * - * This function is very similar to SD_task_schedulev(), - * but takes the list of workstations to schedule onto as separate parameters. + * This function is very similar to SD_task_schedulev(), but takes the list of workstations to schedule onto as + * separate parameters. * It builds a proper vector of workstations and then call SD_task_schedulev() */ void SD_task_schedulel(SD_task_t task, int count, ...) diff --git a/src/simdag/simdag_private.h b/src/simdag/simdag_private.h index 2c3355eb51..8f36906ee2 100644 --- a/src/simdag/simdag_private.h +++ b/src/simdag/simdag_private.h @@ -28,7 +28,6 @@ typedef struct SD_global { xbt_dynar_t completed_task_set; xbt_dynar_t return_set; - int task_number; } s_SD_global_t, *SD_global_t; -- 2.20.1