-/* Copyright (c) 2007-2020. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2021. 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. */
#include <unordered_set>
-XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_host);
+XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(res_host);
XBT_LOG_EXTERNAL_CATEGORY(xbt_cfg);
/**************************************/
set_maxmin_system(sys);
loopback_ = NetworkL07Model::create_link("__loopback__",
std::vector<double>{simgrid::config::get_value<double>("network/loopback-bw")},
- simgrid::config::get_value<double>("network/loopback-lat"),
- s4u::Link::SharingPolicy::FATPIPE);
+ s4u::Link::SharingPolicy::FATPIPE)->set_latency(simgrid::config::get_value<double>("network/loopback-lat"));
+ loopback_->seal();
}
NetworkL07Model::~NetworkL07Model()
{
double min = HostModel::next_occurring_event_full(now);
for (kernel::resource::Action const& action : *get_started_action_set()) {
- const L07Action& net_action = static_cast<const L07Action&>(action);
+ const auto& net_action = static_cast<const L07Action&>(action);
if (net_action.get_latency() > 0 && (min < 0 || net_action.get_latency() < min)) {
min = net_action.get_latency();
XBT_DEBUG("Updating min with %p (start %f): %f", &net_action, net_action.get_start_time(), min);
void HostL07Model::update_actions_state(double /*now*/, double delta)
{
for (auto it = std::begin(*get_started_action_set()); it != std::end(*get_started_action_set());) {
- L07Action& action = static_cast<L07Action&>(*it);
+ auto& action = static_cast<L07Action&>(*it);
++it; // increment iterator here since the following calls to action.finish() may invalidate it
if (action.get_latency() > 0) {
if (action.get_latency() > delta) {
kernel::resource::Action* NetworkL07Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
{
std::vector<s4u::Host*> host_list = {src, dst};
- const double* flops_amount = new double[2]();
- double* bytes_amount = new double[4]();
+ const auto* flops_amount = new double[2]();
+ auto* bytes_amount = new double[4]();
bytes_amount[1] = size;
}
kernel::resource::LinkImpl* NetworkL07Model::create_link(const std::string& name, const std::vector<double>& bandwidths,
- double latency, s4u::Link::SharingPolicy policy)
+ s4u::Link::SharingPolicy policy)
{
xbt_assert(bandwidths.size() == 1, "Non WIFI link must have only 1 bandwidth.");
- return new LinkL07(this, name, bandwidths[0], latency, policy);
+ return new LinkL07(this, name, bandwidths[0], policy);
}
/************
************/
CpuL07::CpuL07(CpuL07Model* model, simgrid::s4u::Host* host, const std::vector<double>& speed_per_pstate, int core)
- : Cpu(model, host, model->get_maxmin_system()->constraint_new(this, speed_per_pstate.front()), speed_per_pstate,
- core)
+ : Cpu(host, speed_per_pstate)
{
+ this->set_core_count(core)->set_model(model)->set_constraint(
+ model->get_maxmin_system()->constraint_new(this, speed_per_pstate.front()));
}
CpuL07::~CpuL07()=default;
-LinkL07::LinkL07(NetworkL07Model* model, const std::string& name, double bandwidth, double latency,
- s4u::Link::SharingPolicy policy)
+LinkL07::LinkL07(NetworkL07Model* model, const std::string& name, double bandwidth, s4u::Link::SharingPolicy policy)
: LinkImpl(model, name, model->get_maxmin_system()->constraint_new(this, bandwidth))
{
bandwidth_.peak = bandwidth;
- latency_.peak = latency;
if (policy == s4u::Link::SharingPolicy::FATPIPE)
get_constraint()->unshare();
-
- s4u::Link::on_creation(*get_iface());
}
kernel::resource::CpuAction* CpuL07::execution_start(double size)
{
- std::vector<s4u::Host*> host_list = {get_host()};
+ std::vector<s4u::Host*> host_list = {get_iface()};
- double* flops_amount = new double[host_list.size()]();
+ auto* flops_amount = new double[host_list.size()]();
flops_amount[0] = size;
kernel::resource::CpuAction* res =
kernel::resource::CpuAction* CpuL07::sleep(double duration)
{
- L07Action *action = static_cast<L07Action*>(execution_start(1.0));
+ auto* action = static_cast<L07Action*>(execution_start(1.0));
action->set_max_duration(duration);
action->set_suspend_state(kernel::resource::Action::SuspendStates::SLEEPING);
get_model()->get_maxmin_system()->update_variable_penalty(action->get_variable(), 0.0);
return action;
}
-bool CpuL07::is_used()
+bool CpuL07::is_used() const
{
return get_model()->get_maxmin_system()->constraint_used(get_constraint());
}
Cpu::on_speed_change();
}
-bool LinkL07::is_used()
+bool LinkL07::is_used() const
{
return get_model()->get_maxmin_system()->constraint_used(get_constraint());
}
} else if (triggered == state_event_) {
if (value > 0) {
if (not is_on()) {
- XBT_VERB("Restart actors on host %s", get_host()->get_cname());
- get_host()->turn_on();
+ XBT_VERB("Restart actors on host %s", get_iface()->get_cname());
+ get_iface()->turn_on();
}
} else
- get_host()->turn_off();
+ get_iface()->turn_off();
tmgr_trace_event_unref(&state_event_);
} else {
get_model()->get_maxmin_system()->update_constraint_bound(get_constraint(), bandwidth_.peak * bandwidth_.scale);
}
-void LinkL07::set_latency(double value)
+kernel::resource::LinkImpl* LinkL07::set_latency(double value)
{
+ latency_check(value);
const kernel::lmm::Variable* var;
L07Action *action;
const kernel::lmm::Element* elem = nullptr;
action = static_cast<L07Action*>(var->get_id());
action->updateBound();
}
+ return this;
}
LinkL07::~LinkL07() = default;
