X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a6c262a93734a964f6aaaddf59d933398db660ff..c2e921f7dfe65fd24e5e797fcb37cba28401f9f9:/src/surf/surf.c diff --git a/src/surf/surf.c b/src/surf/surf.c index f4d1895b3e..5e5937ffaf 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,6 +9,7 @@ #include "surf_private.h" #include "xbt/module.h" #include "mc/mc.h" +#include "surf/surf_resource.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf, "Logging specific to SURF (kernel)"); @@ -112,67 +113,79 @@ 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}, - {"Vivaldi", "Scalable network model using the Vivaldi coordinate ideas", - NULL, surf_network_model_init_Vivaldi}, - {"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}, + "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", + "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, + {"Cas01_fullupdate", "CPU classical model time=size/power (Cas01). [Deprecated. Use Cas01 with option --cfg=cpu/optim:Full. The Full option updates all actions at every step, which may be useful for debug.]", 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}, + "Simplistic CPU model (time=size/power).", + surf_cpu_model_init_Cas01}, {"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 */ + "CPU classical model time=size/power (Cas01). [Deprecated. Use Cas01 with option --cfg=cpu/optim:TI. The TI optimization is highly optimized when using traces]", + surf_cpu_model_init_ti}, + {NULL, NULL, NULL} /* this array must be NULL terminated */ }; s_surf_model_description_t surf_workstation_model_description[] = { + {"current_default", + "Curent default workstation model (may change with versions of SimGrid). Currently Cas01 and LV08 (with full duplex support) as CPU and Network", + surf_workstation_model_init_current_default}, {"CLM03", - "Default workstation model, using LV08 and CM02 as network and CPU", - NULL, surf_workstation_model_init_CLM03, create_workstations}, + "Default workstation model, using Cas01 and CM02 as CPU and Network", + surf_workstation_model_init_CLM03}, {"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 */ +}; /** Displays the long description of all registered models, and quit */ void model_help(const char *category, s_surf_model_description_t * table) @@ -198,12 +211,12 @@ 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); } - xbt_assert2(0, "Model '%s' is invalid! Valid models are: %s.", name, - name_list); + xbt_die("Model '%s' is invalid! Valid models are: %s.", name, name_list); + return -1; } double generic_maxmin_share_resources(xbt_swag_t running_actions, @@ -216,7 +229,6 @@ double generic_maxmin_share_resources(xbt_swag_t running_actions, double value = -1; #define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + (offset)))) - xbt_assert0(solve, "Give me a real solver function!"); solve(sys); xbt_swag_foreach(action, running_actions) { @@ -250,15 +262,15 @@ double generic_maxmin_share_resources(xbt_swag_t running_actions, value = 0.0; if (value < min) { min = value; - DEBUG2("Updating min (value) with %p: %f", action, min); + XBT_DEBUG("Updating min (value) with %p: %f", action, min); } } if ((action->max_duration >= 0) && (action->max_duration < min)) { min = action->max_duration; - DEBUG2("Updating min (duration) with %p: %f", action, min); + XBT_DEBUG("Updating min (duration) with %p: %f", action, min); } } - DEBUG1("min value : %f", min); + XBT_DEBUG("min value : %f", min); #undef VARIABLE return min; @@ -283,6 +295,20 @@ 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); + /* Connect our log channels: that must be done manually under windows */ XBT_LOG_CONNECT(surf_cpu, surf); XBT_LOG_CONNECT(surf_kernel, surf); @@ -308,6 +334,7 @@ void surf_init(int *argc, char **argv) history = tmgr_history_new(); surf_config_init(argc, argv); + surf_action_init(); if (MC_IS_ENABLED) MC_memory_init(); } @@ -352,6 +379,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); @@ -361,13 +389,19 @@ void surf_exit(void) tmgr_history_free(history); history = NULL; } + surf_action_exit(); + + xbt_dynar_free(&surf_path); + + xbt_lib_free(&host_lib); + xbt_lib_free(&link_lib); + xbt_lib_free(&as_router_lib); - if (surf_path) - xbt_dynar_free(&surf_path); tmgr_finalize(); surf_parse_lex_destroy(); surf_parse_free_callbacks(); + NOW = 0; /* Just in case the user plans to restart the simulation afterward */ } @@ -380,7 +414,7 @@ void surf_presolve(void) surf_model_t model = NULL; unsigned int iter; - DEBUG0 + XBT_DEBUG ("First Run! Let's \"purge\" events and put models in the right state"); while ((next_event_date = tmgr_history_next_date(history)) != -1.0) { if (next_event_date > NOW) @@ -413,44 +447,68 @@ double surf_solve(double max_date) min = max_date - NOW; } - DEBUG0("Looking for next action end"); + XBT_DEBUG("Looking for next action end for all models except NS3"); xbt_dynar_foreach(model_list, iter, model) { - DEBUG1("Running for Resource [%s]", model->name); - model_next_action_end = model->model_private->share_resources(NOW); - DEBUG2("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(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; + } } - DEBUG1("Next action end : %f", min); - DEBUG0("Looking for next event"); - while ((next_event_date = tmgr_history_next_date(history)) != -1.0) { - DEBUG1("Next TRACE event : %f", next_event_date); - if ((min != -1.0) && (next_event_date > NOW + min)) - break; - DEBUG0("Updating models"); + XBT_DEBUG("Min for resources (except NS3) : %f", min); + + XBT_DEBUG("Looking for next trace event"); + + do { + XBT_DEBUG("Next TRACE event : %f", next_event_date); + + 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) 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, &value, (void **) &resource))) { if (resource->model->model_private->resource_used(resource)) { min = next_event_date - NOW; - DEBUG1 + XBT_DEBUG ("This event will modify model state. Next event set to %f", min); } /* update state of model_obj according to new value. Does not touch lmm. It will be modified if needed when updating actions */ - DEBUG2("Calling update_resource_state for resource %s with min %lf", + XBT_DEBUG("Calling update_resource_state for resource %s with min %lf", resource->model->name, min); resource->model->model_private->update_resource_state(resource, 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. * This may cause an infinite loop if one cpu has a trace with periodicity = 0 and the other a trace with periodicity > 0. @@ -458,17 +516,21 @@ double surf_solve(double max_date) if (min < 0.0) return -1.0; - DEBUG1("Duration set to %f", min); + 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); +#ifdef HAVE_TRACING + TRACE_paje_dump_buffer (0); +#endif + return min; } -double surf_get_clock(void) +XBT_INLINE double surf_get_clock(void) { return NOW; }