X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6b188a3ca7fe91cf125a08229fb4fe51eee26e6d..a413f81990af8e4b725d3eb6712b885789a5121e:/src/surf/surf.c diff --git a/src/surf/surf.c b/src/surf/surf.c index a3a685c7c0..335351e2fe 100644 --- a/src/surf/surf.c +++ b/src/surf/surf.c @@ -4,17 +4,21 @@ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ -#include - #include "surf_private.h" #include "xbt/module.h" #include "mc/mc.h" +#include "simix/smx_host_private.h" #include "surf/surf_resource.h" +#include "xbt/xbt_os_thread.h" +#include "simgrid/sg_config.h" + +#include +XBT_LOG_NEW_CATEGORY(surf, "All SURF categories"); XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf, "Logging specific to SURF (kernel)"); -/* Additional declarations for Windows potability. */ +/* Additional declarations for Windows portability. */ #ifndef MAX_DRIVE #define MAX_DRIVE 26 @@ -133,7 +137,7 @@ s_surf_model_description_t surf_network_model_description[] = { #ifdef HAVE_NS3 {"NS3", "Network pseudo-model using the NS3 tcp model instead of an analytic model", - surf_network_model_init_NS3}, + surf_network_model_init_NS3}, #endif {"Reno", "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).", @@ -179,6 +183,35 @@ s_surf_model_description_t surf_optimization_mode_description[] = { {NULL, NULL, NULL} /* this array must be NULL terminated */ }; +s_surf_model_description_t surf_storage_model_description[] = { + {"default", + "Simplistic storage model.", + surf_storage_model_init_default}, + {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 */ + +static void surf_share_resources(surf_model_t model); +static void surf_update_actions_state(surf_model_t model); + /** Displays the long description of all registered models, and quit */ void model_help(const char *category, s_surf_model_description_t * table) { @@ -268,56 +301,116 @@ double generic_maxmin_share_resources(xbt_swag_t running_actions, return min; } -XBT_LOG_EXTERNAL_CATEGORY(surf_cpu); -XBT_LOG_EXTERNAL_CATEGORY(surf_kernel); -XBT_LOG_EXTERNAL_CATEGORY(surf_lagrange); -XBT_LOG_EXTERNAL_CATEGORY(surf_lagrange_dichotomy); -XBT_LOG_EXTERNAL_CATEGORY(surf_maxmin); -XBT_LOG_EXTERNAL_CATEGORY(surf_network); -XBT_LOG_EXTERNAL_CATEGORY(surf_trace); -XBT_LOG_EXTERNAL_CATEGORY(surf_parse); -XBT_LOG_EXTERNAL_CATEGORY(surf_timer); -XBT_LOG_EXTERNAL_CATEGORY(surf_workstation); -XBT_LOG_EXTERNAL_CATEGORY(surf_config); -XBT_LOG_EXTERNAL_CATEGORY(surf_route); +double generic_share_resources_lazy(double now, surf_model_t model) +{ + surf_action_lmm_t action = NULL; + double min = -1; + double value; -#ifdef HAVE_GTNETS -XBT_LOG_EXTERNAL_CATEGORY(surf_network_gtnets); -#endif + XBT_DEBUG + ("Before share resources, the size of modified actions set is %d", + xbt_swag_size(model->model_private->modified_set)); -void surf_init(int *argc, char **argv) + lmm_solve(model->model_private->maxmin_system); + + XBT_DEBUG + ("After share resources, The size of modified actions set is %d", + xbt_swag_size(model->model_private->modified_set)); + + while((action = xbt_swag_extract(model->model_private->modified_set))) { + int max_dur_flag = 0; + + if (action->generic_action.state_set != + model->states.running_action_set) + continue; + + /* bogus priority, skip it */ + if (action->generic_action.priority <= 0) + continue; + + generic_update_action_remaining_lazy(action,now); + + min = -1; + value = lmm_variable_getvalue(action->variable); + if (value > 0) { + if (action->generic_action.remains > 0) { + value = action->generic_action.remains / value; + min = now + value; + } else { + value = 0.0; + min = now; + } + } + + if ((action->generic_action.max_duration != NO_MAX_DURATION) + && (min == -1 + || action->generic_action.start + + action->generic_action.max_duration < min)) { + min = action->generic_action.start + + action->generic_action.max_duration; + max_dur_flag = 1; + } + + XBT_DEBUG("Action(%p) Start %lf Finish %lf Max_duration %lf", action, + action->generic_action.start, now + value, + action->generic_action.max_duration); + + if (min != -1) { + surf_action_lmm_heap_remove(model->model_private->action_heap,action); + surf_action_lmm_heap_insert(model->model_private->action_heap,action, min, max_dur_flag ? MAX_DURATION : NORMAL); + XBT_DEBUG("Insert at heap action(%p) min %lf now %lf", action, min, + now); + } else DIE_IMPOSSIBLE; + } + + //hereafter must have already the min value for this resource model + if (xbt_heap_size(model->model_private->action_heap) > 0) + min = xbt_heap_maxkey(model->model_private->action_heap) - now; + else + min = -1; + + XBT_DEBUG("The minimum with the HEAP %lf", min); + + return min; +} +static XBT_INLINE void routing_asr_host_free(void *p) { - XBT_DEBUG("Create all Libs"); - host_lib = xbt_lib_new(); - link_lib = xbt_lib_new(); - as_router_lib = xbt_lib_new(); - - XBT_DEBUG("ADD ROUTING LEVEL"); - ROUTING_HOST_LEVEL = xbt_lib_add_level(host_lib,xbt_free); - ROUTING_ASR_LEVEL = xbt_lib_add_level(as_router_lib,xbt_free); - - XBT_DEBUG("ADD SURF LEVELS"); - SURF_CPU_LEVEL = xbt_lib_add_level(host_lib,surf_resource_free); - SURF_WKS_LEVEL = xbt_lib_add_level(host_lib,surf_resource_free); - SURF_LINK_LEVEL = xbt_lib_add_level(link_lib,surf_resource_free); - - /* Connect our log channels: that must be done manually under windows */ - XBT_LOG_CONNECT(surf_cpu, surf); - XBT_LOG_CONNECT(surf_kernel, surf); - XBT_LOG_CONNECT(surf_lagrange, surf); - XBT_LOG_CONNECT(surf_lagrange_dichotomy, surf_lagrange); - XBT_LOG_CONNECT(surf_maxmin, surf); - XBT_LOG_CONNECT(surf_network, surf); - XBT_LOG_CONNECT(surf_trace, surf); - XBT_LOG_CONNECT(surf_parse, surf); - XBT_LOG_CONNECT(surf_timer, surf); - XBT_LOG_CONNECT(surf_workstation, surf); - XBT_LOG_CONNECT(surf_config, surf); - XBT_LOG_CONNECT(surf_route, surf); + sg_routing_edge_t elm = p; + free(elm->name); + xbt_free(elm); +} -#ifdef HAVE_GTNETS - XBT_LOG_CONNECT(surf_network_gtnets, surf); -#endif +static XBT_INLINE void routing_asr_prop_free(void *p) +{ + xbt_dict_t elm = p; + xbt_dict_free(&elm); +} + +void sg_version(int *ver_major,int *ver_minor,int *ver_patch) { + *ver_major = SIMGRID_VERSION_MAJOR; + *ver_minor = SIMGRID_VERSION_MINOR; + *ver_patch = SIMGRID_VERSION_PATCH; +} + +void surf_init(int *argc, char **argv) +{ + XBT_DEBUG("Create all Libs"); + host_lib = xbt_lib_new(); + link_lib = xbt_lib_new(); + as_router_lib = xbt_lib_new(); + storage_lib = xbt_lib_new(); + storage_type_lib = xbt_lib_new(); + watched_hosts_lib = xbt_dict_new(); + + XBT_DEBUG("Add routing levels"); + ROUTING_HOST_LEVEL = xbt_lib_add_level(host_lib,routing_asr_host_free); + ROUTING_ASR_LEVEL = xbt_lib_add_level(as_router_lib,routing_asr_host_free); + ROUTING_PROP_ASR_LEVEL = xbt_lib_add_level(as_router_lib,routing_asr_prop_free); + + XBT_DEBUG("Add SURF levels"); + SURF_CPU_LEVEL = xbt_lib_add_level(host_lib,surf_resource_free); + SURF_WKS_LEVEL = xbt_lib_add_level(host_lib,surf_resource_free); + SURF_LINK_LEVEL = xbt_lib_add_level(link_lib,surf_resource_free); xbt_init(argc, argv); if (!model_list) @@ -325,9 +418,15 @@ void surf_init(int *argc, char **argv) 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(); } @@ -366,7 +465,7 @@ 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(); @@ -383,12 +482,21 @@ void surf_exit(void) } surf_action_exit(); +#ifdef CONTEXT_THREADS + xbt_parmap_destroy(surf_parmap); + xbt_free(surf_mins); + surf_mins = NULL; +#endif + xbt_dynar_free(&surf_path); xbt_lib_free(&host_lib); xbt_lib_free(&link_lib); xbt_lib_free(&as_router_lib); + xbt_lib_free(&storage_lib); + xbt_lib_free(&storage_type_lib); + xbt_dict_free(&watched_hosts_lib); tmgr_finalize(); surf_parse_lex_destroy(); @@ -415,9 +523,11 @@ 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); + } } } xbt_dynar_foreach(model_list, iter, model) @@ -426,7 +536,7 @@ void surf_presolve(void) double surf_solve(double max_date) { - double min = -1.0; /* duration */ + min = -1.0; /* duration */ double next_event_date = -1.0; double model_next_action_end = -1.0; double value = -1.0; @@ -440,19 +550,37 @@ double surf_solve(double max_date) } XBT_DEBUG("Looking for next action end for all models except NS3"); - xbt_dynar_foreach(model_list, iter, model) { - if(strcmp(model->name,"network NS3") ){ - XBT_DEBUG("Running for Resource [%s]", model->name); - model_next_action_end = model->model_private->share_resources(NOW); - XBT_DEBUG("Resource [%s] : next action end = %f", - model->name, model_next_action_end); - if (((min < 0.0) || (model_next_action_end < min)) - && (model_next_action_end >= 0.0)) - min = model_next_action_end; + + if (surf_mins == NULL) { + surf_mins = xbt_new(double, xbt_dynar_length(model_list)); + } + 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 + } + else { + /* sequential version */ + xbt_dynar_foreach(model_list, iter, model) { + surf_share_resources(model); } } - XBT_DEBUG("Min for resources (remember that NS3 dont update that value) : %f", min); + unsigned i; + for (i = 0; i < xbt_dynar_length(model_list); i++) { + if ((min < 0.0 || surf_mins[i] < min) + && surf_mins[i] >= 0.0) { + min = surf_mins[i]; + } + } + + XBT_DEBUG("Min for resources (remember that NS3 don't update that value) : %f", min); XBT_DEBUG("Looking for next trace event"); @@ -468,21 +596,21 @@ 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); - 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) { - XBT_DEBUG("no next TRACE event. Stop searching for it"); - break; + 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"); while ((event = @@ -509,7 +637,7 @@ double surf_solve(double max_date) * This may cause an infinite loop if one cpu has a trace with periodicity = 0 and the other a trace with periodicity > 0. * The options are: all traces with same periodicity(0 or >0) or we need to change the way how the events are managed */ if (min == -1.0) { - XBT_DEBUG("No next event at all. Bail out now."); + XBT_DEBUG("No next event at all. Bail out now."); return -1.0; } @@ -517,8 +645,18 @@ double surf_solve(double max_date) NOW = NOW + min; - xbt_dynar_foreach(model_list, iter, model) - model->model_private->update_actions_state(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); + } + } #ifdef HAVE_TRACING TRACE_paje_dump_buffer (0); @@ -531,3 +669,105 @@ XBT_INLINE double surf_get_clock(void) { return NOW; } + +static void surf_share_resources(surf_model_t model) +{ + double next_action_end = -1.0; + 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); + XBT_DEBUG("Resource [%s] : next action end = %f", + model->name, next_action_end); + } + surf_mins[i] = next_action_end; +} + +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; +} + +/** + * \brief Sets the number of parallel threads used to update the models. + * + * A value of 1 means no parallelism. + * + * \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; +} + +/* This function is a pimple that we ought to fix. But it won't be easy. + * + * 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. + * + */ +void surf_watched_hosts(void) +{ + char *key; + void *host; + xbt_dict_cursor_t cursor; + + XBT_DEBUG("Check for host SURF_RESOURCE_ON on watched_hosts_lib"); + xbt_dict_foreach(watched_hosts_lib,cursor,key,host) + { + 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); + } + else + XBT_DEBUG("See SURF_RESOURCE_OFF on host: %s",key); + } +}