: NetworkModel(Model::UpdateAlgo::FULL), hostModel_(hmodel)
{
set_maxmin_system(sys);
- loopback_ = NetworkL07Model::create_link("__loopback__", std::vector<double>{498000000}, 0.000015,
- s4u::Link::SharingPolicy::FATPIPE);
+ 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);
}
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) {
L07Action::L07Action(kernel::resource::Model* model, const std::vector<s4u::Host*>& host_list,
const double* flops_amount, const double* bytes_amount, double rate)
- : CpuAction(model, 1, 0), computationAmount_(flops_amount), communicationAmount_(bytes_amount), rate_(rate)
+ : CpuAction(model, 1.0, false), computationAmount_(flops_amount), communicationAmount_(bytes_amount), rate_(rate)
{
size_t link_nb = 0;
size_t used_host_nb = 0; /* Only the hosts with something to compute (>0 flops) are counted) */
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;
{
std::vector<s4u::Host*> host_list = {get_host()};
- 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());
}
get_model()->get_maxmin_system()->update_constraint_bound(get_constraint(), speed_.peak * speed_.scale);
while ((var = get_constraint()->get_variable(&elem))) {
- const kernel::resource::Action* action = static_cast<kernel::resource::Action*>(var->get_id());
+ const kernel::resource::Action* action = var->get_id();
get_model()->get_maxmin_system()->update_variable_bound(action->get_variable(), speed_.scale * speed_.peak);
}
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 processes on host %s", get_host()->get_cname());
+ XBT_VERB("Restart actors on host %s", get_host()->get_cname());
get_host()->turn_on();
}
} else