Plugins:
- Revamp the battery plugin: rewrite completely the API, for a better usability.
+ The examples were updated accordingly.
----------------------------------------------------------------------------
battery->set_load("load", 100);
- auto handler1 = battery->schedule_handler(0.2, simgrid::plugins::Battery::DISCHARGE, true, [battery]() {
- XBT_INFO("%f,%f,SoC", simgrid::s4u::Engine::get_clock(), battery->get_state_of_charge());
- XBT_INFO("%f,%f,SoH", simgrid::s4u::Engine::get_clock(), battery->get_state_of_health());
- battery->set_load("load", -100);
- });
+ auto handler1 = battery->schedule_handler(
+ 0.2, simgrid::plugins::Battery::DISCHARGE, simgrid::plugins::Battery::Handler::PERSISTANT, [battery]() {
+ XBT_INFO("%f,%f,SoC", simgrid::s4u::Engine::get_clock(), battery->get_state_of_charge());
+ XBT_INFO("%f,%f,SoH", simgrid::s4u::Engine::get_clock(), battery->get_state_of_health());
+ battery->set_load("load", -100);
+ });
std::shared_ptr<simgrid::plugins::Battery::Handler> handler2;
- handler2 = battery->schedule_handler(0.8, simgrid::plugins::Battery::CHARGE, true, [battery, handler1, handler2]() {
- XBT_INFO("%f,%f,SoC", simgrid::s4u::Engine::get_clock(), battery->get_state_of_charge());
- XBT_INFO("%f,%f,SoH", simgrid::s4u::Engine::get_clock(), battery->get_state_of_health());
- if (battery->get_state_of_health() < 0.1) {
- battery->delete_handler(handler1);
- battery->delete_handler(handler2);
- }
- battery->set_load("load", 100);
- });
+ handler2 = battery->schedule_handler(
+ 0.8, simgrid::plugins::Battery::CHARGE, simgrid::plugins::Battery::Handler::PERSISTANT,
+ [battery, handler1, handler2]() {
+ XBT_INFO("%f,%f,SoC", simgrid::s4u::Engine::get_clock(), battery->get_state_of_charge());
+ XBT_INFO("%f,%f,SoH", simgrid::s4u::Engine::get_clock(), battery->get_state_of_health());
+ if (battery->get_state_of_health() < 0.1) {
+ battery->delete_handler(handler1);
+ battery->delete_handler(handler2);
+ }
+ battery->set_load("load", 100);
+ });
}
int main(int argc, char* argv[])
auto* host2 = simgrid::s4u::Engine::get_instance()->host_by_name("MyHost2");
auto* host3 = simgrid::s4u::Engine::get_instance()->host_by_name("MyHost3");
- battery->schedule_handler(0.2, simgrid::plugins::Battery::DISCHARGE, true, [battery, &host1, &host2, &host3]() {
- XBT_INFO("Handler -> Battery low: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
- battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
- battery->get_energy_provided(), battery->get_energy_consumed());
- XBT_INFO("Disconnecting hosts %s and %s", host1->get_cname(), host2->get_cname());
- battery->connect_host(host1, false);
- battery->connect_host(host2, false);
- XBT_INFO("Energy consumed this far by: %s: %fJ, %s: %fJ, %s: %fJ", host1->get_cname(),
- sg_host_get_consumed_energy(host1), host2->get_cname(), sg_host_get_consumed_energy(host2),
- host3->get_cname(), sg_host_get_consumed_energy(host3));
- });
+ battery->schedule_handler(
+ 0.2, simgrid::plugins::Battery::DISCHARGE, simgrid::plugins::Battery::Handler::PERSISTANT,
+ [battery, &host1, &host2, &host3]() {
+ XBT_INFO("Handler -> Battery low: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
+ battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
+ battery->get_energy_provided(), battery->get_energy_consumed());
+ XBT_INFO("Disconnecting hosts %s and %s", host1->get_cname(), host2->get_cname());
+ battery->connect_host(host1, false);
+ battery->connect_host(host2, false);
+ XBT_INFO("Energy consumed this far by: %s: %fJ, %s: %fJ, %s: %fJ", host1->get_cname(),
+ sg_host_get_consumed_energy(host1), host2->get_cname(), sg_host_get_consumed_energy(host2),
+ host3->get_cname(), sg_host_get_consumed_energy(host3));
+ });
XBT_INFO("Battery state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
battery->set_load("load", load_w);
XBT_INFO("Set load to %fW", load_w);
- battery->schedule_handler(0.2, simgrid::plugins::Battery::DISCHARGE, true, [battery, &load_w]() {
- XBT_INFO("Discharged state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
- battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
- battery->get_energy_provided(), battery->get_energy_consumed());
- battery->set_load("load", -load_w);
- XBT_INFO("Set load to %fW", -load_w);
- });
-
- battery->schedule_handler(0.8, simgrid::plugins::Battery::CHARGE, true, [battery]() {
- XBT_INFO("Charged state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
- battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
- battery->get_energy_provided(), battery->get_energy_consumed());
- XBT_INFO("Set load to %fW", 0.0);
- });
+ battery->schedule_handler(
+ 0.2, simgrid::plugins::Battery::DISCHARGE, simgrid::plugins::Battery::Handler::PERSISTANT, [battery, &load_w]() {
+ XBT_INFO("Discharged state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
+ battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
+ battery->get_energy_provided(), battery->get_energy_consumed());
+ battery->set_load("load", -load_w);
+ XBT_INFO("Set load to %fW", -load_w);
+ });
+
+ battery->schedule_handler(
+ 0.8, simgrid::plugins::Battery::CHARGE, simgrid::plugins::Battery::Handler::PERSISTANT, [battery]() {
+ XBT_INFO("Charged state: SoC: %f SoH: %f Energy stored: %fJ Energy provided: %fJ Energy consumed %fJ",
+ battery->get_state_of_charge(), battery->get_state_of_health(), battery->get_energy_stored(),
+ battery->get_energy_provided(), battery->get_energy_consumed());
+ XBT_INFO("Set load to %fW", 0.0);
+ });
e.run();
return 0;
class Handler {
friend Battery;
+ public:
+ enum Persistancy { PERSISTANT, ONESHOT };
+
private:
double state_of_charge_;
Flow flow_;
double time_delta_ = -1;
std::function<void()> callback_;
- bool repeat_;
+ Persistancy persistancy_;
public:
- Handler(double state_of_charge, Flow flow, bool repeat, std::function<void()> callback);
- static std::shared_ptr<Handler> init(double state_of_charge, Flow flow, bool repeat,
+ Handler(double state_of_charge, Flow flow, Persistancy p, std::function<void()> callback);
+ static std::shared_ptr<Handler> init(double state_of_charge, Flow flow, Persistancy p,
std::function<void()> callback);
/** @ingroup plugin_battery
* @return true if its a recurrent Handler.
* @note For Battery::Handler objects
*/
- bool get_repeat() { return repeat_; }
+ Persistancy get_persistancy() { return persistancy_; }
};
private:
double get_energy_provided();
double get_energy_consumed();
double get_energy_stored(std::string unit = "J");
- std::shared_ptr<Handler> schedule_handler(double state_of_charge, Flow flow, bool repeat,
+ std::shared_ptr<Handler> schedule_handler(double state_of_charge, Flow flow, Handler::Persistancy p,
std::function<void()> callback);
std::vector<std::shared_ptr<Handler>> get_handlers();
void delete_handler(std::shared_ptr<Handler> handler);
/* Handler */
-Battery::Handler::Handler(double state_of_charge, Flow flow, bool repeat, std::function<void()> callback)
- : state_of_charge_(state_of_charge), flow_(flow), callback_(callback), repeat_(repeat)
+Battery::Handler::Handler(double state_of_charge, Flow flow, Persistancy p, std::function<void()> callback)
+ : state_of_charge_(state_of_charge), flow_(flow), callback_(callback), persistancy_(p)
{
}
-std::shared_ptr<Battery::Handler> Battery::Handler::init(double state_of_charge, Flow flow, bool repeat,
+std::shared_ptr<Battery::Handler> Battery::Handler::init(double state_of_charge, Flow flow, Persistancy p,
std::function<void()> callback)
{
- return std::make_shared<Battery::Handler>(state_of_charge, flow, repeat, callback);
+ return std::make_shared<Battery::Handler>(state_of_charge, flow, p, callback);
}
/* Battery */
for (auto handler : handlers_) {
if (abs(handler->time_delta_ - time_delta_s) < 0.000000001) {
handler->callback_();
- if (handler->repeat_)
+ if (handler->persistancy_ == Handler::Persistancy::PERSISTANT)
handler->time_delta_ = -1;
else
to_delete.push_back(handler);
* @param state_of_charge The state of charge at which the Handler will happen.
* @param flow The flow in which the Handler will happen, either when the Battery is charging or discharging.
* @param callback The callable to trigger when the Handler happen.
- * @param repeat If the Handler is recurrent or unique.
+ * @param Persistancy If the Handler is recurrent or unique.
* @return A shared pointer of the new Handler.
*/
-std::shared_ptr<Battery::Handler> Battery::schedule_handler(double state_of_charge, Flow flow, bool repeat, std::function<void()> callback)
+std::shared_ptr<Battery::Handler> Battery::schedule_handler(double state_of_charge, Flow flow, Handler::Persistancy p,
+ std::function<void()> callback)
{
- auto handler = Handler::init(state_of_charge, flow, repeat, callback);
+ auto handler = Handler::init(state_of_charge, flow, p, callback);
handlers_.push_back(handler);
return handler;
}