X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/975babad32bf69ffb339dc1d449cd85e111ba733..9bbf0601aa9af6089fdcfc0fd09bfdf64382705c:/src/surf/surf.c diff --git a/src/surf/surf.c b/src/surf/surf.c index 5fb7317eaa..157cbe2639 100644 --- a/src/surf/surf.c +++ b/src/surf/surf.c @@ -10,6 +10,7 @@ #include "simix/smx_host_private.h" #include "surf/surf_resource.h" #include "xbt/xbt_os_thread.h" +#include "simgrid/sg_config.h" #include @@ -109,7 +110,11 @@ int __surf_is_absolute_file_path(const char *file_path) double NOW = 0; -xbt_dynar_t model_list = NULL; +/* model_list_invoke contains only surf_workstation and surf_vm_workstation. + * The callback functions of cpu_model and network_model will be called from + * those of these workstation models. */ +xbt_dynar_t model_list = NULL; /* for destroying all models correctly */ +xbt_dynar_t model_list_invoke = NULL; /* for invoking callbacks */ tmgr_history_t history = NULL; lmm_system_t maxmin_system = NULL; xbt_dynar_t surf_path = NULL; @@ -189,11 +194,20 @@ s_surf_model_description_t surf_storage_model_description[] = { {NULL, NULL, NULL} /* this array must be NULL terminated */ }; +/* ********************************************************************* */ +/* TUTORIAL: New model */ +s_surf_model_description_t surf_new_model_description[] = { + {"default", + "Tutorial model.", + surf_new_model_init_default}, + {NULL, NULL, NULL} /* this array must be NULL terminated */ +}; +/* ********************************************************************* */ + #ifdef CONTEXT_THREADS static xbt_parmap_t surf_parmap = NULL; /* parallel map on models */ #endif -static int surf_nthreads = 1; /* number of threads of the parmap (1 means no parallelism) */ static double *surf_mins = NULL; /* return value of share_resources for each model */ static int surf_min_index; /* current index in surf_mins */ static double min; /* duration determined by surf_solve */ @@ -404,12 +418,20 @@ void surf_init(int *argc, char **argv) xbt_init(argc, argv); if (!model_list) model_list = xbt_dynar_new(sizeof(surf_model_private_t), NULL); + if (!model_list_invoke) + model_list_invoke = xbt_dynar_new(sizeof(surf_model_private_t), NULL); if (!history) history = tmgr_history_new(); - surf_config_init(argc, argv); +#ifdef HAVE_TRACING + TRACE_add_start_function(TRACE_surf_alloc); + TRACE_add_end_function(TRACE_surf_release); +#endif + + sg_config_init(argc, argv); + surf_action_init(); - if (MC_IS_ENABLED) + if (MC_is_active()) MC_memory_init(); } @@ -448,11 +470,14 @@ void surf_exit(void) unsigned int iter; surf_model_t model = NULL; - surf_config_finalize(); + sg_config_finalize(); xbt_dynar_foreach(model_list, iter, model) - model->model_private->finalize(); + model->model_private->finalize(model); xbt_dynar_free(&model_list); + + xbt_dynar_free(&model_list_invoke); + routing_exit(); if (maxmin_system) { @@ -506,17 +531,22 @@ void surf_presolve(void) tmgr_history_get_next_event_leq(history, next_event_date, &value, (void **) &resource))) { - resource->model->model_private->update_resource_state(resource, - event, value, - NOW); + if (value >= 0){ + resource->model->model_private->update_resource_state(resource, + event, value, + NOW); + } } } + + /* FIXME: see what is check_update_action_state(). if necessary, use model_list_invoke. */ xbt_dynar_foreach(model_list, iter, model) - model->model_private->update_actions_state(NOW, 0.0); + model->model_private->update_actions_state(model, NOW, 0.0); } double surf_solve(double max_date) { + min = -1.0; /* duration */ double next_event_date = -1.0; double model_next_action_end = -1.0; @@ -533,28 +563,16 @@ double surf_solve(double max_date) XBT_DEBUG("Looking for next action end for all models except NS3"); if (surf_mins == NULL) { - surf_mins = xbt_new(double, xbt_dynar_length(model_list)); + surf_mins = xbt_new(double, xbt_dynar_length(model_list_invoke)); } surf_min_index = 0; - - if (surf_get_nthreads() > 1) { - /* parallel version */ -#ifdef CONTEXT_THREADS - xbt_parmap_apply(surf_parmap, (void_f_pvoid_t) surf_share_resources, model_list); -#else - xbt_die("Asked to run in parallel, but no thread at hand..."); -#endif + /* sequential version */ + xbt_dynar_foreach(model_list_invoke, iter, model) { + surf_share_resources(model); } - else { - /* sequential version */ - xbt_dynar_foreach(model_list, iter, model) { - surf_share_resources(model); - } - } - unsigned i; - for (i = 0; i < xbt_dynar_length(model_list); i++) { + for (i = 0; i < xbt_dynar_length(model_list_invoke); i++) { if ((min < 0.0 || surf_mins[i] < min) && surf_mins[i] >= 0.0) { min = surf_mins[i]; @@ -577,23 +595,23 @@ double surf_solve(double max_date) min = MAX(next_event_date - NOW, min); } - XBT_DEBUG("Run for NS3 at most %f", min); + XBT_DEBUG("Run for network at most %f", min); // run until min or next flow - model_next_action_end = surf_network_model->model_private->share_resources(min); + model_next_action_end = surf_network_model->model_private->share_resources(surf_network_model, min); - XBT_DEBUG("Min for NS3 : %f", model_next_action_end); + XBT_DEBUG("Min for network : %f", model_next_action_end); if(model_next_action_end>=0.0) min = model_next_action_end; } - if (next_event_date == -1.0) { + if (next_event_date < 0.0) { XBT_DEBUG("no next TRACE event. Stop searching for it"); break; } - if ((min != -1.0) && (next_event_date > NOW + min)) break; + if ((min == -1.0) || (next_event_date > NOW + min)) break; - XBT_DEBUG("Updating models"); + XBT_DEBUG("Updating models (min = %g, NOW = %g, next_event_date = %g)",min, NOW, next_event_date); while ((event = tmgr_history_get_next_event_leq(history, next_event_date, &value, @@ -610,7 +628,7 @@ double surf_solve(double max_date) resource->model->name, min); resource->model->model_private->update_resource_state(resource, event, value, - NOW + min); + next_event_date); } } while (1); @@ -625,18 +643,10 @@ double surf_solve(double max_date) XBT_DEBUG("Duration set to %f", min); NOW = NOW + min; - - if (surf_get_nthreads() > 1) { - /* parallel version */ -#ifdef CONTEXT_THREADS - xbt_parmap_apply(surf_parmap, (void_f_pvoid_t) surf_update_actions_state, model_list); -#endif - } - else { - /* sequential version */ - xbt_dynar_foreach(model_list, iter, model) { - surf_update_actions_state(model); - } + /* FIXME: model_list or model_list_invoke? revisit here later */ + /* sequential version */ + xbt_dynar_foreach(model_list, iter, model) { + surf_update_actions_state(model); } #ifdef HAVE_TRACING @@ -657,7 +667,7 @@ static void surf_share_resources(surf_model_t model) int i = __sync_fetch_and_add(&surf_min_index, 1); if (strcmp(model->name,"network NS3")) { XBT_DEBUG("Running for Resource [%s]", model->name); - next_action_end = model->model_private->share_resources(NOW); + next_action_end = model->model_private->share_resources(model, NOW); XBT_DEBUG("Resource [%s] : next action end = %f", model->name, next_action_end); } @@ -666,45 +676,40 @@ static void surf_share_resources(surf_model_t model) static void surf_update_actions_state(surf_model_t model) { - model->model_private->update_actions_state(NOW, min); -} - -/** - * \brief Returns the number of parallel threads used to update the models. - * \return the number of threads (1 means no parallelism) - */ -int surf_get_nthreads(void) { - return surf_nthreads; + model->model_private->update_actions_state(model, NOW, min); } -/** - * \brief Sets the number of parallel threads used to update the models. +/* This function is a pimple that we ought to fix. But it won't be easy. * - * A value of 1 means no parallelism. + * The surf_solve() function does properly return the set of actions that changed. + * Instead, each model change a global data, and then the caller of surf_solve must + * pick into these sets of action_failed and action_done. + * + * This was not clean but ok as long as we didn't had to restart the processes when the resource comes back up. + * We worked by putting sentinel actions on every resources we are interested in, + * so that surf informs us if/when the corresponding resource fails. + * + * But this does not work to get Simix informed of when a resource comes back up, and this is where this pimple comes. + * We have a set of resources that are currently down and for which simix needs to know when it comes back up. + * And the current function is called *at every simulation step* to sweep over that set, searching for a resource + * that was turned back up in the meanwhile. This is UGLY and slow. + * + * The proper solution would be to not rely on globals for the action_failed and action_done swags. + * They must be passed as parameter by the caller (the handling of these actions in simix may let you + * think that these two sets can be merged, but their handling in SimDag induce the contrary unless this + * simdag code can check by itself whether the action is done of failed -- seems very doable, but yet more + * cleanup to do). + * + * Once surf_solve() is passed the set of actions that changed, you want to add a new set of resources back up + * as parameter to this function. You also want to add a boolean field "restart_watched" to each resource, and + * make sure that whenever a resource with this field enabled comes back up, it's added to that set so that Simix + * sees it and react accordingly. This would kill that need for surf to call simix. * - * \param nb_threads the number of threads to use */ -void surf_set_nthreads(int nthreads) { - - if (nthreads<=0) { - nthreads = xbt_os_get_numcores(); - XBT_INFO("Auto-setting surf/nthreads to %d",nthreads); - } - -#ifdef CONTEXT_THREADS - xbt_parmap_destroy(surf_parmap); - surf_parmap = NULL; -#endif - if (nthreads > 1) { -#ifdef CONTEXT_THREADS - surf_parmap = xbt_parmap_new(nthreads, XBT_PARMAP_DEFAULT); -#else - THROWF(arg_error, 0, "Cannot activate parallel threads in Surf: your architecture does not support threads"); -#endif - } - - surf_nthreads = nthreads; +static void remove_watched_host(void *key) +{ + xbt_dict_remove(watched_hosts_lib, *(char**)key); } void surf_watched_hosts(void) @@ -712,6 +717,7 @@ void surf_watched_hosts(void) char *key; void *host; xbt_dict_cursor_t cursor; + xbt_dynar_t hosts = xbt_dynar_new(sizeof(char*), NULL); XBT_DEBUG("Check for host SURF_RESOURCE_ON on watched_hosts_lib"); xbt_dict_foreach(watched_hosts_lib,cursor,key,host) @@ -719,9 +725,11 @@ void surf_watched_hosts(void) if(SIMIX_host_get_state(host) == SURF_RESOURCE_ON){ XBT_INFO("Restart processes on host: %s",SIMIX_host_get_name(host)); SIMIX_host_autorestart(host); - xbt_dict_remove(watched_hosts_lib,key); + xbt_dynar_push_as(hosts, char*, key); } else XBT_DEBUG("See SURF_RESOURCE_OFF on host: %s",key); } + xbt_dynar_map(hosts, remove_watched_host); + xbt_dynar_free(&hosts); }