X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7da2926d0733ff0683f31aeea176ce71e127264f..0bac7d0f735ac8ba47a46e1db4f6d7a7164fe0f2:/src/surf/surf_interface.cpp diff --git a/src/surf/surf_interface.cpp b/src/surf/surf_interface.cpp index 8c78bcc2f0..e5cee4109a 100644 --- a/src/surf/surf_interface.cpp +++ b/src/surf/surf_interface.cpp @@ -9,11 +9,11 @@ #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, @@ -23,71 +23,10 @@ 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; @@ -96,8 +35,14 @@ xbt_dynar_t surf_path = NULL; xbt_dynar_t host_that_restart = NULL; xbt_dict_t watched_hosts_lib; +namespace simgrid { +namespace surf { + surf_callback(void, void) surfExitCallbacks; +} +} + 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 */ @@ -326,12 +271,12 @@ static XBT_INLINE void routing_asr_prop_free(void *p) static XBT_INLINE void surf_host_free(void *r) { - delete static_cast(r); + delete static_cast(r); } static XBT_INLINE void surf_storage_free(void *r) { - delete static_cast(r); + delete static_cast(r); } void sg_version_check(int lib_version_major,int lib_version_minor,int lib_version_patch) { @@ -361,7 +306,9 @@ void sg_version(int *ver_major,int *ver_minor,int *ver_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 (simgrid::Host*)p; + }); as_router_lib = xbt_lib_new(); storage_lib = xbt_lib_new(); storage_type_lib = xbt_lib_new(); @@ -374,14 +321,14 @@ void surf_init(int *argc, char **argv) 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_HOST_LEVEL = simgrid::Host::add_level(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(); @@ -397,7 +344,7 @@ void surf_init(int *argc, char **argv) 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) */ @@ -407,7 +354,7 @@ void surf_exit(void) 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(); @@ -415,13 +362,13 @@ void surf_exit(void) 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); + surf_callback_emit(simgrid::surf::surfExitCallbacks); if (maxmin_system) { lmm_system_free(maxmin_system); @@ -447,6 +394,9 @@ void surf_exit(void) * Model * *********/ +namespace simgrid { +namespace surf { + Model::Model() : p_maxminSystem(NULL) { @@ -635,22 +585,33 @@ void Model::updateActionsStateFull(double /*now*/, double /*delta*/) THROW_UNIMPLEMENTED; } +} +} + /************ * Resource * ************/ +namespace simgrid { +namespace surf { + Resource::Resource() : p_name(NULL), p_properties(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(model, name, props, SURF_RESOURCE_ON) {} Resource::Resource(Model *model, const char *name, xbt_dict_t props, lmm_constraint_t constraint) + : Resource(model, name, props, constraint, SURF_RESOURCE_ON) +{} + +Resource::Resource( + Model *model, const char *name, xbt_dict_t props, + lmm_constraint_t constraint, e_surf_resource_state_t stateInit) : p_name(xbt_strdup(name)), p_properties(props), p_model(model) - , m_running(true), m_stateCurrent(SURF_RESOURCE_ON), p_constraint(constraint) + , 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) @@ -710,6 +671,9 @@ lmm_constraint_t Resource::getConstraint() { return p_constraint; } +} +} + /********** * Action * **********/ @@ -723,7 +687,15 @@ const char *surf_action_state_names[6] = { "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(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; @@ -751,12 +723,12 @@ void Action::initialize(Model *model, double cost, bool failed, 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); } @@ -955,11 +927,6 @@ void Action::heapUpdate(xbt_heap_t heap, double key, enum heap_action_type hat) } } -/* added to manage the communication action's heap */ -void surf_action_lmm_update_index_heap(void *action, int i) { - static_cast(action)->updateIndexHeap(i); -} - void Action::updateIndexHeap(int i) { m_indexHeap = i; } @@ -1006,7 +973,8 @@ void Action::updateRemainingLazy(double now) 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(lmm_constraint_id(lmm_get_cnst_from_var(getModel()->getMaxminSystem(), getVariable(), 0))); + simgrid::surf::Resource *cpu = static_cast( + 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); @@ -1034,3 +1002,6 @@ void Action::updateRemainingLazy(double now) m_lastUpdate = now; m_lastValue = lmm_variable_getvalue(getVariable()); } + +} +}