xbt::signal<void(Host const&)> Host::on_state_change;
xbt::signal<void(Host const&)> Host::on_speed_change;
+Host* Host::set_cpu(kernel::resource::CpuImpl* cpu)
+{
+ pimpl_cpu_ = cpu;
+ return this;
+}
+
+#ifndef DOXYGEN
Host* Host::set_netpoint(kernel::routing::NetPoint* netpoint)
{
pimpl_netpoint_ = netpoint;
{
if (pimpl_netpoint_ != nullptr) // not removed yet by a children class
Engine::get_instance()->netpoint_unregister(pimpl_netpoint_);
- delete pimpl_cpu;
+ delete pimpl_cpu_;
}
+#endif
/** @brief Fire the required callbacks and destroy the object
*
{
if (not is_on()) {
kernel::actor::simcall([this] {
- this->pimpl_cpu->turn_on();
+ this->pimpl_cpu_->turn_on();
this->pimpl_->turn_on();
on_state_change(*this);
});
vm->shutdown();
vm->turn_off();
}
- this->pimpl_cpu->turn_off();
+ this->pimpl_cpu_->turn_off();
this->pimpl_->turn_off(self);
on_state_change(*this);
bool Host::is_on() const
{
- return this->pimpl_cpu->is_on();
+ return this->pimpl_cpu_->is_on();
}
int Host::get_pstate_count() const
{
- return this->pimpl_cpu->get_pstate_count();
+ return this->pimpl_cpu_->get_pstate_count();
}
/**
}
/** @brief Returns how many actors (daemonized or not) have been launched on this host */
-int Host::get_actor_count() const
+size_t Host::get_actor_count() const
{
return pimpl_->get_actor_count();
}
}
/** @brief Returns the networking zone englobing that host */
-NetZone* Host::get_englobing_zone()
+NetZone* Host::get_englobing_zone() const
{
return pimpl_netpoint_->get_englobing_zone()->get_iface();
}
-void Host::sendto(Host* dest, double byte_amount) // deprecated 331
+#ifndef DOXYGEN
+void Host::sendto(Host* dest, double byte_amount) // XBT_ATTRIB_DEPRECATED_v331
{
Comm::sendto_async(this, dest, byte_amount)->wait();
}
-CommPtr Host::sendto_async(Host* dest, double byte_amount) // deprecated 331
+CommPtr Host::sendto_async(Host* dest, double byte_amount) // XBT_ATTRIB_DEPRECATED_v331
{
return Comm::sendto_async(this, dest, byte_amount);
}
-void Host::send_to(Host* dest, double byte_amount) // deprecated 330
+void Host::send_to(Host* dest, double byte_amount) // XBT_ATTRIB_DEPRECATED_v330
{
Comm::sendto(this, dest, byte_amount);
}
+#endif
/** Get the properties assigned to a host */
const std::unordered_map<std::string, std::string>* Host::get_properties() const
* The profile must contain boolean values. */
Host* Host::set_state_profile(kernel::profile::Profile* p)
{
- kernel::actor::simcall([this, p] { pimpl_cpu->set_state_profile(p); });
+ kernel::actor::simcall([this, p] { pimpl_cpu_->set_state_profile(p); });
return this;
}
/** Specify a profile modeling the external load according to an exhaustive list or a stochastic law.
*/
Host* Host::set_speed_profile(kernel::profile::Profile* p)
{
- kernel::actor::simcall([this, p] { pimpl_cpu->set_speed_profile(p); });
+ kernel::actor::simcall([this, p] { pimpl_cpu_->set_speed_profile(p); });
return this;
}
/** @brief Get the peak processor speed (in flops/s), at the specified pstate */
double Host::get_pstate_speed(int pstate_index) const
{
- return this->pimpl_cpu->get_pstate_peak_speed(pstate_index);
+ return this->pimpl_cpu_->get_pstate_peak_speed(pstate_index);
}
double Host::get_speed() const
{
- return this->pimpl_cpu->get_speed(1.0);
+ return this->pimpl_cpu_->get_speed(1.0);
}
double Host::get_load() const
{
- return this->pimpl_cpu->get_load();
+ return this->pimpl_cpu_->get_load();
}
double Host::get_available_speed() const
{
- return this->pimpl_cpu->get_speed_ratio();
+ return this->pimpl_cpu_->get_speed_ratio();
}
int Host::get_core_count() const
{
- return this->pimpl_cpu->get_core_count();
+ return this->pimpl_cpu_->get_core_count();
}
Host* Host::set_core_count(int core_count)
{
- kernel::actor::simcall([this, core_count] { this->pimpl_cpu->set_core_count(core_count); });
+ kernel::actor::simcall([this, core_count] { this->pimpl_cpu_->set_core_count(core_count); });
return this;
}
Host* Host::set_pstate_speed(const std::vector<double>& speed_per_state)
{
- kernel::actor::simcall([this, &speed_per_state] { pimpl_cpu->set_pstate_speed(speed_per_state); });
+ kernel::actor::simcall([this, &speed_per_state] { pimpl_cpu_->set_pstate_speed(speed_per_state); });
return this;
}
speed_list.reserve(speed_per_state.size());
for (const auto& speed_str : speed_per_state) {
try {
- double speed = xbt_parse_get_speed("", 0, speed_str.c_str(), nullptr, "");
+ double speed = xbt_parse_get_speed("", 0, speed_str, "");
speed_list.push_back(speed);
} catch (const simgrid::ParseError&) {
throw std::invalid_argument(std::string("Invalid speed value: ") + speed_str);
/** @brief Set the pstate at which the host should run */
Host* Host::set_pstate(int pstate_index)
{
- kernel::actor::simcall([this, pstate_index] { this->pimpl_cpu->set_pstate(pstate_index); });
+ kernel::actor::simcall([this, pstate_index] { this->pimpl_cpu_->set_pstate(pstate_index); });
return this;
}
/** @brief Retrieve the pstate at which the host is currently running */
int Host::get_pstate() const
{
- return this->pimpl_cpu->get_pstate();
+ return this->pimpl_cpu_->get_pstate();
}
+Host* Host::set_coordinates(const std::string& coords)
+{
+ if (not coords.empty())
+ kernel::actor::simcall([this, coords] { this->pimpl_netpoint_->set_coordinates(coords); });
+ return this;
+}
std::vector<Disk*> Host::get_disks() const
{
return this->pimpl_->get_disks();
Disk* Host::create_disk(const std::string& name, double read_bandwidth, double write_bandwidth)
{
return kernel::actor::simcall([this, &name, read_bandwidth, write_bandwidth] {
- return this->pimpl_->create_disk(name, read_bandwidth, write_bandwidth);
+ auto* disk = pimpl_->create_disk(name, read_bandwidth, write_bandwidth);
+ pimpl_->add_disk(disk);
+ return disk;
});
}
Disk* Host::create_disk(const std::string& name, const std::string& read_bandwidth, const std::string& write_bandwidth)
{
- double d_read, d_write;
+ double d_read;
try {
- d_read = xbt_parse_get_bandwidth("", 0, read_bandwidth.c_str(), nullptr, "");
+ d_read = xbt_parse_get_bandwidth("", 0, read_bandwidth, "");
} catch (const simgrid::ParseError&) {
- throw std::invalid_argument(std::string("Impossible to create disk: ") + name.c_str() +
+ throw std::invalid_argument(std::string("Impossible to create disk: ") + name +
std::string(". Invalid read bandwidth: ") + read_bandwidth);
}
+ double d_write;
try {
- d_write = xbt_parse_get_bandwidth("", 0, write_bandwidth.c_str(), nullptr, "");
+ d_write = xbt_parse_get_bandwidth("", 0, write_bandwidth, "");
} catch (const simgrid::ParseError&) {
- throw std::invalid_argument(std::string("Impossible to create disk: ") + name.c_str() +
+ throw std::invalid_argument(std::string("Impossible to create disk: ") + name +
std::string(". Invalid write bandwidth: ") + write_bandwidth);
}
return create_disk(name, d_read, d_write);
xbt_assert(host_count > 0, "There is no host!");
std::vector<simgrid::s4u::Host*> hosts = e->get_all_hosts();
- sg_host_t* res = xbt_new(sg_host_t, hosts.size());
+ auto* res = xbt_new(sg_host_t, hosts.size());
std::copy(begin(hosts), end(hosts), res);
return res;
return sg_host_get_speed(host);
}
-/** @brief Return the speed of the processor (in flop/s) at a given pstate. See also @ref plugin_energy.
+/** @brief Return the speed of the processor (in flop/s) at a given pstate. See also @ref plugin_host_energy.
*
* @param host host to test
* @param pstate_index pstate to test
/** @brief Returns the number of power states for a host.
*
- * See also @ref plugin_energy.
+ * See also @ref plugin_host_energy.
*/
int sg_host_get_nb_pstates(const_sg_host_t host)
{
/** @brief Gets the pstate at which that host currently runs.
*
- * See also @ref plugin_energy.
+ * See also @ref plugin_host_energy.
*/
int sg_host_get_pstate(const_sg_host_t host)
{
}
/** @brief Sets the pstate at which that host should run.
*
- * See also @ref plugin_energy.
+ * See also @ref plugin_host_energy.
*/
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() 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_host_energy
* for more info on DVFS.
*/
void sg_host_turn_on(sg_host_t host)
*
* @brief Stop the host if it is on
*
- * See also #MSG_host_is_on() 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_host_energy
* for more info on DVFS.
*/
void sg_host_turn_off(sg_host_t host)
/** @ingroup m_host_management
* @brief Determine if a host is up and running.
*
- * 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.
+ * See also #sg_host_turn_on() and #sg_host_turn_off() to switch the host ON and OFF and @ref plugin_host_energy for
+ * more info on DVFS.
*
* @param host host to test
* @return Returns true if the host is up and running, and false if it's currently down
