#include "simix/smx_host_private.h"
#include "surf/surf_resource.h"
#include "xbt/xbt_os_thread.h"
+#include "simgrid/sg_config.h"
#include <ctype.h>
};
#endif /* #ifdef _XBT_WIN32 */
-int surf_cfg_get_int(const char* name)
-{
- return xbt_cfg_get_int(_surf_cfg_set,name);
-}
-double surf_cfg_get_double(const char* name)
-{
- return xbt_cfg_get_double(_surf_cfg_set,name);
-}
-char* surf_cfg_get_string(const char* name)
-{
- return xbt_cfg_get_string(_surf_cfg_set,name);
-}
-void surf_cfg_get_peer(const char *name, char **peer, int *port)
-{
- xbt_cfg_get_peer(_surf_cfg_set,name, peer, port);
-}
-xbt_dynar_t surf_cfg_get_dynar(const char* name)
-{
- return xbt_cfg_get_dynar(_surf_cfg_set,name);
-}
/*
* Returns the initial path. On Windows the initial path is
* the current directory for the current process in the other
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;
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 */
*ver_patch = SIMGRID_VERSION_PATCH;
}
-xbt_dynar_t sg_cmdline = NULL;
-
void surf_init(int *argc, char **argv)
{
XBT_DEBUG("Create all Libs");
SURF_WKS_LEVEL = xbt_lib_add_level(host_lib,surf_resource_free);
SURF_LINK_LEVEL = xbt_lib_add_level(link_lib,surf_resource_free);
- sg_cmdline = xbt_dynar_new(sizeof(char*),NULL);
- int i;
- for (i=0;i<*argc;i++) {
- xbt_dynar_push(sg_cmdline,&(argv[i]));
- }
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_active())
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) {
#endif
xbt_dynar_free(&surf_path);
- xbt_dynar_free(&sg_cmdline);
xbt_lib_free(&host_lib);
xbt_lib_free(&link_lib);
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;
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];
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,
resource->model->name, min);
resource->model->model_private->update_resource_state(resource,
event, value,
- NOW + min);
+ next_event_date);
}
} while (1);
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
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);
}
static void surf_update_actions_state(surf_model_t model)
{
- model->model_private->update_actions_state(NOW, min);
+ model->model_private->update_actions_state(model, 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.
+/* 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.
*
- * A value of 1 means no parallelism.
+ * 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)
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)
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);
}
