X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/f3dabc5eb26d7bc8b1e29b3aa52c74368c6bb699..97f3dfe883909ad3f75c9fab7aaaf1ddde0cd7f5:/src/surf/surf.c diff --git a/src/surf/surf.c b/src/surf/surf.c index bd4660229c..a4ef05aa17 100644 --- a/src/surf/surf.c +++ b/src/surf/surf.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team. +/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -9,11 +9,13 @@ #include "surf_private.h" #include "xbt/module.h" #include "mc/mc.h" +#include "surf/surf_resource.h" +#include "xbt/xbt_os_thread.h" 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 @@ -112,73 +114,90 @@ xbt_dynar_t surf_path = NULL; /* Don't forget to update the option description in smx_config when you change this */ s_surf_model_description_t surf_network_model_description[] = { - {"Constant", - "Simplistic network model where all communication take a constant time (one second)", - NULL, surf_network_model_init_Constant}, - {"CM02", - "Realistic network model with lmm_solve and no correction factors", - NULL, surf_network_model_init_CM02}, {"LV08", - "Realistic network model with lmm_solve and these correction factors: latency*=10.4, bandwidth*=.92, S=8775", - NULL, surf_network_model_init_LegrandVelho}, - {"LV08_im", - "Realistic network model with IMPROVED ACTION MANAGEMENT and these correction factors: latency*=10.4, bandwidth*=.92, S=8775", - NULL, im_surf_network_model_init_LegrandVelho}, + "Realistic network analytic model (slow-start modeled by multiplying latency by 10.4, bandwidth by .92; bottleneck sharing uses a payload of S=8775 for evaluating RTT). ", + surf_network_model_init_LegrandVelho}, + {"Constant", + "Simplistic network model where all communication take a constant time (one second). This model provides the lowest realism, but is (marginally) faster.", + surf_network_model_init_Constant}, {"SMPI", - "Realistic network model with lmm_solve and correction factors on three intervals (< 1KiB, < 64 KiB, >= 64 KiB)", - NULL, surf_network_model_init_SMPI}, + "Realistic network model specifically tailored for HPC settings (accurate modeling of slow start with correction factors on three intervals: < 1KiB, < 64 KiB, >= 64 KiB)", + surf_network_model_init_SMPI}, + {"CM02", + "Legacy network analytic model (Very similar to LV08, but without corrective factors. The timings of small messages are thus poorly modeled).", + surf_network_model_init_CM02}, #ifdef HAVE_GTNETS {"GTNets", - "Network Pseudo-model using the GTNets simulator instead of an analytic model", - NULL, surf_network_model_init_GTNETS}, + "Network pseudo-model using the GTNets simulator instead of an analytic model", + surf_network_model_init_GTNETS}, #endif #ifdef HAVE_NS3 {"NS3", - "TODO", - NULL, surf_network_model_init_NS3}, + "Network pseudo-model using the NS3 tcp model instead of an analytic model", + surf_network_model_init_NS3}, #endif {"Reno", - "Model using lagrange_solve instead of lmm_solve (experts only)", NULL, + "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).", surf_network_model_init_Reno}, {"Reno2", - "Model using lagrange_solve instead of lmm_solve (experts only)", NULL, + "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).", surf_network_model_init_Reno2}, {"Vegas", - "Model using lagrange_solve instead of lmm_solve (experts only)", NULL, + "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).", surf_network_model_init_Vegas}, - {NULL, NULL, NULL, NULL} /* this array must be NULL terminated */ + {NULL, NULL, NULL} /* this array must be NULL terminated */ }; s_surf_model_description_t surf_cpu_model_description[] = { - {"Cas01_fullupdate", "CPU classical model time=size/power", NULL, - surf_cpu_model_init_Cas01}, {"Cas01", - "Variation of Cas01_fullupdate with partial invalidation optimization of lmm system. Should produce the same values, only faster", - NULL, surf_cpu_model_init_Cas01_im}, - {"CpuTI", - "Variation of Cas01 with also trace integration. Should produce the same values, only faster if you use availability traces", - NULL, surf_cpu_model_init_ti}, - {NULL, NULL, NULL, NULL} /* this array must be NULL terminated */ + "Simplistic CPU model (time=size/power).", + surf_cpu_model_init_Cas01}, + {NULL, NULL, NULL} /* this array must be NULL terminated */ }; s_surf_model_description_t surf_workstation_model_description[] = { - {"CLM03", - "Default workstation model, using LV08 and CM02 as network and CPU", - NULL, surf_workstation_model_init_CLM03, create_workstations}, + {"default", + "Default workstation model. Currently, CPU:Cas01 and network:LV08 (with cross traffic enabled)", + surf_workstation_model_init_current_default}, {"compound", - "Workstation model allowing you to use other network and CPU models", - NULL, surf_workstation_model_init_compound, create_workstations}, - {"ptask_L07", "Workstation model with better parallel task modeling", - NULL, surf_workstation_model_init_ptask_L07, NULL}, - {NULL, NULL, NULL, NULL} /* this array must be NULL terminated */ + "Workstation model that is automatically chosen if you change the network and CPU models", + surf_workstation_model_init_compound}, + {"ptask_L07", "Workstation model somehow similar to Cas01+CM02 but allowing parallel tasks", + surf_workstation_model_init_ptask_L07}, + {NULL, NULL, NULL} /* this array must be NULL terminated */ }; -void update_model_description(s_surf_model_description_t * table, - const char *name, surf_model_t model) -{ - int i = find_model_description(table, name); - table[i].model = model; -} +s_surf_model_description_t surf_optimization_mode_description[] = { + {"Lazy", + "Lazy action management (partial invalidation in lmm + heap in action remaining).", + NULL}, + {"TI", + "Trace integration. Highly optimized mode when using availability traces (only available for the Cas01 CPU model for now).", + NULL}, + {"Full", + "Full update of remaining and variables. Slow but may be useful when debugging.", + NULL}, + {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 */ +}; + +#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) @@ -204,7 +223,7 @@ int find_model_description(s_surf_model_description_t * table, for (i = 1; table[i].name; i++) { name_list = xbt_realloc(name_list, - strlen(name_list) + strlen(table[i].name) + 2); + strlen(name_list) + strlen(table[i].name) + 3); strcat(name_list, ", "); strcat(name_list, table[i].name); } @@ -222,7 +241,6 @@ double generic_maxmin_share_resources(xbt_swag_t running_actions, double value = -1; #define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + (offset)))) - xbt_assert(solve, "Give me a real solver function!"); solve(sys); xbt_swag_foreach(action, running_actions) { @@ -289,19 +307,25 @@ XBT_LOG_EXTERNAL_CATEGORY(surf_network_gtnets); 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(); - - 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); + 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(); + + 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); + ROUTING_STORAGE_LEVEL = xbt_lib_add_level(storage_lib,xbt_free); + ROUTING_STORAGE_HOST_LEVEL = xbt_lib_add_level(storage_lib,routing_storage_host_free); + ROUTING_STORAGE_TYPE_LEVEL = xbt_lib_add_level(storage_type_lib,routing_storage_type_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); + SURF_STORAGE_LEVEL = xbt_lib_add_level(storage_lib,surf_resource_free); /* Connect our log channels: that must be done manually under windows */ XBT_LOG_CONNECT(surf_cpu, surf); @@ -373,6 +397,7 @@ void surf_exit(void) xbt_dynar_foreach(model_list, iter, model) model->model_private->finalize(); xbt_dynar_free(&model_list); + routing_exit(); if (maxmin_system) { lmm_system_free(maxmin_system); @@ -384,12 +409,19 @@ void surf_exit(void) } surf_action_exit(); - if (surf_path) - xbt_dynar_free(&surf_path); +#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); tmgr_finalize(); surf_parse_lex_destroy(); @@ -427,7 +459,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,23 +472,67 @@ double surf_solve(double max_date) min = max_date - NOW; } - XBT_DEBUG("Looking for next action end"); - xbt_dynar_foreach(model_list, iter, model) { - 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; + 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)); } - XBT_DEBUG("Next action end : %f", min); + surf_min_index = 0; - XBT_DEBUG("Looking for next event"); - while ((next_event_date = tmgr_history_next_date(history)) != -1.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); +#endif + } + 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++) { + 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 dont update that value) : %f", min); + + XBT_DEBUG("Looking for next trace event"); + + do { XBT_DEBUG("Next TRACE event : %f", next_event_date); - if ((min != -1.0) && (next_event_date > NOW + min)) - break; + + next_event_date = tmgr_history_next_date(history); + + if(surf_network_model->name && !strcmp(surf_network_model->name,"network NS3")){ + if(next_event_date!=-1.0 && min!=-1.0) { + min = MIN(next_event_date - NOW, min); + } else{ + min = MAX(next_event_date - NOW, min); + } + + XBT_DEBUG("Run for NS3 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); + 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 ((min != -1.0) && (next_event_date > NOW + min)) break; + XBT_DEBUG("Updating models"); while ((event = tmgr_history_get_next_event_leq(history, next_event_date, @@ -476,21 +552,32 @@ double surf_solve(double max_date) event, value, NOW + min); } - } + } while (1); - - /* FIXME: Moved this test to here to avoid stoping simulation if there are actions running on cpus and all cpus are with availability = 0. + /* FIXME: Moved this test to here to avoid stopping simulation if there are actions running on cpus and all cpus are with availability = 0. * 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 < 0.0) + if (min == -1.0) { + XBT_DEBUG("No next event at all. Bail out now."); return -1.0; + } XBT_DEBUG("Duration set to %f", min); 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); @@ -503,3 +590,58 @@ XBT_INLINE double surf_get_clock(void) { return NOW; } + +static void surf_share_resources(surf_model_t model) +{ + if (strcmp(model->name,"network NS3")) { + XBT_DEBUG("Running for Resource [%s]", model->name); + double next_action_end = model->model_private->share_resources(NOW); + XBT_DEBUG("Resource [%s] : next action end = %f", + model->name, next_action_end); + int i = __sync_fetch_and_add(&surf_min_index, 1); + 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; +}