X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/96f99f2c43f129472ec7603caef3e370be91e13e..3f17e7a2d9e727cf8ba2da354280f3afd329c8a6:/src/simdag/sd_global.c diff --git a/src/simdag/sd_global.c b/src/simdag/sd_global.c index 33149902df..2e5f3f3ecf 100644 --- a/src/simdag/sd_global.c +++ b/src/simdag/sd_global.c @@ -1,12 +1,23 @@ -#include "simdag/simdag.h" #include "private.h" #include "xbt/sysdep.h" #include "xbt/dynar.h" #include "surf/surf.h" +XBT_LOG_NEW_CATEGORY(sd,"Logging specific to SimDag"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_kernel,sd, + "Logging specific to SimDag (kernel)"); + SD_global_t sd_global = NULL; -/* Initialises SD internal data. This function should be called before any other SD function. +/** + * \brief Initialises SD internal data + * + * 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 + * \see SD_create_environment(), SD_exit() */ void SD_init(int *argc, char **argv) { xbt_assert0(sd_global == NULL, "SD_init already called"); @@ -15,11 +26,12 @@ void SD_init(int *argc, char **argv) { sd_global->workstations = xbt_dict_new(); sd_global->workstation_count = 0; sd_global->links = xbt_dict_new(); - sd_global->tasks = xbt_dynar_new(sizeof(SD_task_t), NULL); + sd_global->watch_point_reached = 0; s_SD_task_t task; sd_global->not_scheduled_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup)); sd_global->scheduled_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup)); + sd_global->ready_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup)); sd_global->running_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup)); sd_global->done_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup)); sd_global->failed_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup)); @@ -27,7 +39,23 @@ void SD_init(int *argc, char **argv) { surf_init(argc, argv); } -/* Creates the environnement described in a xml file of a platform description. +/** + * \brief Creates the environment + * + * The environment (i.e. the \ref SD_workstation_management "workstations" 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 SD_workstation_management, SD_link_management + * + * The XML file follows this DTD: + * + * \include surfxml.dtd + * + * Here is a small example of such a platform: + * + * \include small_platform.xml */ void SD_create_environment(const char *platform_file) { xbt_dict_cursor_t cursor = NULL; @@ -60,106 +88,106 @@ void SD_create_environment(const char *platform_file) { } } -/* Launches the simulation. Returns a NULL-terminated array of SD_task_t whose state has changed. +/** + * \brief Launches the simulation. + * + * The function will execute the \ref SD_READY ready tasks. + * The simulation will be stopped when its time reaches \a how_long, + * 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 + * \return a NULL-terminated array of \ref SD_task_t whose state has changed. + * \see SD_task_schedule(), SD_task_watch() */ SD_task_t* SD_simulate(double how_long) { - /* TODO */ - double total_time = 0.0; /* we stop the simulation when total_time >= how_long */ double elapsed_time = 0.0; - int watch_point_reached = 0; - int i; SD_task_t task; - surf_action_t surf_action; + surf_action_t action; + SD_task_t *changed_tasks = NULL; + int changed_task_number = 0; + int changed_task_capacity = 16; /* will be increased if necessary */ + + /* create the array that will be returned */ + changed_tasks = xbt_new0(SD_task_t, changed_task_capacity); + changed_tasks[0] = NULL; surf_solve(); /* Takes traces into account. Returns 0.0 */ + sd_global->watch_point_reached = 0; + /* main loop */ - while (elapsed_time >= 0.0 && total_time < how_long && !watch_point_reached) { - for (i = 0 ; i < xbt_dynar_length(sd_global->tasks); i++) { - xbt_dynar_get_cpy(sd_global->tasks, i, &task); - printf("Examining task '%s'...\n", SD_task_get_name(task)); - - /* if the task is scheduled and the dependencies are satisfied, - we can execute the task */ - if (SD_task_get_state(task) == SD_SCHEDULED) { - printf("Task '%s' is scheduled.\n", SD_task_get_name(task)); - - if (xbt_dynar_length(task->tasks_before) == 0) { - printf("The dependencies are satisfied. Executing task '%s'\n", SD_task_get_name(task)); - surf_action = __SD_task_run(task); - } - else { - printf("Cannot execute task '%s' because some depencies are not satisfied.\n", SD_task_get_name(task)); - } - } - else { - printf("Task '%s' is not scheduled. Nothing to do.\n", SD_task_get_name(task)); + while (elapsed_time >= 0.0 && total_time < how_long && !sd_global->watch_point_reached) { + + /* explore the ready tasks */ + xbt_swag_foreach(task, sd_global->ready_task_set) { + INFO1("Executing task '%s'", SD_task_get_name(task)); + task->state_changed = 0; + action = __SD_task_run(task); + surf_workstation_resource->common_public->action_set_data(action, task); + task->state_changed = 1; + + changed_tasks[changed_task_number++] = task; /* replace NULL by the task */ + if (changed_task_number == changed_task_capacity) { + changed_task_capacity *= 2; + changed_tasks = xbt_realloc(changed_tasks, sizeof(SD_task_t) * changed_task_capacity); } + changed_tasks[changed_task_number] = NULL; } + elapsed_time = surf_solve(); if (elapsed_time > 0.0) total_time += elapsed_time; - printf("Total time: %f\n", total_time); - } - - return NULL; -} -void SD_test() { - /* temporary test to explore the workstations and the links */ - xbt_dict_cursor_t cursor = NULL; - char *name = NULL; - SD_workstation_t workstation = NULL; - double power, available_power, bandwidth, latency; - SD_link_t link = NULL; - - surf_solve(); + /* let's see which tasks are done */ + while ((action = xbt_swag_extract(surf_workstation_resource->common_public->states.done_action_set))) { + task = action->data; + INFO1("Task '%s' done", SD_task_get_name(task)); + __SD_task_set_state(task, SD_DONE); + __SD_task_remove_dependencies(task); + if (!task->state_changed) { + task->state_changed = 1; + changed_tasks[changed_task_number++] = task; + } + } - xbt_dict_foreach(sd_global->workstations, cursor, name, workstation) { - power = SD_workstation_get_power(workstation); - available_power = SD_workstation_get_available_power(workstation); - printf("Workstation name: %s, power: %f Mflop/s, available power: %f%%\n", name, power, (available_power*100)); + /* let's see which tasks have just failed */ + while ((action = xbt_swag_extract(surf_workstation_resource->common_public->states.failed_action_set))) { + task = action->data; + INFO1("Task '%s' failed", SD_task_get_name(task)); + __SD_task_set_state(task, SD_FAILED); + if (!task->state_changed) { + task->state_changed = 1; + changed_tasks[changed_task_number++] = task; + } + } } - xbt_dict_foreach(sd_global->links, cursor, name, link) { - bandwidth = SD_link_get_current_bandwidth(link); - latency = SD_link_get_current_latency(link); - printf("Link name: %s, bandwidth: %f, latency: %f\n", name, bandwidth, latency); - } + INFO0("Simulation finished"); + INFO1("Number of tasks whose state has changed: %d", changed_task_number); - /* test the route between two workstations */ - SD_workstation_t src, dst; - xbt_dict_cursor_first(sd_global->workstations, &cursor); - xbt_dict_cursor_get_or_free(&cursor, &name, (void**) &src); - xbt_dict_cursor_step(cursor); - xbt_dict_cursor_get_or_free(&cursor, &name, (void**) &dst); - xbt_dict_cursor_free(&cursor); - - SD_link_t *route = SD_workstation_route_get_list(src, dst); - int route_size = SD_workstation_route_get_size(src, dst); - - printf("Route between %s and %s (%d links) : ", SD_workstation_get_name(src), SD_workstation_get_name(dst), route_size); - int i; - for (i = 0; i < route_size; i++) { - printf("%s ", SD_link_get_name(route[i])); - } - printf("\n"); + return changed_tasks; } -/* Destroys all SD internal data. This function should be called when the simulation is over. - * The tasks should have been destroyed first. +/** + * \brief Destroys all SD internal data. + * + * This function should be called when the simulation is over. Don't forget also to destroy + * the tasks. + * + * \see SD_init(), SD_task_destroy() */ -void SD_exit() { +void SD_exit(void) { if (sd_global != NULL) { xbt_dict_free(&sd_global->workstations); xbt_dict_free(&sd_global->links); - xbt_dynar_free(&sd_global->tasks); xbt_free(sd_global); xbt_swag_free(sd_global->not_scheduled_task_set); xbt_swag_free(sd_global->scheduled_task_set); + xbt_swag_free(sd_global->ready_task_set); xbt_swag_free(sd_global->running_task_set); xbt_swag_free(sd_global->done_task_set); xbt_swag_free(sd_global->failed_task_set);