#include "network_interface.hpp"
#include "cpu_interface.hpp"
#include "host_interface.hpp"
-#include "simix/smx_host_private.h"
+#include "src/simix/smx_host_private.h"
#include "surf_routing.hpp"
#include "simgrid/sg_config.h"
#include "mc/mc.h"
-#include "vm_interface.hpp"
+#include "virtual_machine.hpp"
XBT_LOG_NEW_CATEGORY(surf, "All SURF categories");
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf,
* Utils *
*********/
-/* 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((smx_host_t)host) == SURF_RESOURCE_ON){
- XBT_INFO("Restart processes on host: %s", SIMIX_host_get_name((smx_host_t)host));
- SIMIX_host_autorestart((smx_host_t)host);
- 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);
-}*/
-
/* model_list_invoke contains only surf_host and surf_vm.
* The callback functions of cpu_model and network_model will be called from
* those of these host models. */
-xbt_dynar_t model_list = NULL; /* for destroying all models correctly */
+xbt_dynar_t all_existing_models = NULL; /* to destroy models correctly */
xbt_dynar_t model_list_invoke = NULL; /* for invoking callbacks */
tmgr_history_t history = NULL;
xbt_dynar_t host_that_restart = NULL;
xbt_dict_t watched_hosts_lib;
-surf_callback(void, void) surfExitCallbacks;
+namespace simgrid {
+namespace surf {
+
+simgrid::surf::signal<void(void)> surfExitCallbacks;
+
+}
+}
s_surf_model_description_t surf_plugin_description[] = {
{"Energy", "Cpu energy consumption.", sg_energy_plugin_init},
//xbt_dict_free(&elm); FIXME: leaking in some case? That's a sometimes double-free with AsCluster::~AsCluster
}
-static XBT_INLINE void surf_host_free(void *r)
-{
- delete static_cast<Host*>(r);
-}
-
static XBT_INLINE void surf_storage_free(void *r)
{
- delete static_cast<Storage*>(r);
+ delete static_cast<simgrid::surf::Storage*>(r);
}
void sg_version_check(int lib_version_major,int lib_version_minor,int lib_version_patch) {
void surf_init(int *argc, char **argv)
{
XBT_DEBUG("Create all Libs");
- host_lib = xbt_lib_new();
+ host_list = xbt_dict_new_homogeneous([](void*p) {
+ delete static_cast<simgrid::Host*>(p);
+ });
as_router_lib = xbt_lib_new();
storage_lib = xbt_lib_new();
storage_type_lib = xbt_lib_new();
ROUTING_PROP_ASR_LEVEL = xbt_lib_add_level(as_router_lib,routing_asr_prop_free);
XBT_DEBUG("Add SURF levels");
- SURF_HOST_LEVEL = xbt_lib_add_level(host_lib,surf_host_free);
SURF_STORAGE_LEVEL = xbt_lib_add_level(storage_lib,surf_storage_free);
xbt_init(argc, argv);
- if (!model_list)
- model_list = xbt_dynar_new(sizeof(Model*), NULL);
+ if (!all_existing_models)
+ all_existing_models = xbt_dynar_new(sizeof(simgrid::surf::Model*), NULL);
if (!model_list_invoke)
- model_list_invoke = xbt_dynar_new(sizeof(Model*), NULL);
+ model_list_invoke = xbt_dynar_new(sizeof(simgrid::surf::Model*), NULL);
if (!history)
history = tmgr_history_new();
void surf_exit(void)
{
unsigned int iter;
- Model *model = NULL;
+ simgrid::surf::Model *model = NULL;
TRACE_end(); /* Just in case it was not called by the upper
* layer (or there is no upper layer) */
xbt_dynar_free(&host_that_restart);
xbt_dynar_free(&surf_path);
- xbt_lib_free(&host_lib);
+ xbt_dict_free(&host_list);
xbt_lib_free(&as_router_lib);
xbt_lib_free(&storage_lib);
sg_link_exit();
xbt_lib_free(&file_lib);
xbt_dict_free(&watched_hosts_lib);
- xbt_dynar_foreach(model_list, iter, model)
+ xbt_dynar_foreach(all_existing_models, iter, model)
delete model;
- xbt_dynar_free(&model_list);
+ xbt_dynar_free(&all_existing_models);
xbt_dynar_free(&model_list_invoke);
routing_exit();
- surf_callback_emit(surfExitCallbacks);
+ simgrid::surf::surfExitCallbacks();
if (maxmin_system) {
lmm_system_free(maxmin_system);
* Model *
*********/
+namespace simgrid {
+namespace surf {
+
Model::Model()
: p_maxminSystem(NULL)
{
THROW_UNIMPLEMENTED;
}
+}
+}
+
/************
* Resource *
************/
+namespace simgrid {
+namespace surf {
+
Resource::Resource()
-: p_name(NULL), p_properties(NULL), p_model(NULL)
+: p_name(NULL), p_model(NULL)
{}
-Resource::Resource(Model *model, const char *name, xbt_dict_t props)
- : p_name(xbt_strdup(name)), p_properties(props), p_model(model)
- , m_running(true), m_stateCurrent(SURF_RESOURCE_ON)
+Resource::Resource(Model *model, const char *name)
+ : Resource(model, name, SURF_RESOURCE_ON)
{}
-Resource::Resource(Model *model, const char *name, xbt_dict_t props, lmm_constraint_t constraint)
- : p_name(xbt_strdup(name)), p_properties(props), p_model(model)
- , m_running(true), m_stateCurrent(SURF_RESOURCE_ON), p_constraint(constraint)
+Resource::Resource(Model *model, const char *name, lmm_constraint_t constraint)
+ : Resource(model, name, constraint, SURF_RESOURCE_ON)
+{}
+
+Resource::Resource(
+ Model *model, const char *name,
+ lmm_constraint_t constraint, e_surf_resource_state_t stateInit)
+ : p_name(xbt_strdup(name)), p_model(model)
+ , m_running(true), m_stateCurrent(stateInit), p_constraint(constraint)
{}
-Resource::Resource(Model *model, const char *name, xbt_dict_t props, e_surf_resource_state_t stateInit)
- : p_name(xbt_strdup(name)), p_properties(props), p_model(model)
+Resource::Resource(Model *model, const char *name, e_surf_resource_state_t stateInit)
+ : p_name(xbt_strdup(name)), p_model(model)
, m_running(true), m_stateCurrent(stateInit)
{}
+
Resource::~Resource() {
xbt_free((void*)p_name);
- xbt_dict_free(&p_properties);
}
e_surf_resource_state_t Resource::getState()
return p_name;
}
-xbt_dict_t Resource::getProperties() {
- if (p_properties==NULL)
- p_properties = xbt_dict_new();
- return p_properties;
-}
-
lmm_constraint_t Resource::getConstraint() {
return p_constraint;
}
+}
+}
+
/**********
* Action *
**********/
"SURF_ACTION_NOT_IN_THE_SYSTEM"
};
-void Action::initialize(Model *model, double cost, bool failed,
+/* added to manage the communication action's heap */
+void surf_action_lmm_update_index_heap(void *action, int i) {
+ static_cast<simgrid::surf::Action*>(action)->updateIndexHeap(i);
+}
+
+namespace simgrid {
+namespace surf {
+
+void Action::initialize(simgrid::surf::Model *model, double cost, bool failed,
lmm_variable_t var)
{
- m_priority = 1.0;
- m_refcount = 1;
m_remains = cost;
- m_maxDuration = NO_MAX_DURATION;
- m_finish = -1.0;
m_start = surf_get_clock();
m_cost = cost;
p_model = model;
- p_data = NULL;
p_variable = var;
- m_lastValue = 0;
- m_lastUpdate = 0;
- m_suspended = false;
- m_hat = NOTSET;
- p_category = NULL;
- p_stateHookup.prev = 0;
- p_stateHookup.next = 0;
if (failed)
p_stateSet = getModel()->getFailedActionSet();
else
p_stateSet->push_back(*this);
}
-Action::Action(Model *model, double cost, bool failed)
+Action::Action(simgrid::surf::Model *model, double cost, bool failed)
{
initialize(model, cost, failed);
}
-Action::Action(Model *model, double cost, bool failed, lmm_variable_t var)
+Action::Action(simgrid::surf::Model *model, double cost, bool failed, lmm_variable_t var)
{
initialize(model, cost, failed, var);
}
}
}
-/* added to manage the communication action's heap */
-void surf_action_lmm_update_index_heap(void *action, int i) {
- static_cast<Action*>(action)->updateIndexHeap(i);
-}
-
void Action::updateIndexHeap(int i) {
m_indexHeap = i;
}
double_update(&m_remains, m_lastValue * delta, sg_surf_precision*sg_maxmin_precision);
if (getModel() == surf_cpu_model_pm && TRACE_is_enabled()) {
- Resource *cpu = static_cast<Resource*>(lmm_constraint_id(lmm_get_cnst_from_var(getModel()->getMaxminSystem(), getVariable(), 0)));
+ simgrid::surf::Resource *cpu = static_cast<simgrid::surf::Resource*>(
+ lmm_constraint_id(lmm_get_cnst_from_var(getModel()->getMaxminSystem(), getVariable(), 0)));
TRACE_surf_host_set_utilization(cpu->getName(), getCategory(), m_lastValue, m_lastUpdate, now - m_lastUpdate);
}
XBT_DEBUG("Updating action(%p): remains is now %f", this, m_remains);
m_lastUpdate = now;
m_lastValue = lmm_variable_getvalue(getVariable());
}
+
+}
+}
