Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
cosmetics
[simgrid.git] / src / kernel / resource / Action.cpp
1 /* Copyright (c) 2004-2019. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "simgrid/kernel/resource/Action.hpp"
7 #include "simgrid/kernel/resource/Model.hpp"
8 #include "src/kernel/lmm/maxmin.hpp"
9 #include "src/surf/surf_interface.hpp"
10 #include "surf/surf.hpp"
11
12 XBT_LOG_NEW_CATEGORY(kernel, "Logging specific to the internals of SimGrid");
13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(resource, kernel, "Logging specific to the resources");
14
15 namespace simgrid {
16 namespace kernel {
17 namespace resource {
18
19 Action::Action(simgrid::kernel::resource::Model* model, double cost, bool failed) : Action(model, cost, failed, nullptr)
20 {
21 }
22
23 Action::Action(simgrid::kernel::resource::Model* model, double cost, bool failed, kernel::lmm::Variable* var)
24     : remains_(cost), start_time_(surf_get_clock()), cost_(cost), model_(model), variable_(var)
25 {
26   if (failed)
27     state_set_ = get_model()->get_failed_action_set();
28   else
29     state_set_ = get_model()->get_started_action_set();
30
31   state_set_->push_back(*this);
32 }
33
34 Action::~Action()
35 {
36   if (state_set_hook_.is_linked())
37     simgrid::xbt::intrusive_erase(*state_set_, *this);
38   if (get_variable())
39     get_model()->get_maxmin_system()->variable_free(get_variable());
40
41   /* remove from heap on need (ie, if selective update) */
42   get_model()->get_action_heap().remove(this);
43   if (modified_set_hook_.is_linked())
44     simgrid::xbt::intrusive_erase(*get_model()->get_modified_set(), *this);
45 }
46
47 void Action::finish(Action::State state)
48 {
49   finish_time_ = surf_get_clock();
50   set_remains(0);
51   set_state(state);
52 }
53
54 Action::State Action::get_state() const
55 {
56   if (state_set_ == model_->get_inited_action_set())
57     return Action::State::INITED;
58   if (state_set_ == model_->get_started_action_set())
59     return Action::State::STARTED;
60   if (state_set_ == model_->get_failed_action_set())
61     return Action::State::FAILED;
62   if (state_set_ == model_->get_finished_action_set())
63     return Action::State::FINISHED;
64   if (state_set_ == model_->get_ignored_action_set())
65     return Action::State::IGNORED;
66   THROW_IMPOSSIBLE;
67 }
68
69 void Action::set_state(Action::State state)
70 {
71   simgrid::xbt::intrusive_erase(*state_set_, *this);
72   switch (state) {
73     case Action::State::INITED:
74       state_set_ = model_->get_inited_action_set();
75       break;
76     case Action::State::STARTED:
77       state_set_ = model_->get_started_action_set();
78       break;
79     case Action::State::FAILED:
80       state_set_ = model_->get_failed_action_set();
81       break;
82     case Action::State::FINISHED:
83       state_set_ = model_->get_finished_action_set();
84       break;
85     case Action::State::IGNORED:
86       state_set_ = model_->get_ignored_action_set();
87       break;
88     default:
89       state_set_ = nullptr;
90       break;
91   }
92   if (state_set_)
93     state_set_->push_back(*this);
94 }
95
96 double Action::get_bound() const
97 {
98   return variable_ ? variable_->get_bound() : 0;
99 }
100
101 void Action::set_bound(double bound)
102 {
103   XBT_IN("(%p,%g)", this, bound);
104   if (variable_)
105     get_model()->get_maxmin_system()->update_variable_bound(variable_, bound);
106
107   if (get_model()->get_update_algorithm() == Model::UpdateAlgo::LAZY && get_last_update() != surf_get_clock())
108     get_model()->get_action_heap().remove(this);
109   XBT_OUT();
110 }
111
112 void Action::ref()
113 {
114   refcount_++;
115 }
116
117 void Action::set_max_duration(double duration)
118 {
119   max_duration_ = duration;
120   if (get_model()->get_update_algorithm() == Model::UpdateAlgo::LAZY) // remove action from the heap
121     get_model()->get_action_heap().remove(this);
122 }
123
124 void Action::set_sharing_penalty(double sharing_penalty)
125 {
126   XBT_IN("(%p,%g)", this, sharing_penalty);
127   sharing_penalty_ = sharing_penalty;
128   get_model()->get_maxmin_system()->update_variable_penalty(get_variable(), sharing_penalty);
129
130   if (get_model()->get_update_algorithm() == Model::UpdateAlgo::LAZY)
131     get_model()->get_action_heap().remove(this);
132   XBT_OUT();
133 }
134
135 void Action::cancel()
136 {
137   set_state(Action::State::FAILED);
138   if (get_model()->get_update_algorithm() == Model::UpdateAlgo::LAZY) {
139     if (modified_set_hook_.is_linked())
140       simgrid::xbt::intrusive_erase(*get_model()->get_modified_set(), *this);
141     get_model()->get_action_heap().remove(this);
142   }
143 }
144
145 bool Action::unref()
146 {
147   refcount_--;
148   if (not refcount_) {
149     delete this;
150     return true;
151   }
152   return false;
153 }
154
155 void Action::suspend()
156 {
157   XBT_IN("(%p)", this);
158   if (suspended_ != SuspendStates::SLEEPING) {
159     get_model()->get_maxmin_system()->update_variable_penalty(get_variable(), 0.0);
160     if (get_model()->get_update_algorithm() == Model::UpdateAlgo::LAZY) {
161       get_model()->get_action_heap().remove(this);
162       if (state_set_ == get_model()->get_started_action_set() && sharing_penalty_ > 0) {
163         // If we have a lazy model, we need to update the remaining value accordingly
164         update_remains_lazy(surf_get_clock());
165       }
166     }
167     suspended_ = SuspendStates::SUSPENDED;
168   }
169   XBT_OUT();
170 }
171
172 void Action::resume()
173 {
174   XBT_IN("(%p)", this);
175   if (suspended_ != SuspendStates::SLEEPING) {
176     get_model()->get_maxmin_system()->update_variable_penalty(get_variable(), get_sharing_penalty());
177     suspended_ = SuspendStates::RUNNING;
178     if (get_model()->get_update_algorithm() == Model::UpdateAlgo::LAZY)
179       get_model()->get_action_heap().remove(this);
180   }
181   XBT_OUT();
182 }
183
184 double Action::get_remains()
185 {
186   XBT_IN("(%p)", this);
187   /* update remains before returning it */
188   if (get_model()->get_update_algorithm() == Model::UpdateAlgo::LAZY) /* update remains before return it */
189     update_remains_lazy(surf_get_clock());
190   XBT_OUT();
191   return remains_;
192 }
193
194 void Action::update_max_duration(double delta)
195 {
196   if (max_duration_ != NO_MAX_DURATION)
197     double_update(&max_duration_, delta, sg_surf_precision);
198 }
199 void Action::update_remains(double delta)
200 {
201   double_update(&remains_, delta, sg_maxmin_precision * sg_surf_precision);
202 }
203
204 void Action::set_last_update()
205 {
206   last_update_ = surf_get_clock();
207 }
208
209 double ActionHeap::top_date() const
210 {
211   return top().first;
212 }
213 void ActionHeap::insert(Action* action, double date, ActionHeap::Type type)
214 {
215   action->type_      = type;
216   action->heap_hook_ = emplace(std::make_pair(date, action));
217 }
218 void ActionHeap::remove(Action* action)
219 {
220   action->type_ = ActionHeap::Type::unset;
221   if (action->heap_hook_) {
222     erase(*action->heap_hook_);
223     action->heap_hook_ = boost::none;
224   }
225 }
226 void ActionHeap::update(Action* action, double date, ActionHeap::Type type)
227 {
228   action->type_ = type;
229   if (action->heap_hook_) {
230     heap_type::update(*action->heap_hook_, std::make_pair(date, action));
231   } else {
232     action->heap_hook_ = emplace(std::make_pair(date, action));
233   }
234 }
235 Action* ActionHeap::pop()
236 {
237   Action* action = top().second;
238   heap_type::pop();
239   action->heap_hook_ = boost::none;
240   return action;
241 }
242
243 } // namespace resource
244 } // namespace kernel
245 } // namespace simgrid