#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 <algorithm>
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
- Engine::get_instance()->netpoint_unregister(pimpl_netpoint);
+ if (pimpl_netpoint_ != nullptr) // not removed yet by a children class
+ Engine::get_instance()->netpoint_unregister(pimpl_netpoint_);
delete pimpl_cpu;
delete mounts_;
}
Host* Host::current()
{
- kernel::actor::ActorImpl* self = SIMIX_process_self();
+ kernel::actor::ActorImpl* self = kernel::actor::ActorImpl::self();
if (self == nullptr)
xbt_die("Cannot call Host::current() from the maestro context");
return self->get_host();
void Host::turn_off()
{
if (is_on()) {
- kernel::actor::simcall([this] {
+ kernel::actor::ActorImpl* self = kernel::actor::ActorImpl::self();
+ kernel::actor::simcall([this, self] {
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();
+ this->pimpl_->turn_off(self);
on_state_change(*this);
});
std::vector<kernel::resource::LinkImpl*> linkImpls;
this->route_to(dest, linkImpls, latency);
for (kernel::resource::LinkImpl* const& l : linkImpls)
- links.push_back(&l->piface_);
+ links.push_back(l->get_iface());
}
/** @brief Just like Host::routeTo, but filling an array of link implementations */
void Host::route_to(Host* dest, std::vector<kernel::resource::LinkImpl*>& links, double* latency)
{
- kernel::routing::NetZoneImpl::get_global_route(pimpl_netpoint, dest->pimpl_netpoint, links, latency);
+ kernel::routing::NetZoneImpl::get_global_route(pimpl_netpoint_, dest->get_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));
/** @brief Returns the networking zone englobing that host */
NetZone* Host::get_englobing_zone()
{
- return pimpl_netpoint->get_englobing_zone()->get_iface();
+ return pimpl_netpoint_->get_englobing_zone()->get_iface();
}
void Host::send_to(Host* dest, double byte_amount)
if (mounts_ == nullptr) {
mounts_ = new std::unordered_map<std::string, Storage*>();
for (auto const& m : this->pimpl_->storage_) {
- mounts_->insert({m.first, &m.second->piface_});
+ mounts_->insert({m.first, m.second->get_iface()});
}
}
return *mounts_;
std::vector<simgrid::s4u::Host*> list = simgrid::s4u::Engine::get_instance()->get_all_hosts();
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();
+ return not host || not host->get_netpoint() || not host->get_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_dict_t res = xbt_dict_new_homogeneous(nullptr);
for (auto const& elm : host->get_mounted_storages()) {
const char* mount_name = elm.first.c_str();
- sg_storage_t storage = elm.second;
- xbt_dict_set(res, mount_name, (void*)storage->get_cname(), nullptr);
+ const simgrid::s4u::Storage* storage = elm.second;
+ xbt_dict_set(res, mount_name, (void*)storage->get_cname());
}
return res;
return host->is_on();
}
-/** @deprecated */
-int sg_host_is_off(sg_host_t host)
-{
- return not host->is_on();
-}
-
/** @brief Get the properties of a host */
xbt_dict_t sg_host_get_properties(sg_host_t host)
{
if (props == nullptr)
return nullptr;
for (auto const& elm : *props) {
- xbt_dict_set(as_dict, elm.first.c_str(), xbt_strdup(elm.second.c_str()), nullptr);
+ xbt_dict_set(as_dict, elm.first.c_str(), xbt_strdup(elm.second.c_str()));
}
return as_dict;
}
return res;
}
/**
- * @brief Find the bandwitdh of the route between two hosts
+ * @brief Find the bandwidth of the route between two hosts
*
* @param from where from
* @param to where to
*/
void sg_host_get_actor_list(sg_host_t host, xbt_dynar_t whereto)
{
- auto actors = host->get_all_actors();
- for (auto& actor : actors)
+ auto const actors = host->get_all_actors();
+ for (auto const& actor : actors)
xbt_dynar_push(whereto, &actor);
}
sg_host_t sg_host_self()
{
- smx_actor_t process = SIMIX_process_self();
- return (process == nullptr) ? nullptr : process->get_host();
+ return SIMIX_is_maestro() ? nullptr : simgrid::kernel::actor::ActorImpl::self()->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();
+ return SIMIX_is_maestro() ? "" : simgrid::kernel::actor::ActorImpl::self()->get_host()->get_cname();
}
double sg_host_load(sg_host_t host)
