-/* 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
* under the terms of the license (GNU LGPL) which comes with this package. */
+#include "src/portable.h"
#include "surf_private.h"
#include "surf_interface.hpp"
#include "network_interface.hpp"
#include "cpu_interface.hpp"
-#include "host_interface.hpp"
-#include "simix/smx_host_private.h"
+#include "src/surf/HostImpl.hpp"
+#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"
+#include "src/instr/instr_private.h" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
XBT_LOG_NEW_CATEGORY(surf, "All SURF categories");
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf,
- "Logging specific to SURF (kernel)");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf, "Logging specific to SURF (kernel)");
/*********
* 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 model_list_invoke = NULL; /* for invoking callbacks */
+ * The callback functions of cpu_model and network_model will be called from those of these host models. */
+xbt_dynar_t all_existing_models = NULL; /* to destroy models correctly */
+xbt_dynar_t model_list_invoke = NULL; /* to invoke callbacks */
-tmgr_history_t history = NULL;
-lmm_system_t maxmin_system = NULL;
+simgrid::trace_mgr::future_evt_set *future_evt_set = nullptr;
xbt_dynar_t surf_path = NULL;
-xbt_dynar_t host_that_restart = NULL;
+xbt_dynar_t host_that_restart = xbt_dynar_new(sizeof(char*), NULL);
xbt_dict_t watched_hosts_lib;
-surf_callback(void, void) surfExitCallbacks;
+namespace simgrid {
+namespace surf {
+
+simgrid::xbt::signal<void(void)> surfExitCallbacks;
+
+}
+}
+
+#include <simgrid/plugins/energy.h> // FIXME: this plugin should not be linked to the core
s_surf_model_description_t surf_plugin_description[] = {
{"Energy", "Cpu energy consumption.", sg_energy_plugin_init},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
-/* Don't forget to update the option description in smx_config when you change
- this */
+/* Don't forget to update the option description in smx_config when you change this */
s_surf_model_description_t surf_network_model_description[] = {
- {"LV08",
- "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). ",
+ {"LV08", "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 specifically tailored for HPC settings (accurate modeling of slow start with correction factors on three intervals: < 1KiB, < 64 KiB, >= 64 KiB)",
+ {"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},
- {"IB",
- "Realistic network model specifically tailored for HPC settings, with Infiniband contention model",
+ {"IB", "Realistic network model specifically tailored for HPC settings, with Infiniband contention model",
surf_network_model_init_IB},
- {"CM02",
- "Legacy network analytic model (Very similar to LV08, but without corrective factors. The timings of small messages are thus poorly modeled).",
+ {"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",
- surf_network_model_init_NS3},
+ {"NS3", "Network pseudo-model using the NS3 tcp model instead of an analytic model", surf_network_model_init_NS3},
#endif
- {"Reno",
- "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
+ {"Reno", "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 from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
+ {"Reno2", "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 from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
+ {"Vegas", "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} /* this array must be NULL terminated */
};
s_surf_model_description_t surf_cpu_model_description[] = {
- {"Cas01",
- "Simplistic CPU model (time=size/power).",
- surf_cpu_model_init_Cas01},
+ {"Cas01", "Simplistic CPU model (time=size/power).", surf_cpu_model_init_Cas01},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
s_surf_model_description_t surf_host_model_description[] = {
- {"default",
- "Default host model. Currently, CPU:Cas01 and network:LV08 (with cross traffic enabled)",
- surf_host_model_init_current_default},
- {"compound",
- "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},
+ {"default", "Default host model. Currently, CPU:Cas01 and network:LV08 (with cross traffic enabled)", surf_host_model_init_current_default},
+ {"compound", "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_model_description[] = {
- {"default",
- "Default vm model.",
- surf_vm_model_init_HL13},
+ {"default", "Default vm model.", surf_vm_model_init_HL13},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
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},
+ {"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 */
};
s_surf_model_description_t surf_storage_model_description[] = {
- {"default",
- "Simplistic storage model.",
- surf_storage_model_init_default},
+ {"default", "Simplistic storage model.", surf_storage_model_init_default},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
-#ifdef CONTEXT_THREADS
+#ifdef HAVE_THREAD_CONTEXTS
static xbt_parmap_t surf_parmap = NULL; /* parallel map on models */
#endif
/** Displays the long description of all registered models, and quit */
void model_help(const char *category, s_surf_model_description_t * table)
{
- int i;
- printf("Long description of the %s models accepted by this simulator:\n",
- category);
- for (i = 0; table[i].name; i++)
+ printf("Long description of the %s models accepted by this simulator:\n", category);
+ for (int i = 0; table[i].name; i++)
printf(" %s: %s\n", table[i].name, table[i].description);
}
return -1;
}
-static XBT_INLINE void routing_asr_prop_free(void *p)
-{
- //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_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) {
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",
+ "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);
+ 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",
+ "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);
+ lib_version_major,lib_version_minor,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) {
+ simgrid::s4u::Host* host = static_cast<simgrid::s4u::Host*>(p);
+ simgrid::s4u::Host::onDestruction(*host);
+ delete host;
+ });
+ USER_HOST_LEVEL = simgrid::s4u::Host::extension_create(NULL);
+
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_PROP_ASR_LEVEL = xbt_lib_add_level(as_router_lib,routing_asr_prop_free);
+ ROUTING_PROP_ASR_LEVEL = xbt_lib_add_level(as_router_lib, NULL);
XBT_DEBUG("Add SURF levels");
- SURF_HOST_LEVEL = xbt_lib_add_level(host_lib,surf_host_free);
+ simgrid::surf::HostImpl::classInit();
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);
- if (!history)
- history = tmgr_history_new();
+ model_list_invoke = xbt_dynar_new(sizeof(simgrid::surf::Model*), NULL);
+ if (!future_evt_set)
+ future_evt_set = new simgrid::trace_mgr::future_evt_set();
TRACE_add_start_function(TRACE_surf_alloc);
TRACE_add_end_function(TRACE_surf_release);
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);
- maxmin_system = NULL;
- }
- if (history) {
- tmgr_history_free(history);
- history = NULL;
+ if (future_evt_set) {
+ delete future_evt_set;
+ future_evt_set = nullptr;
}
-#ifdef CONTEXT_THREADS
+#ifdef HAVE_THREAD_CONTEXTS
xbt_parmap_destroy(surf_parmap);
#endif
tmgr_finalize();
- surf_parse_lex_destroy();
- surf_parse_free_callbacks();
+ sg_platf_exit();
NOW = 0; /* Just in case the user plans to restart the simulation afterward */
}
* Model *
*********/
+namespace simgrid {
+namespace surf {
+
Model::Model()
: p_maxminSystem(NULL)
{
delete p_doneActionSet;
}
-double Model::shareResources(double now)
+double Model::next_occuring_event(double now)
{
//FIXME: set the good function once and for all
if (p_updateMechanism == UM_LAZY)
- return shareResourcesLazy(now);
+ return next_occuring_event_lazy(now);
else if (p_updateMechanism == UM_FULL)
- return shareResourcesFull(now);
+ return next_occuring_event_full(now);
else
xbt_die("Invalid cpu update mechanism!");
}
-double Model::shareResourcesLazy(double now)
+double Model::next_occuring_event_lazy(double now)
{
Action *action = NULL;
double min = -1;
return min;
}
-double Model::shareResourcesFull(double /*now*/) {
+double Model::next_occuring_event_full(double /*now*/) {
THROW_UNIMPLEMENTED;
}
for (++it; it != itend; ++it) {
- action = &*it;
+ action = &*it;
value = lmm_variable_getvalue(action->getVariable());
if (value > 0) {
if (action->getRemains() > 0)
void Model::updateActionsState(double now, double delta)
{
if (p_updateMechanism == UM_FULL)
- updateActionsStateFull(now, delta);
+ updateActionsStateFull(now, delta);
else if (p_updateMechanism == UM_LAZY)
- updateActionsStateLazy(now, delta);
+ updateActionsStateLazy(now, delta);
else
- xbt_die("Invalid cpu update mechanism!");
+ xbt_die("Invalid cpu update mechanism!");
}
void Model::updateActionsStateLazy(double /*now*/, double /*delta*/)
THROW_UNIMPLEMENTED;
}
+}
+}
+
/************
* Resource *
************/
-Resource::Resource()
-: p_name(NULL), p_properties(NULL), p_model(NULL)
-{}
+namespace simgrid {
+namespace surf {
-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, 1/*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, 1/*ON*/)
+{}
+
+Resource::Resource(Model *model, const char *name, lmm_constraint_t constraint, int initiallyOn)
+ : p_name(xbt_strdup(name))
+ , p_model(model)
+ , m_isOn(initiallyOn)
+ , 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)
- , m_running(true), m_stateCurrent(stateInit)
+Resource::Resource(Model *model, const char *name, int initiallyOn)
+ : p_name(xbt_strdup(name))
+ , p_model(model)
+ , m_isOn(initiallyOn)
{}
+
Resource::~Resource() {
xbt_free((void*)p_name);
- xbt_dict_free(&p_properties);
-}
-
-e_surf_resource_state_t Resource::getState()
-{
- return m_stateCurrent;
}
-void Resource::setState(e_surf_resource_state_t state)
-{
- m_stateCurrent = state;
+bool Resource::isOn() {
+ return m_isOn;
}
-
-bool Resource::isOn()
-{
- return m_running;
+bool Resource::isOff() {
+ return ! m_isOn;
}
void Resource::turnOn()
{
- if (!m_running) {
- m_running = true;
+ if (!m_isOn) {
+ m_isOn = true;
}
}
void Resource::turnOff()
{
- if (m_running) {
- m_running = false;
+ if (m_isOn) {
+ m_isOn = false;
}
}
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);
}
lmm_update_variable_weight(getModel()->getMaxminSystem(), getVariable(), priority);
if (getModel()->getUpdateMechanism() == UM_LAZY)
- heapRemove(getModel()->getActionHeap());
+ heapRemove(getModel()->getActionHeap());
XBT_OUT();
}
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) {
- 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());
}
+
+}
+}
