/* 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 <ctype.h>
-
#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 <ctype.h>
XBT_LOG_NEW_CATEGORY(surf, "All SURF categories");
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf,
{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
xbt_free(elm);
}
+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;
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);
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();
}
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();
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)
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) {
+ 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);
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.
+ *
+ */
+
+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);
}