X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/88fad0aaff9eb463f048bfdfe4ad6218aba44ddb..HEAD:/src/kernel/resource/Action.cpp diff --git a/src/kernel/resource/Action.cpp b/src/kernel/resource/Action.cpp index 9e64d25dad..9651cde842 100644 --- a/src/kernel/resource/Action.cpp +++ b/src/kernel/resource/Action.cpp @@ -1,31 +1,28 @@ -/* Copyright (c) 2004-2018. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2004-2023. 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 "simgrid/kernel/resource/Action.hpp" #include "simgrid/kernel/resource/Model.hpp" +#include "src/kernel/EngineImpl.hpp" #include "src/kernel/lmm/maxmin.hpp" -#include "src/surf/surf_interface.hpp" +#include "src/simgrid/math_utils.h" -XBT_LOG_NEW_CATEGORY(kernel, "Logging specific to the internals of SimGrid"); -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(resource, kernel, "Logging specific to the resources"); +XBT_LOG_NEW_CATEGORY(kernel, "SimGrid internals"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ker_resource, kernel, "Resources, modeling the platform performance"); -namespace simgrid { -namespace kernel { -namespace resource { +namespace simgrid::kernel::resource { -Action::Action(simgrid::kernel::resource::Model* model, double cost, bool failed) : Action(model, cost, failed, nullptr) -{ -} +Action::Action(Model* model, double cost, bool failed) : Action(model, cost, failed, nullptr) {} -Action::Action(simgrid::kernel::resource::Model* model, double cost, bool failed, kernel::lmm::Variable* var) - : remains_(cost), start_time_(surf_get_clock()), cost_(cost), model_(model), variable_(var) +Action::Action(Model* model, double cost, bool failed, lmm::Variable* var) + : remains_(cost), start_time_(EngineImpl::get_clock()), cost_(cost), model_(model), variable_(var) { if (failed) - state_set_ = get_model()->get_failed_action_set(); + state_set_ = model_->get_failed_action_set(); else - state_set_ = get_model()->get_running_action_set(); + state_set_ = model_->get_started_action_set(); state_set_->push_back(*this); } @@ -33,54 +30,56 @@ Action::Action(simgrid::kernel::resource::Model* model, double cost, bool failed Action::~Action() { if (state_set_hook_.is_linked()) - simgrid::xbt::intrusive_erase(*state_set_, *this); + xbt::intrusive_erase(*state_set_, *this); if (get_variable()) - get_model()->get_maxmin_system()->variable_free(get_variable()); - if (get_model()->getUpdateMechanism() == Model::UpdateAlgo::Lazy) { - /* remove from heap */ - heapRemove(); - if (modified_set_hook_.is_linked()) - simgrid::xbt::intrusive_erase(*get_model()->get_modified_set(), *this); - } + model_->get_maxmin_system()->variable_free(get_variable()); - xbt_free(category_); + /* remove from heap on need (ie, if selective update) */ + model_->get_action_heap().remove(this); + if (modified_set_hook_.is_linked()) + xbt::intrusive_erase(*model_->get_modified_set(), *this); } void Action::finish(Action::State state) { - finish_time_ = surf_get_clock(); - set_state(state); + finish_time_ = EngineImpl::get_clock(); set_remains(0); + set_state(state); } Action::State Action::get_state() const { - if (state_set_ == model_->get_ready_action_set()) - return Action::State::ready; - if (state_set_ == model_->get_running_action_set()) - return Action::State::running; + if (state_set_ == model_->get_inited_action_set()) + return Action::State::INITED; + if (state_set_ == model_->get_started_action_set()) + return Action::State::STARTED; if (state_set_ == model_->get_failed_action_set()) - return Action::State::failed; - if (state_set_ == model_->get_done_action_set()) - return Action::State::done; - return Action::State::not_in_the_system; + return Action::State::FAILED; + if (state_set_ == model_->get_finished_action_set()) + return Action::State::FINISHED; + if (state_set_ == model_->get_ignored_action_set()) + return Action::State::IGNORED; + THROW_IMPOSSIBLE; } void Action::set_state(Action::State state) { - simgrid::xbt::intrusive_erase(*state_set_, *this); + xbt::intrusive_erase(*state_set_, *this); switch (state) { - case Action::State::ready: - state_set_ = model_->get_ready_action_set(); + case Action::State::INITED: + state_set_ = model_->get_inited_action_set(); break; - case Action::State::running: - state_set_ = model_->get_running_action_set(); + case Action::State::STARTED: + state_set_ = model_->get_started_action_set(); break; - case Action::State::failed: + case Action::State::FAILED: state_set_ = model_->get_failed_action_set(); break; - case Action::State::done: - state_set_ = model_->get_done_action_set(); + case Action::State::FINISHED: + state_set_ = model_->get_finished_action_set(); + break; + case Action::State::IGNORED: + state_set_ = model_->get_ignored_action_set(); break; default: state_set_ = nullptr; @@ -95,22 +94,22 @@ double Action::get_bound() const return variable_ ? variable_->get_bound() : 0; } +double Action::get_rate() const +{ + return variable_ ? variable_->get_value() * factor_ : 0; +} + void Action::set_bound(double bound) { XBT_IN("(%p,%g)", this, bound); if (variable_) - get_model()->get_maxmin_system()->update_variable_bound(variable_, bound); + model_->get_maxmin_system()->update_variable_bound(variable_, bound); - if (get_model()->getUpdateMechanism() == Model::UpdateAlgo::Lazy && get_last_update() != surf_get_clock()) - heapRemove(); + if (model_->is_update_lazy() && get_last_update() != EngineImpl::get_clock()) + model_->get_action_heap().remove(this); XBT_OUT(); } -void Action::set_category(const char* category) -{ - category_ = xbt_strdup(category); -} - void Action::ref() { refcount_++; @@ -119,54 +118,53 @@ void Action::ref() void Action::set_max_duration(double duration) { max_duration_ = duration; - if (get_model()->getUpdateMechanism() == Model::UpdateAlgo::Lazy) // remove action from the heap - heapRemove(); + if (model_->is_update_lazy()) // remove action from the heap + model_->get_action_heap().remove(this); } -void Action::set_priority(double weight) +void Action::set_sharing_penalty(double sharing_penalty) { - XBT_IN("(%p,%g)", this, weight); - sharing_priority_ = weight; - get_model()->get_maxmin_system()->update_variable_weight(get_variable(), weight); - - if (get_model()->getUpdateMechanism() == Model::UpdateAlgo::Lazy) - heapRemove(); + XBT_IN("(%p,%g)", this, sharing_penalty); + sharing_penalty_ = sharing_penalty; + model_->get_maxmin_system()->update_variable_penalty(get_variable(), sharing_penalty); + if (model_->is_update_lazy()) + model_->get_action_heap().remove(this); XBT_OUT(); } void Action::cancel() { - set_state(Action::State::failed); - if (get_model()->getUpdateMechanism() == Model::UpdateAlgo::Lazy) { + set_state(Action::State::FAILED); + if (model_->is_update_lazy()) { if (modified_set_hook_.is_linked()) - simgrid::xbt::intrusive_erase(*get_model()->get_modified_set(), *this); - heapRemove(); + xbt::intrusive_erase(*model_->get_modified_set(), *this); + model_->get_action_heap().remove(this); } } -int Action::unref() +bool Action::unref() { refcount_--; if (not refcount_) { delete this; - return 1; + return true; } - return 0; + return false; } void Action::suspend() { XBT_IN("(%p)", this); - if (suspended_ != SuspendStates::sleeping) { - get_model()->get_maxmin_system()->update_variable_weight(get_variable(), 0.0); - if (get_model()->getUpdateMechanism() == Model::UpdateAlgo::Lazy) { - heapRemove(); - if (state_set_ == get_model()->get_running_action_set() && sharing_priority_ > 0) { + if (suspended_ != SuspendStates::SLEEPING) { + model_->get_maxmin_system()->update_variable_penalty(get_variable(), 0.0); + if (model_->is_update_lazy()) { + model_->get_action_heap().remove(this); + if (state_set_ == model_->get_started_action_set() && sharing_penalty_ > 0) { // If we have a lazy model, we need to update the remaining value accordingly - update_remains_lazy(surf_get_clock()); + update_remains_lazy(EngineImpl::get_clock()); } } - suspended_ = SuspendStates::suspended; + suspended_ = SuspendStates::SUSPENDED; } XBT_OUT(); } @@ -174,75 +172,77 @@ void Action::suspend() void Action::resume() { XBT_IN("(%p)", this); - if (suspended_ != SuspendStates::sleeping) { - get_model()->get_maxmin_system()->update_variable_weight(get_variable(), get_priority()); - suspended_ = SuspendStates::not_suspended; - if (get_model()->getUpdateMechanism() == Model::UpdateAlgo::Lazy) - heapRemove(); + if (suspended_ != SuspendStates::SLEEPING) { + model_->get_maxmin_system()->update_variable_penalty(get_variable(), get_sharing_penalty()); + suspended_ = SuspendStates::RUNNING; + if (model_->is_update_lazy()) + model_->get_action_heap().remove(this); } XBT_OUT(); } -bool Action::is_suspended() +double Action::get_remains() { - return suspended_ == SuspendStates::suspended; + XBT_IN("(%p)", this); + /* update remains before returning it */ + if (model_->is_update_lazy()) /* update remains before return it */ + update_remains_lazy(EngineImpl::get_clock()); + XBT_OUT(); + return remains_; } -/* insert action on heap using a given key and a hat (heap_action_type) - * a hat can be of three types for communications: - * - * NORMAL = this is a normal heap entry stating the date to finish transmitting - * LATENCY = this is a heap entry to warn us when the latency is payed - * MAX_DURATION =this is a heap entry to warn us when the max_duration limit is reached - */ -void Action::heapInsert(double key, Action::Type hat) + +void Action::update_max_duration(double delta) { - type_ = hat; - heap_hook_ = get_model()->getActionHeap().emplace(std::make_pair(key, this)); + if (max_duration_ != NO_MAX_DURATION) + double_update(&max_duration_, delta, sg_precision_timing); } -void Action::heapRemove() +void Action::update_remains(double delta) { - type_ = Action::Type::NOTSET; - if (heap_hook_) { - get_model()->getActionHeap().erase(*heap_hook_); - clearHeapHandle(); - } + double_update(&remains_, delta, sg_precision_workamount * sg_precision_timing); } -void Action::heapUpdate(double key, Action::Type hat) +void Action::set_last_update() { - type_ = hat; - if (heap_hook_) { - get_model()->getActionHeap().update(*heap_hook_, std::make_pair(key, this)); - } else { - heap_hook_ = get_model()->getActionHeap().emplace(std::make_pair(key, this)); - } + last_update_ = EngineImpl::get_clock(); } -double Action::get_remains() +double ActionHeap::top_date() const { - XBT_IN("(%p)", this); - /* update remains before return it */ - if (get_model()->getUpdateMechanism() == Model::UpdateAlgo::Lazy) /* update remains before return it */ - update_remains_lazy(surf_get_clock()); - XBT_OUT(); - return remains_; + return top().first; } -void Action::update_max_duration(double delta) +void ActionHeap::insert(Action* action, double date, ActionHeap::Type type) { - double_update(&max_duration_, delta, sg_surf_precision); + action->type_ = type; + action->heap_hook_ = emplace(std::make_pair(date, action)); } -void Action::update_remains(double delta) + +void ActionHeap::remove(Action* action) { - double_update(&remains_, delta, sg_maxmin_precision * sg_surf_precision); + action->type_ = ActionHeap::Type::unset; + if (action->heap_hook_) { + erase(*action->heap_hook_); + action->heap_hook_ = boost::none; + } } -void Action::set_last_update() +void ActionHeap::update(Action* action, double date, ActionHeap::Type type) +{ + action->type_ = type; + if (action->heap_hook_) { + heap_type::update(*action->heap_hook_, std::make_pair(date, action)); + } else { + action->heap_hook_ = emplace(std::make_pair(date, action)); + } +} + +Action* ActionHeap::pop() { - last_update_ = surf_get_clock(); + Action* action = top().second; + heap_type::pop(); + action->heap_hook_ = boost::none; + return action; } -} // namespace surf -} // namespace simgrid -} // namespace simgrid +} // namespace simgrid::kernel::resource