}
}
-bool Host::is_on()
+bool Host::is_on() const
{
return this->pimpl_cpu->is_on();
}
int Host::get_pstate_count() const
{
- return this->pimpl_cpu->get_pstates_count();
+ return this->pimpl_cpu->get_pstate_count();
}
/**
}
/** Get the properties assigned to a host */
-std::map<std::string, std::string>* Host::getProperties()
+std::unordered_map<std::string, std::string>* Host::get_properties()
{
- return simgrid::simix::simcall([this] { return this->pimpl_->getProperties(); });
+ return simgrid::simix::simcall([this] { return this->pimpl_->get_properties(); });
}
/** Retrieve the property value (or nullptr if not set) */
-const char* Host::get_property(const char* key)
+const char* Host::get_property(const char* key) const
{
- return this->pimpl_->getProperty(key);
+ return this->pimpl_->get_property(key);
}
void Host::set_property(std::string key, std::string value)
{
- simgrid::simix::simcall([this, key, value] { this->pimpl_->setProperty(key, value); });
+ simgrid::simix::simcall([this, key, value] { this->pimpl_->set_property(key, value); });
}
/** @brief Get the peak processor speed (in flops/s), at the specified pstate */
-double Host::getPstateSpeed(int pstate_index)
+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); });
}
-/** @brief Get the peak processor speed in flops/s, (under full load (=1.0), at the current pstate)
+/** @brief Get the peak computing speed in flops/s at the current pstate, taking the external load into account.
*
- * The result also takes 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 set_speed_trace())
+ *
+ * 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().
+ *
+ * The host may have multiple cores, and your executions may be able to use more than a single core.
+ *
+ * Finally, executions of priority 2 get twice the amount of flops than executions of priority 1.
*/
-double Host::getSpeed()
+double Host::get_speed() const
{
return this->pimpl_cpu->get_speed(1.0);
}
+/** @brief Returns the current computation load (in flops per second)
+ * The external load (coming from an availability trace) is not taken in account.
+ */
+double Host::get_load() const
+{
+ return this->pimpl_cpu->get_load();
+}
/** @brief Get the available speed ratio, between 0 and 1.
*
* This accounts for external load (see @ref set_speed_trace()).
*/
-double Host::get_available_speed()
+double Host::get_available_speed() const
{
return this->pimpl_cpu->get_speed_ratio();
}
/** @brief Returns the number of core of the processor. */
-int Host::get_core_count()
+int Host::get_core_count() const
{
- return this->pimpl_cpu->get_cores_count();
+ return this->pimpl_cpu->get_core_count();
}
/** @brief Set the pstate at which the host should run */
simgrid::simix::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()
+int Host::get_pstate() const
{
return this->pimpl_cpu->get_pstate();
}
* \brief Returns the list of storages attached to an host.
* \return a vector containing all storages attached to the host
*/
-std::vector<const char*> Host::get_attached_storages()
+std::vector<const char*> Host::get_attached_storages() const
{
return simgrid::simix::simcall([this] { return this->pimpl_->get_attached_storages(); });
}
storages->push_back(elm);
}
-std::unordered_map<std::string, Storage*> const& Host::getMountedStorages()
+std::unordered_map<std::string, Storage*> const& Host::get_mounted_storages()
{
if (mounts_ == nullptr) {
mounts_ = new std::unordered_map<std::string, Storage*>();
simcall_execution_wait(s);
}
-double Host::getLoad()
-{
- return this->pimpl_cpu->get_load();
-}
-
} // namespace s4u
} // namespace simgrid
{
xbt_assert((host != nullptr), "Invalid parameters");
xbt_dict_t res = xbt_dict_new_homogeneous(nullptr);
- for (auto const& elm : host->getMountedStorages()) {
+ 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);
/** @brief Returns the total speed of a host */
double sg_host_speed(sg_host_t host)
{
- return host->getSpeed();
+ return host->get_speed();
}
/** \brief Return the speed of the processor (in flop/s) at a given pstate. See also @ref plugin_energy.
*/
double sg_host_get_pstate_speed(sg_host_t host, int pstate_index)
{
- return host->getPstateSpeed(pstate_index);
+ return host->get_pstate_speed(pstate_index);
}
/** \ingroup m_host_management
xbt_dict_t sg_host_get_properties(sg_host_t host)
{
xbt_dict_t as_dict = xbt_dict_new_homogeneous(xbt_free_f);
- std::map<std::string, std::string>* props = host->getProperties();
+ std::unordered_map<std::string, std::string>* props = host->get_properties();
if (props == nullptr)
return nullptr;
for (auto const& elm : *props) {
void sg_host_dump(sg_host_t host)
{
XBT_INFO("Displaying host %s", host->get_cname());
- XBT_INFO(" - speed: %.0f", host->getSpeed());
+ XBT_INFO(" - speed: %.0f", host->get_speed());
XBT_INFO(" - available speed: %.2f", sg_host_get_available_speed(host));
- std::map<std::string, std::string>* props = host->getProperties();
+ std::unordered_map<std::string, std::string>* props = host->get_properties();
if (not props->empty()) {
XBT_INFO(" - properties:");
