-/* Copyright (c) 2006-2018. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2019. The SimGrid Team. All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
/** @brief Fire the required callbacks and destroy the object
*
- * Don't delete directly an Host, call h->destroy() instead.
+ * 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
{
simgrid::simix::simcall([this, key, value] { this->pimpl_->set_property(key, value); });
}
+/** 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 simgrid::simix::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 simgrid::simix::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); });
}
-/** @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().
}
/** @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
{
/**
* @ingroup simix_storage_management
- * @brief Returns the list of storages attached to an host.
+ * @brief Returns the list of storages attached to a host.
* @return a vector containing all storages attached to the host
*/
std::vector<const char*> Host::get_attached_storages() const
{
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();
return host->is_off();
}
-/** @brief Get the properties of an host */
+/** @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);
}
}
-/** @brief Return the list of actors attached to an host.
+/** @brief Return the list of actors attached to a host.
*
* @param host a host
* @param whereto a dynar in which we should push actors living on that host
