-/* Copyright (c) 2004-2014. The SimGrid Team.
+/* Copyright (c) 2004-2015. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
#include "surf_interface.hpp"
#include "network_interface.hpp"
#include "cpu_interface.hpp"
-#include "workstation_interface.hpp"
-#include "vm_workstation_interface.hpp"
-#include "simix/smx_host_private.h"
+#include "host_interface.hpp"
+#include "src/simix/smx_host_private.h"
#include "surf_routing.hpp"
#include "simgrid/sg_config.h"
#include "mc/mc.h"
+#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_workstation and surf_vm_workstation.
+/* 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 workstation models. */
-xbt_dynar_t model_list = NULL; /* for destroying all models correctly */
+ * those of these host models. */
+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},
+ {"Energy", "Cpu energy consumption.", sg_energy_plugin_init},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
{"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",
- surf_network_model_init_GTNETS},
-#endif
#ifdef HAVE_NS3
{"NS3",
"Network pseudo-model using the NS3 tcp model instead of an analytic model",
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
-s_surf_model_description_t surf_workstation_model_description[] = {
+s_surf_model_description_t surf_host_model_description[] = {
{"default",
- "Default workstation model. Currently, CPU:Cas01 and network:LV08 (with cross traffic enabled)",
- surf_workstation_model_init_current_default},
+ "Default host model. Currently, CPU:Cas01 and network:LV08 (with cross traffic enabled)",
+ surf_host_model_init_current_default},
{"compound",
- "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},
+ "Host model that is automatically chosen if you change the network and CPU models",
+ surf_host_model_init_compound},
+ {"ptask_L07", "Host model somehow similar to Cas01+CM02 but allowing parallel tasks",
+ surf_host_model_init_ptask_L07},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
-s_surf_model_description_t surf_vm_workstation_model_description[] = {
+s_surf_model_description_t surf_vm_model_description[] = {
{"default",
- "Default vm workstation model.",
- surf_vm_workstation_model_init_HL13},
+ "Default vm model.",
+ surf_vm_model_init_HL13},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
#endif
double NOW = 0;
-double *surf_mins = NULL; /* return value of share_resources for each model */
-int surf_min_index; /* current index in surf_mins */
-double surf_min; /* duration determined by surf_solve */
double surf_get_clock(void)
{
return NULL;
}
-
-#ifndef MAX_DRIVE
-#define MAX_DRIVE 26
-#endif
-
#ifdef _XBT_WIN32
#include <windows.h>
+#define MAX_DRIVE 26
static const char *disk_drives_letter_table[MAX_DRIVE] = {
- "A:\\",
- "B:\\",
- "C:\\",
- "D:\\",
- "E:\\",
- "F:\\",
- "G:\\",
- "H:\\",
- "I:\\",
- "J:\\",
- "K:\\",
- "L:\\",
- "M:\\",
- "N:\\",
- "O:\\",
- "P:\\",
- "Q:\\",
- "R:\\",
- "S:\\",
- "T:\\",
- "U:\\",
- "V:\\",
- "W:\\",
- "X:\\",
- "Y:\\",
- "Z:\\"
+ "A:\\","B:\\","C:\\","D:\\","E:\\","F:\\","G:\\","H:\\","I:\\","J:\\","K:\\","L:\\","M:\\",
+ "N:\\","O:\\","P:\\","Q:\\","R:\\","S:\\","T:\\","U:\\","V:\\","W:\\","X:\\","Y:\\","Z:\\"
};
#endif
return -1;
}
-static XBT_INLINE void routing_asr_host_free(void *p)
-{
- delete ((RoutingEdgePtr) p);
-}
-
static XBT_INLINE void routing_asr_prop_free(void *p)
{
- xbt_dict_t elm = (xbt_dict_t) p;
- xbt_dict_free(&elm);
-}
-
-static XBT_INLINE void surf_cpu_free(void *r)
-{
- delete static_cast<CpuPtr>(r);
-}
-
-static XBT_INLINE void surf_link_free(void *r)
-{
- delete static_cast<NetworkLinkPtr>(r);
-}
-
-static XBT_INLINE void surf_workstation_free(void *r)
-{
- delete static_cast<WorkstationPtr>(r);
+ //xbt_dict_t elm = (xbt_dict_t) p;
+ //xbt_dict_free(&elm); FIXME: leaking in some case? That's a sometimes double-free with AsCluster::~AsCluster
}
static XBT_INLINE void surf_storage_free(void *r)
{
- delete static_cast<StoragePtr>(r);
+ delete static_cast<simgrid::surf::Storage*>(r);
}
+void sg_version_check(int lib_version_major,int lib_version_minor,int lib_version_patch) {
+ if ((lib_version_major != SIMGRID_VERSION_MAJOR) || (lib_version_minor != SIMGRID_VERSION_MINOR)) {
+ fprintf(stderr,
+ "FATAL ERROR: Your program was compiled with SimGrid version %d.%d.%d, "
+ "and then linked against SimGrid %d.%d.%d. Please fix this.\n",
+ SIMGRID_VERSION_MAJOR,SIMGRID_VERSION_MINOR,SIMGRID_VERSION_PATCH,
+ lib_version_major,lib_version_minor,lib_version_patch);
+ abort();
+ }
+ if (lib_version_patch != SIMGRID_VERSION_PATCH) {
+ fprintf(stderr,
+ "Warning: Your program was compiled with SimGrid version %d.%d.%d, "
+ "and then linked against SimGrid %d.%d.%d. Proceeding anyway.\n",
+ SIMGRID_VERSION_MAJOR,SIMGRID_VERSION_MINOR,SIMGRID_VERSION_PATCH,
+ lib_version_major,lib_version_minor,lib_version_patch);
+ }
+}
void sg_version(int *ver_major,int *ver_minor,int *ver_patch) {
*ver_major = SIMGRID_VERSION_MAJOR;
void surf_init(int *argc, char **argv)
{
XBT_DEBUG("Create all Libs");
- host_lib = xbt_lib_new();
- link_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();
file_lib = xbt_lib_new();
watched_hosts_lib = xbt_dict_new_homogeneous(NULL);
+ sg_host_init();
+
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_cpu_free);
- SURF_WKS_LEVEL = xbt_lib_add_level(host_lib,surf_workstation_free);
- SURF_LINK_LEVEL = xbt_lib_add_level(link_lib,surf_link_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(ModelPtr), 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(ModelPtr), NULL);
+ model_list_invoke = xbt_dynar_new(sizeof(simgrid::surf::Model*), NULL);
if (!history)
history = tmgr_history_new();
-#ifdef HAVE_TRACING
TRACE_add_start_function(TRACE_surf_alloc);
TRACE_add_end_function(TRACE_surf_release);
-#endif
sg_config_init(argc, argv);
void surf_exit(void)
{
unsigned int iter;
- ModelPtr model = NULL;
+ simgrid::surf::Model *model = NULL;
-#ifdef HAVE_TRACING
TRACE_end(); /* Just in case it was not called by the upper
* layer (or there is no upper layer) */
-#endif
sg_config_finalize();
xbt_dynar_free(&host_that_restart);
xbt_dynar_free(&surf_path);
- xbt_lib_free(&host_lib);
- xbt_lib_free(&link_lib);
+ xbt_dict_free(&host_list);
xbt_lib_free(&as_router_lib);
xbt_lib_free(&storage_lib);
+ sg_link_exit();
xbt_lib_free(&storage_type_lib);
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);
xbt_parmap_destroy(surf_parmap);
#endif
- xbt_free(surf_mins);
- surf_mins = NULL;
-
tmgr_finalize();
surf_parse_lex_destroy();
surf_parse_free_callbacks();
* Model *
*********/
-Model::Model(const char *name)
+namespace simgrid {
+namespace surf {
+
+Model::Model()
: p_maxminSystem(NULL)
- , p_name(name)
{
p_readyActionSet = new ActionList();
p_runningActionSet = new ActionList();
double Model::shareResourcesLazy(double now)
{
- ActionPtr action = NULL;
+ Action *action = NULL;
double min = -1;
double share;
THROW_UNIMPLEMENTED;
}
-double Model::shareResourcesMaxMin(ActionListPtr running_actions,
+double Model::shareResourcesMaxMin(ActionList *running_actions,
lmm_system_t sys,
void (*solve) (lmm_system_t))
{
- ActionPtr action = NULL;
+ Action *action = NULL;
double min = -1;
double value = -1;
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(ModelPtr 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(ModelPtr 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(ModelPtr 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()
}
}
-ModelPtr Resource::getModel() {
+Model *Resource::getModel() {
return p_model;
}
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(ModelPtr 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_failed = failed;
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;
-}
-
-Action::Action(ModelPtr model, double cost, bool failed)
-{
- initialize(model, cost, failed);
- #ifdef HAVE_TRACING
- p_category = NULL;
- #endif
- p_stateHookup.prev = 0;
- p_stateHookup.next = 0;
if (failed)
p_stateSet = getModel()->getFailedActionSet();
else
p_stateSet->push_back(*this);
}
-Action::Action(ModelPtr model, double cost, bool failed, lmm_variable_t var)
+Action::Action(simgrid::surf::Model *model, double cost, bool failed)
{
- initialize(model, cost, failed, var);
- #ifdef HAVE_TRACING
- p_category = NULL;
- #endif
- p_stateHookup.prev = 0;
- p_stateHookup.next = 0;
- if (failed)
- p_stateSet = getModel()->getFailedActionSet();
- else
- p_stateSet = getModel()->getRunningActionSet();
+ initialize(model, cost, failed);
+}
- p_stateSet->push_back(*this);
+Action::Action(simgrid::surf::Model *model, double cost, bool failed, lmm_variable_t var)
+{
+ initialize(model, cost, failed, var);
}
Action::~Action() {
-#ifdef HAVE_TRACING
xbt_free(p_category);
-#endif
}
void Action::finish() {
p_data = data;
}
-#ifdef HAVE_TRACING
void Action::setCategory(const char *category)
{
XBT_IN("(%p,%s)", this, category);
p_category = xbt_strdup(category);
XBT_OUT();
}
-#endif
void Action::ref(){
m_refcount++;
void Action::cancel(){
setState(SURF_ACTION_FAILED);
if (getModel()->getUpdateMechanism() == UM_LAZY) {
- if (actionLmmHook::is_linked())
+ if (action_lmm_hook.is_linked())
getModel()->getModifiedSet()->erase(getModel()->getModifiedSet()->iterator_to(*this));
heapRemove(getModel()->getActionHeap());
}
int Action::unref(){
m_refcount--;
if (!m_refcount) {
- if (actionHook::is_linked())
+ if (action_hook.is_linked())
p_stateSet->erase(p_stateSet->iterator_to(*this));
if (getVariable())
lmm_variable_free(getModel()->getMaxminSystem(), getVariable());
if (getModel()->getUpdateMechanism() == UM_LAZY) {
/* remove from heap */
heapRemove(getModel()->getActionHeap());
- if (actionLmmHook::is_linked())
+ if (action_lmm_hook.is_linked())
getModel()->getModifiedSet()->erase(getModel()->getModifiedSet()->iterator_to(*this));
}
delete this;
}
}
-/* added to manage the communication action's heap */
-void surf_action_lmm_update_index_heap(void *action, int i) {
- ((ActionPtr)action)->updateIndexHeap(i);
-}
-
void Action::updateIndexHeap(int i) {
m_indexHeap = i;
}
XBT_DEBUG("Updating action(%p): remains was %f, last_update was: %f", this, m_remains, m_lastUpdate);
double_update(&m_remains, m_lastValue * delta, sg_surf_precision*sg_maxmin_precision);
-#ifdef HAVE_TRACING
if (getModel() == surf_cpu_model_pm && TRACE_is_enabled()) {
- ResourcePtr cpu = static_cast<ResourcePtr>(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);
}
-#endif
XBT_DEBUG("Updating action(%p): remains is now %f", this, m_remains);
}
m_lastValue = lmm_variable_getvalue(getVariable());
}
+}
+}
