X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/665b37c47175d0abd08d1252180d4d37bf9a342a..e13d26773d3aa31c3d0eb24816470bcf8ccc26c0:/src/msg/msg_vm.cpp diff --git a/src/msg/msg_vm.cpp b/src/msg/msg_vm.cpp index 2198f6d593..35efaa791e 100644 --- a/src/msg/msg_vm.cpp +++ b/src/msg/msg_vm.cpp @@ -11,6 +11,8 @@ #include +#include "src/plugins/vm/VirtualMachineImpl.hpp" +#include #include #include "msg_private.h" @@ -18,76 +20,39 @@ #include "xbt/log.h" #include "simgrid/host.h" +#include "src/simix/smx_host_private.h" /* don't ask me why the VM functions are in there (FIXME:KILLME) */ + XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_vm, msg, "Cloud-oriented parts of the MSG API"); /* **** ******** GENERAL ********* **** */ -/** \ingroup m_vm_management - * \brief Returns the value of a given vm property - * - * \param vm a vm - * \param name a property name - * \return value of a property (or nullptr if property not set) - */ -const char *MSG_vm_get_property_value(msg_vm_t vm, const char *name) -{ - return MSG_host_get_property_value(vm, name); -} /** \ingroup m_vm_management - * \brief Returns a xbt_dict_t consisting of the list of properties assigned to this host - * - * \param vm a vm - * \return a dict containing the properties - */ -xbt_dict_t MSG_vm_get_properties(msg_vm_t vm) -{ - xbt_assert((vm != nullptr), "Invalid parameters (vm is nullptr)"); - return vm->properties(); -} - -/** \ingroup m_host_management - * \brief Change the value of a given host property + * \brief Set the parameters of a given host * * \param vm a vm - * \param name a property name - * \param value what to change the property to - * \param free_ctn the freeing function to use to kill the value on need + * \param params a parameter object */ -void MSG_vm_set_property_value(msg_vm_t vm, const char *name, void *value, void_f_pvoid_t free_ctn) +void MSG_vm_set_params(msg_vm_t vm, vm_params_t params) { - xbt_dict_set(MSG_host_get_properties(vm), name, value, free_ctn); -} - -/** \ingroup msg_vm_management - * \brief Finds a msg_vm_t using its name. - * - * This is a name directory service - * \param name the name of a vm. - * \return the corresponding vm - * - * Please note that a VM is a specific host. Hence, you should give a different name for each VM/PM. - */ -msg_vm_t MSG_vm_get_by_name(const char *name) -{ - return MSG_host_by_name(name); + static_cast(vm)->setParameters(params); } /** \ingroup m_vm_management + * \brief Get the parameters of a given host * - * \brief Return the name of the #msg_host_t. - * - * This functions checks whether \a host is a valid pointer or not and return its name. + * \param host a host + * \param params a prameter object */ -const char *MSG_vm_get_name(msg_vm_t vm) +void MSG_vm_get_params(msg_vm_t vm, vm_params_t params) { - return MSG_host_get_name(vm); + static_cast(vm)->parameters(params); } /* **** Check state of a VM **** */ static inline int __MSG_vm_is_state(msg_vm_t vm, e_surf_vm_state_t state) { - return simcall_vm_get_state(vm) == state; + return static_cast(vm)->pimpl_vm_->getState() == state; } /** @brief Returns whether the given VM has just created, not running. @@ -111,8 +76,7 @@ int MSG_vm_is_running(msg_vm_t vm) */ int MSG_vm_is_migrating(msg_vm_t vm) { - msg_host_priv_t priv = sg_host_msg(vm); - return priv->is_migrating; + return static_cast(vm)->isMigrating(); } /** @brief Returns whether the given VM is currently suspended, not running. @@ -182,7 +146,7 @@ msg_vm_t MSG_vm_create(msg_host_t pm, const char *name, int ncpus, int ramsize, //XBT_INFO("dp rate %f migspeed : %f intensity mem : %d, updatespeed %f, hostspeed %f",params.dp_rate, // params.mig_speed, dp_intensity, update_speed, host_speed); - vm->setParameters(¶ms); + static_cast(vm)->setParameters(¶ms); return vm; } @@ -196,7 +160,7 @@ msg_vm_t MSG_vm_create_core(msg_host_t ind_pm, const char *name) { /* make sure the VM of the same name does not exit */ { - simgrid::s4u::Host* ind_host_tmp = (simgrid::s4u::Host*) xbt_dict_get_or_null(host_list, name); + simgrid::s4u::Host* ind_host_tmp = sg_host_by_name(name); if (ind_host_tmp != nullptr && sg_host_simix(ind_host_tmp) != nullptr) { XBT_ERROR("host %s already exits", name); return nullptr; @@ -332,7 +296,7 @@ static int migration_rx_fun(int argc, char *argv[]) struct migration_session *ms = (migration_session *) MSG_process_get_data(MSG_process_self()); s_vm_params_t params; - ms->vm->parameters(¶ms); + static_cast(ms->vm)->parameters(¶ms); int need_exit = 0; @@ -366,25 +330,31 @@ static int migration_rx_fun(int argc, char *argv[]) // Copy the reference to the vm (if SRC crashes now, do_migration will free ms) // This is clearly ugly but I (Adrien) need more time to do something cleaner (actually we should copy the whole ms // structure at the beginning and free it at the end of each function) - msg_vm_t vm = ms->vm; - msg_host_t src_pm = ms->src_pm; - msg_host_t dst_pm = ms-> dst_pm; - -// TODO: we have an issue, if the DST node is turning off during the three next calls, then the VM is in an inconsistent -// state. I should check with Takahiro in order to make this portion of code atomic -// -// /* Update the vm location */ -// simcall_vm_migrate(vm, dst_pm); -// -// /* Resume the VM */ -// simcall_vm_resume(vm); -// - simcall_vm_migratefrom_resumeto(vm, src_pm, dst_pm); + simgrid::s4u::VirtualMachine* vm = static_cast(ms->vm); + msg_host_t src_pm = ms->src_pm; + msg_host_t dst_pm = ms->dst_pm; + + // TODO: we have an issue, if the DST node is turning off during the three next calls, then the VM is in an + // inconsistent + // state. I should check with Takahiro in order to make this portion of code atomic + // + // /* Update the vm location */ + // simcall_vm_migrate(vm, dst_pm); + // + // /* Resume the VM */ + // simcall_vm_resume(vm); + // + simgrid::simix::kernelImmediate([vm, src_pm, dst_pm]() { + /* Update the vm location */ + SIMIX_vm_migrate(vm, dst_pm); + + /* Resume the VM */ + SIMIX_vm_resume(vm); + }); { // Now the VM is running on the new host (the migration is completed) (even if the SRC crash) - msg_host_priv_t priv = sg_host_msg(vm); - priv->is_migrating = 0; + vm->pimpl_vm_->isMigrating = false; XBT_DEBUG("VM(%s) moved from PM(%s) to PM(%s)", sg_host_get_name(ms->vm), sg_host_get_name(ms->src_pm), sg_host_get_name(ms->dst_pm)); TRACE_msg_vm_change_host(ms->vm, ms->src_pm, ms->dst_pm); @@ -415,12 +385,14 @@ static int migration_rx_fun(int argc, char *argv[]) static void reset_dirty_pages(msg_vm_t vm) { - msg_host_priv_t priv = sg_host_msg(vm); + simgrid::surf::VirtualMachineImpl* pimpl = static_cast(vm->pimpl_); char *key = nullptr; xbt_dict_cursor_t cursor = nullptr; dirty_page_t dp = nullptr; - xbt_dict_foreach(priv->dp_objs, cursor, key, dp) { + if (!pimpl->dp_objs) + return; + xbt_dict_foreach (pimpl->dp_objs, cursor, key, dp) { double remaining = MSG_task_get_flops_amount(dp->task); dp->prev_clock = MSG_get_clock(); dp->prev_remaining = remaining; @@ -431,16 +403,14 @@ static void reset_dirty_pages(msg_vm_t vm) static void start_dirty_page_tracking(msg_vm_t vm) { - msg_host_priv_t priv = sg_host_msg(vm); - priv->dp_enabled = 1; + static_cast(vm)->pimpl_vm_->dp_enabled = 1; reset_dirty_pages(vm); } static void stop_dirty_page_tracking(msg_vm_t vm) { - msg_host_priv_t priv = sg_host_msg(vm); - priv->dp_enabled = 0; + static_cast(vm)->pimpl_vm_->dp_enabled = 0; } static double get_computed(char *key, msg_vm_t vm, dirty_page_t dp, double remaining, double clock) @@ -456,13 +426,13 @@ static double get_computed(char *key, msg_vm_t vm, dirty_page_t dp, double remai static double lookup_computed_flop_counts(msg_vm_t vm, int stage_for_fancy_debug, int stage2_round_for_fancy_debug) { - msg_host_priv_t priv = sg_host_msg(vm); + simgrid::surf::VirtualMachineImpl* pimpl = static_cast(vm)->pimpl_vm_; double total = 0; char *key = nullptr; xbt_dict_cursor_t cursor = nullptr; dirty_page_t dp = nullptr; - xbt_dict_foreach(priv->dp_objs, cursor, key, dp) { + xbt_dict_foreach (pimpl->dp_objs, cursor, key, dp) { double remaining = MSG_task_get_flops_amount(dp->task); double clock = MSG_get_clock(); @@ -474,65 +444,70 @@ static double lookup_computed_flop_counts(msg_vm_t vm, int stage_for_fancy_debug dp->prev_clock = clock; } - total += priv->dp_updated_by_deleted_tasks; + total += pimpl->dp_updated_by_deleted_tasks; - XBT_DEBUG("mig-stage%d.%d: computed %f flop_counts (including %f by deleted tasks)", - stage_for_fancy_debug, stage2_round_for_fancy_debug, total, priv->dp_updated_by_deleted_tasks); + XBT_DEBUG("mig-stage%d.%d: computed %f flop_counts (including %f by deleted tasks)", stage_for_fancy_debug, + stage2_round_for_fancy_debug, total, pimpl->dp_updated_by_deleted_tasks); - priv->dp_updated_by_deleted_tasks = 0; + pimpl->dp_updated_by_deleted_tasks = 0; return total; } // TODO Is this code redundant with the information provided by // msg_process_t MSG_process_create(const char *name, xbt_main_func_t code, void *data, msg_host_t host) +/** @brief take care of the dirty page tracking, in case we're adding a task to a migrating VM */ void MSG_host_add_task(msg_host_t host, msg_task_t task) { - msg_host_priv_t priv = sg_host_msg(host); + simgrid::s4u::VirtualMachine* vm = dynamic_cast(host); + if (vm == nullptr) + return; + simgrid::surf::VirtualMachineImpl* pimpl = static_cast(vm->pimpl_); + double remaining = MSG_task_get_flops_amount(task); char *key = bprintf("%s-%p", task->name, task); dirty_page_t dp = xbt_new0(s_dirty_page, 1); dp->task = task; - - /* It should be okay that we add a task onto a migrating VM. */ - if (priv->dp_enabled) { + if (pimpl->dp_enabled) { dp->prev_clock = MSG_get_clock(); dp->prev_remaining = remaining; } - - xbt_assert(xbt_dict_get_or_null(priv->dp_objs, key) == nullptr); - xbt_dict_set(priv->dp_objs, key, dp, nullptr); - XBT_DEBUG("add %s on %s (remaining %f, dp_enabled %d)", key, sg_host_get_name(host), remaining, priv->dp_enabled); + if (!pimpl->dp_objs) + pimpl->dp_objs = xbt_dict_new(); + xbt_assert(xbt_dict_get_or_null(pimpl->dp_objs, key) == nullptr); + xbt_dict_set(pimpl->dp_objs, key, dp, nullptr); + XBT_DEBUG("add %s on %s (remaining %f, dp_enabled %d)", key, sg_host_get_name(host), remaining, pimpl->dp_enabled); xbt_free(key); } void MSG_host_del_task(msg_host_t host, msg_task_t task) { - msg_host_priv_t priv = sg_host_msg(host); + simgrid::s4u::VirtualMachine* vm = dynamic_cast(host); + if (vm == nullptr) + return; + simgrid::surf::VirtualMachineImpl* pimpl = static_cast(vm->pimpl_); char *key = bprintf("%s-%p", task->name, task); - - dirty_page_t dp = (dirty_page_t) xbt_dict_get_or_null(priv->dp_objs, key); + dirty_page_t dp = (dirty_page_t)(pimpl->dp_objs ? xbt_dict_get_or_null(pimpl->dp_objs, key) : NULL); xbt_assert(dp->task == task); /* If we are in the middle of dirty page tracking, we record how much computation has been done until now, and keep * the information for the lookup_() function that will called soon. */ - if (priv->dp_enabled) { + if (pimpl->dp_enabled) { double remaining = MSG_task_get_flops_amount(task); double clock = MSG_get_clock(); // double updated = calc_updated_pages(key, host, dp, remaining, clock); double updated = get_computed(key, host, dp, remaining, clock); - priv->dp_updated_by_deleted_tasks += updated; + pimpl->dp_updated_by_deleted_tasks += updated; } - - xbt_dict_remove(priv->dp_objs, key); + if (pimpl->dp_objs) + xbt_dict_remove(pimpl->dp_objs, key); xbt_free(dp); XBT_DEBUG("del %s on %s", key, sg_host_get_name(host)); - xbt_free(key); } @@ -636,7 +611,7 @@ static int migration_tx_fun(int argc, char *argv[]) migration_session *ms = (migration_session *) MSG_process_get_data(MSG_process_self()); s_vm_params_t params; - ms->vm->parameters(¶ms); + static_cast(ms->vm)->parameters(¶ms); const sg_size_t ramsize = params.ramsize; const sg_size_t devsize = params.devsize; const int skip_stage1 = params.skip_stage1; @@ -899,18 +874,18 @@ void MSG_vm_migrate(msg_vm_t vm, msg_host_t new_pm) if (MSG_vm_is_migrating(vm)) THROWF(vm_error, 0, "VM(%s) is already migrating", sg_host_get_name(vm)); - msg_host_priv_t priv = sg_host_msg(vm); - priv->is_migrating = 1; + simgrid::surf::VirtualMachineImpl* pimpl = static_cast(vm->pimpl_); + pimpl->isMigrating = 1; { int ret = do_migration(vm, old_pm, new_pm); if (ret == -1){ - priv->is_migrating = 0; - THROWF(host_error, 0, "SRC host failed during migration"); + pimpl->isMigrating = 0; + THROWF(host_error, 0, "SRC host failed during migration"); } else if(ret == -2){ - priv->is_migrating = 0; - THROWF(host_error, 0, "DST host failed during migration"); + pimpl->isMigrating = 0; + THROWF(host_error, 0, "DST host failed during migration"); } }