X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/96cedde3cdbc0b8ffc3f096a1b65d021b0226f99..a73d204e173f35c0abb92b26e061929066b8b283:/src/s4u/s4u_Host.cpp diff --git a/src/s4u/s4u_Host.cpp b/src/s4u/s4u_Host.cpp index 24163be788..1d89a9e811 100644 --- a/src/s4u/s4u_Host.cpp +++ b/src/s4u/s4u_Host.cpp @@ -7,42 +7,43 @@ #include "simgrid/s4u/Actor.hpp" #include "simgrid/s4u/Engine.hpp" #include "simgrid/s4u/Exec.hpp" +#include "simgrid/s4u/VirtualMachine.hpp" +#include "src/plugins/vm/VirtualMachineImpl.hpp" +#include "src/simix/smx_private.hpp" #include "src/surf/HostImpl.hpp" +#include #include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_host, s4u, "Logging specific to the S4U hosts"); XBT_LOG_EXTERNAL_CATEGORY(surf_route); -int USER_HOST_LEVEL = -1; - namespace simgrid { - namespace xbt { -template class Extendable; -} +template class Extendable; +} // namespace xbt namespace s4u { -simgrid::xbt::signal Host::on_creation; -simgrid::xbt::signal Host::on_destruction; -simgrid::xbt::signal Host::on_state_change; -simgrid::xbt::signal Host::on_speed_change; +xbt::signal Host::on_creation; +xbt::signal Host::on_destruction; +xbt::signal Host::on_state_change; +xbt::signal Host::on_speed_change; -Host::Host(std::string name) : name_(name) +Host::Host(const std::string& name) : name_(name) { - xbt_assert(Host::by_name_or_null(name) == nullptr, "Refusing to create a second host named '%s'.", name.c_str()); - Engine::get_instance()->host_register(std::string(name_), this); - new simgrid::surf::HostImpl(this); + xbt_assert(Host::by_name_or_null(name_) == nullptr, "Refusing to create a second host named '%s'.", get_cname()); + Engine::get_instance()->host_register(name_, this); + new surf::HostImpl(this); } Host::~Host() { - xbt_assert(currentlyDestroying_, "Please call h->destroy() instead of manually deleting it."); + xbt_assert(currently_destroying_, "Please call h->destroy() instead of manually deleting it."); delete pimpl_; if (pimpl_netpoint != nullptr) // not removed yet by a children class - simgrid::s4u::Engine::get_instance()->netpoint_unregister(pimpl_netpoint); + Engine::get_instance()->netpoint_unregister(pimpl_netpoint); delete pimpl_cpu; delete mounts_; } @@ -51,41 +52,40 @@ Host::~Host() * * Don't delete directly a host, call h->destroy() instead. * - * This is cumbersome but this is the simplest solution to ensure that the - * onDestruction() callback receives a valid object (because of the destructor - * order in a class hierarchy). + * This is cumbersome but this is the simplest solution to ensure that the onDestruction() callback receives a valid + * object (because of the destructor order in a class hierarchy). */ void Host::destroy() { - if (not currentlyDestroying_) { - currentlyDestroying_ = true; + if (not currently_destroying_) { + currently_destroying_ = true; on_destruction(*this); Engine::get_instance()->host_unregister(std::string(name_)); delete this; } } -Host* Host::by_name(std::string name) +Host* Host::by_name(const std::string& name) { return Engine::get_instance()->host_by_name(name); } -Host* Host::by_name_or_null(std::string name) +Host* Host::by_name_or_null(const std::string& name) { return Engine::get_instance()->host_by_name_or_null(name); } Host* Host::current() { - smx_actor_t smx_proc = SIMIX_process_self(); - if (smx_proc == nullptr) + kernel::actor::ActorImpl* self = SIMIX_process_self(); + if (self == nullptr) xbt_die("Cannot call Host::current() from the maestro context"); - return smx_proc->host_; + return self->get_host(); } void Host::turn_on() { - if (is_off()) { - simgrid::simix::simcall([this] { + if (not is_on()) { + kernel::actor::simcall([this] { this->pimpl_cpu->turn_on(); this->pimpl_->turn_on(); on_state_change(*this); @@ -97,7 +97,12 @@ void Host::turn_on() void Host::turn_off() { if (is_on()) { - simgrid::simix::simcall([this] { + kernel::actor::simcall([this] { + for (VirtualMachine* const& vm : vm::VirtualMachineImpl::allVms_) + if (vm->get_pm() == this) { + vm->shutdown(); + vm->turn_off(); + } this->pimpl_cpu->turn_off(); this->pimpl_->turn_off(); @@ -132,22 +137,6 @@ int Host::get_actor_count() return pimpl_->get_actor_count(); } -/** @deprecated */ -void Host::getProcesses(std::vector* list) -{ - auto actors = get_all_actors(); - for (auto& actor : actors) - list->push_back(actor); -} - -/** @deprecated */ -void Host::actorList(std::vector* whereto) -{ - auto actors = get_all_actors(); - for (auto& actor : actors) - whereto->push_back(actor); -} - /** * @brief Find a route toward another host * @@ -171,7 +160,7 @@ void Host::route_to(Host* dest, std::vector& links, double* latency) /** @brief Just like Host::routeTo, but filling an array of link implementations */ void Host::route_to(Host* dest, std::vector& links, double* latency) { - simgrid::kernel::routing::NetZoneImpl::get_global_route(pimpl_netpoint, dest->pimpl_netpoint, links, latency); + kernel::routing::NetZoneImpl::get_global_route(pimpl_netpoint, dest->pimpl_netpoint, links, latency); if (XBT_LOG_ISENABLED(surf_route, xbt_log_priority_debug)) { XBT_CDEBUG(surf_route, "Route from '%s' to '%s' (latency: %f):", get_cname(), dest->get_cname(), (latency == nullptr ? -1 : *latency)); @@ -180,36 +169,72 @@ void Host::route_to(Host* dest, std::vector& links, } } +/** @brief Returns the networking zone englobing that host */ +NetZone* Host::get_englobing_zone() +{ + return pimpl_netpoint->get_englobing_zone()->get_iface(); +} + +void Host::send_to(Host* dest, double byte_amount) +{ + std::vector m_host_list = {this, dest}; + std::vector flops_amount = {0, 0}; + std::vector bytes_amount = {0, byte_amount, 0, 0}; + this_actor::parallel_execute(m_host_list, flops_amount, bytes_amount); +} + /** Get the properties assigned to a host */ -std::unordered_map* Host::get_properties() +const std::unordered_map* Host::get_properties() const { - return simgrid::simix::simcall([this] { return this->pimpl_->get_properties(); }); + return this->pimpl_->get_properties(); } /** Retrieve the property value (or nullptr if not set) */ -const char* Host::get_property(std::string key) const +const char* Host::get_property(const std::string& key) const { return this->pimpl_->get_property(key); } -void Host::set_property(std::string key, std::string value) +void Host::set_property(const std::string& key, const std::string& value) { - simgrid::simix::simcall([this, key, value] { this->pimpl_->set_property(key, value); }); + kernel::actor::simcall([this, &key, &value] { this->pimpl_->set_property(key, value); }); +} + +void Host::set_properties(const std::map& properties) +{ + kernel::actor::simcall([this, &properties] { this->pimpl_->set_properties(properties); }); +} + +/** Specify a profile turning the host on and off according to a exhaustive list or a stochastic law. + * The profile must contain boolean values. */ +void Host::set_state_profile(kernel::profile::Profile* p) +{ + return kernel::actor::simcall([this, p] { pimpl_cpu->set_state_profile(p); }); +} +/** Specify a profile modeling the external load according to a exhaustive list or a stochastic law. + * + * Each event of the profile represent a peak speed change that is due to external load. The values are given as a rate + * of the initial value. This means that the actual value is obtained by multiplying the initial value (the peek speed + * at this pstate level) by the rate coming from the profile. + */ +void Host::set_speed_profile(kernel::profile::Profile* p) +{ + return kernel::actor::simcall([this, p] { pimpl_cpu->set_speed_profile(p); }); } /** @brief Get the peak processor speed (in flops/s), at the specified pstate */ double Host::get_pstate_speed(int pstate_index) const { - return simgrid::simix::simcall([this, pstate_index] { return this->pimpl_cpu->get_pstate_peak_speed(pstate_index); }); + return this->pimpl_cpu->get_pstate_peak_speed(pstate_index); } -/** @brief Get the peak computing speed in flops/s at the current pstate, taking the external load into account. +/** @brief Get the peak computing speed in flops/s at the current pstate, NOT taking the external load into account. * * The amount of flops per second available for computing depends on several things: * - The current pstate determines the maximal peak computing speed (use @ref get_pstate_speed() to retrieve the * computing speed you would get at another pstate) - * - If you declared an external load, then this reduces the available computing speed - * (see @ref simgrid::surf::Cpu::set_speed_trace()) + * - If you declared an external load (with @ref simgrid::surf::Cpu::set_speed_profile()), you must multiply the + * result of get_speed() by get_available_speed() to retrieve what a new computation would get. * * The remaining speed is then shared between the executions located on this host. * You can retrieve the amount of tasks currently running on this host with @ref get_load(). @@ -233,7 +258,7 @@ double Host::get_load() const } /** @brief Get the available speed ratio, between 0 and 1. * - * This accounts for external load (see @ref simgrid::surf::Cpu::set_speed_trace()). + * This accounts for external load (see @ref simgrid::surf::Cpu::set_speed_profile()). */ double Host::get_available_speed() const { @@ -249,7 +274,7 @@ int Host::get_core_count() const /** @brief Set the pstate at which the host should run */ void Host::set_pstate(int pstate_index) { - simgrid::simix::simcall([this, pstate_index] { this->pimpl_cpu->set_pstate(pstate_index); }); + kernel::actor::simcall([this, pstate_index] { this->pimpl_cpu->set_pstate(pstate_index); }); } /** @brief Retrieve the pstate at which the host is currently running */ int Host::get_pstate() const @@ -257,6 +282,20 @@ int Host::get_pstate() const return this->pimpl_cpu->get_pstate(); } +std::vector Host::get_disks() const +{ + return kernel::actor::simcall([this] { return this->pimpl_->get_disks(); }); +} + +void Host::add_disk(Disk* disk) +{ + kernel::actor::simcall([this, disk] { this->pimpl_->add_disk(disk); }); +} + +void Host::remove_disk(const std::string& disk_name) +{ + kernel::actor::simcall([this, disk_name] { this->pimpl_->remove_disk(disk_name); }); +} /** * @ingroup simix_storage_management * @brief Returns the list of storages attached to a host. @@ -264,15 +303,7 @@ int Host::get_pstate() const */ std::vector Host::get_attached_storages() const { - return simgrid::simix::simcall([this] { return this->pimpl_->get_attached_storages(); }); -} - -void Host::getAttachedStorages(std::vector* storages) -{ - std::vector local_storages = - simgrid::simix::simcall([this] { return this->pimpl_->get_attached_storages(); }); - for (auto elm : local_storages) - storages->push_back(elm); + return kernel::actor::simcall([this] { return this->pimpl_->get_attached_storages(); }); } std::unordered_map const& Host::get_mounted_storages() @@ -288,16 +319,17 @@ std::unordered_map const& Host::get_mounted_storages() ExecPtr Host::exec_async(double flops) { - return this_actor::exec_init(flops)->set_host(this); + return this_actor::exec_init(flops); } void Host::execute(double flops) { execute(flops, 1.0 /* priority */); } + void Host::execute(double flops, double priority) { - this_actor::exec_init(flops)->set_host(this)->set_priority(1 / priority)->start()->wait(); + this_actor::exec_init(flops)->set_priority(1 / priority)->start()->wait(); } } // namespace s4u @@ -323,7 +355,7 @@ sg_host_t* sg_host_list() xbt_assert(sg_host_count() > 0, "There is no host!"); std::vector hosts = simgrid::s4u::Engine::get_instance()->get_all_hosts(); - sg_host_t* res = (sg_host_t*)malloc(sizeof(sg_host_t) * hosts.size()); + sg_host_t* res = xbt_new(sg_host_t, hosts.size()); memcpy(res, hosts.data(), sizeof(sg_host_t) * hosts.size()); return res; @@ -349,40 +381,43 @@ sg_host_t sg_host_by_name(const char* name) return simgrid::s4u::Host::by_name_or_null(name); } -static int hostcmp_voidp(const void* pa, const void* pb) -{ - return strcmp((*static_cast(pa))->get_cname(), - (*static_cast(pb))->get_cname()); -} - xbt_dynar_t sg_hosts_as_dynar() { - xbt_dynar_t res = xbt_dynar_new(sizeof(sg_host_t), nullptr); - std::vector list = simgrid::s4u::Engine::get_instance()->get_all_hosts(); - for (auto const& host : list) { - if (host && host->pimpl_netpoint && host->pimpl_netpoint->is_host()) - xbt_dynar_push(res, &host); - } - xbt_dynar_sort(res, hostcmp_voidp); + auto last = std::remove_if(begin(list), end(list), [](const simgrid::s4u::Host* host) { + return not host || not host->pimpl_netpoint || not host->pimpl_netpoint->is_host(); + }); + std::sort(begin(list), last, + [](const simgrid::s4u::Host* a, const simgrid::s4u::Host* b) { return a->get_name() < b->get_name(); }); + + xbt_dynar_t res = xbt_dynar_new(sizeof(sg_host_t), nullptr); + std::for_each(begin(list), last, [res](sg_host_t host) { xbt_dynar_push_as(res, sg_host_t, host); }); return res; } // ========= Layering madness ==============* // ========== User data Layer ========== -void* sg_host_user(sg_host_t host) +void* sg_host_data(sg_host_t host) +{ + return host->get_data(); +} +void sg_host_data_set(sg_host_t host, void* userdata) +{ + host->set_data(userdata); +} +void* sg_host_user(sg_host_t host) // deprecated { - return host->extension(USER_HOST_LEVEL); + return host->get_data(); } -void sg_host_user_set(sg_host_t host, void* userdata) +void sg_host_user_set(sg_host_t host, void* userdata) // deprecated { - host->extension_set(USER_HOST_LEVEL, userdata); + host->set_data(userdata); } -void sg_host_user_destroy(sg_host_t host) +void sg_host_user_destroy(sg_host_t host) // deprecated { - host->extension_set(USER_HOST_LEVEL, nullptr); + host->set_data(nullptr); } // ========= storage related functions ============ @@ -473,7 +508,7 @@ void sg_host_set_pstate(sg_host_t host, int pstate) * * @brief Start the host if it is off * - * See also #sg_host_is_on() and #sg_host_is_off() to test the current state of the host and @ref plugin_energy + * See also #sg_host_is_on() to test the current state of the host and @ref plugin_energy * for more info on DVFS. */ void sg_host_turn_on(sg_host_t host) @@ -485,7 +520,7 @@ void sg_host_turn_on(sg_host_t host) * * @brief Stop the host if it is on * - * See also #MSG_host_is_on() and #MSG_host_is_off() to test the current state of the host and @ref plugin_energy + * See also #MSG_host_is_on() to test the current state of the host and @ref plugin_energy * for more info on DVFS. */ void sg_host_turn_off(sg_host_t host) @@ -507,22 +542,11 @@ int sg_host_is_on(sg_host_t host) return host->is_on(); } -/** @ingroup m_host_management - * @brief Determine if a host is currently off. - * - * See also #sg_host_turn_on() and #sg_host_turn_off() to switch the host ON and OFF and @ref plugin_energy for more - * info on DVFS. - */ -int sg_host_is_off(sg_host_t host) -{ - return host->is_off(); -} - /** @brief Get the properties of a host */ xbt_dict_t sg_host_get_properties(sg_host_t host) { xbt_dict_t as_dict = xbt_dict_new_homogeneous(xbt_free_f); - std::unordered_map* props = host->get_properties(); + const std::unordered_map* props = host->get_properties(); if (props == nullptr) return nullptr; for (auto const& elm : *props) { @@ -595,13 +619,18 @@ double sg_host_route_bandwidth(sg_host_t from, sg_host_t to) return min_bandwidth; } +void sg_host_send_to(sg_host_t from, sg_host_t to, double byte_amount) +{ + from->send_to(to, byte_amount); +} + /** @brief Displays debugging information about a host */ void sg_host_dump(sg_host_t host) { XBT_INFO("Displaying host %s", host->get_cname()); XBT_INFO(" - speed: %.0f", host->get_speed()); XBT_INFO(" - available speed: %.2f", sg_host_get_available_speed(host)); - std::unordered_map* props = host->get_properties(); + const std::unordered_map* props = host->get_properties(); if (not props->empty()) { XBT_INFO(" - properties:"); @@ -626,7 +655,17 @@ void sg_host_get_actor_list(sg_host_t host, xbt_dynar_t whereto) sg_host_t sg_host_self() { smx_actor_t process = SIMIX_process_self(); - return (process == nullptr) ? nullptr : process->host_; + return (process == nullptr) ? nullptr : process->get_host(); +} + +/* needs to be public and without simcall for exceptions and logging events */ +const char* sg_host_self_get_name() +{ + sg_host_t host = sg_host_self(); + if (host == nullptr || SIMIX_process_self() == simix_global->maestro_process) + return ""; + + return host->get_cname(); } double sg_host_load(sg_host_t host)