doneActionSet_ = new ActionList();
modifiedSet_ = nullptr;
- actionHeap_ = nullptr;
updateMechanism_ = UM_UNDEFINED;
selectiveUpdate_ = 0;
}
delete doneActionSet_;
}
+Action* Model::actionHeapPop()
+{
+ Action* action = actionHeap_.top().second;
+ actionHeap_.pop();
+ action->clearHeapHandle();
+ return action;
+}
+
double Model::nextOccuringEvent(double now)
{
//FIXME: set the good function once and for all
action->updateRemainingLazy(now);
double min = -1;
- double share = lmm_variable_getvalue(action->getVariable());
+ double share = action->getVariable()->get_value();
if (share > 0) {
double time_to_completion;
}
//hereafter must have already the min value for this resource model
- if (xbt_heap_size(actionHeap_) > 0) {
- double min = xbt_heap_maxkey(actionHeap_) - now;
+ if (not actionHeapIsEmpty()) {
+ double min = actionHeapTopDate() - now;
XBT_DEBUG("minimum with the HEAP %f", min);
return min;
} else {
maxminSystem_->solve_fun(maxminSystem_);
double min = -1;
- for (auto it(getRunningActionSet()->begin()), itend(getRunningActionSet()->end()); it != itend ; ++it) {
- Action *action = &*it;
- double value = lmm_variable_getvalue(action->getVariable());
+
+ for (Action& action : *getRunningActionSet()) {
+ double value = action.getVariable()->get_value();
if (value > 0) {
- if (action->getRemains() > 0)
- value = action->getRemainsNoUpdate() / value;
+ if (action.getRemains() > 0)
+ value = action.getRemainsNoUpdate() / value;
else
value = 0.0;
if (min < 0 || value < min) {
min = value;
- XBT_DEBUG("Updating min (value) with %p: %f", action, min);
+ XBT_DEBUG("Updating min (value) with %p: %f", &action, min);
}
}
- if ((action->getMaxDuration() >= 0) && (min<0 || action->getMaxDuration() < min)) {
- min = action->getMaxDuration();
- XBT_DEBUG("Updating min (duration) with %p: %f", action, min);
+ if ((action.getMaxDuration() >= 0) && (min < 0 || action.getMaxDuration() < min)) {
+ min = action.getMaxDuration();
+ XBT_DEBUG("Updating min (duration) with %p: %f", &action, min);
}
}
XBT_DEBUG("min value : %f", min);
"SURF_ACTION_NOT_IN_THE_SYSTEM"
};
-/* added to manage the communication action's heap */
-void surf_action_lmm_update_index_heap(void *action, int i) {
- static_cast<simgrid::surf::Action*>(action)->updateIndexHeap(i);
-}
-
namespace simgrid {
namespace surf {
setState(state);
}
-Action::State Action::getState()
+Action::State Action::getState() const
{
if (stateSet_ == model_->getReadyActionSet())
return Action::State::ready;
stateSet_->push_back(*this);
}
-double Action::getBound()
+double Action::getBound() const
{
- return (variable_) ? lmm_variable_getbound(variable_) : 0;
+ return variable_ ? variable_->get_bound() : 0;
}
void Action::setBound(double bound)
{
XBT_IN("(%p,%g)", this, bound);
if (variable_)
- lmm_update_variable_bound(getModel()->getMaxminSystem(), variable_, bound);
+ getModel()->getMaxminSystem()->update_variable_bound(variable_, bound);
if (getModel()->getUpdateMechanism() == UM_LAZY && getLastUpdate() != surf_get_clock())
heapRemove(getModel()->getActionHeap());
XBT_OUT();
}
-double Action::getStartTime()
-{
- return start_;
-}
-
-double Action::getFinishTime()
-{
- return finishTime_;
-}
-
-void Action::setData(void* data)
-{
- data_ = data;
-}
-
void Action::setCategory(const char *category)
{
category_ = xbt_strdup(category);
{
XBT_IN("(%p,%g)", this, weight);
sharingWeight_ = weight;
- lmm_update_variable_weight(getModel()->getMaxminSystem(), getVariable(), weight);
+ getModel()->getMaxminSystem()->update_variable_weight(getVariable(), weight);
if (getModel()->getUpdateMechanism() == UM_LAZY)
heapRemove(getModel()->getActionHeap());
if (action_hook.is_linked())
stateSet_->erase(stateSet_->iterator_to(*this));
if (getVariable())
- lmm_variable_free(getModel()->getMaxminSystem(), getVariable());
+ getModel()->getMaxminSystem()->variable_free(getVariable());
if (getModel()->getUpdateMechanism() == UM_LAZY) {
/* remove from heap */
heapRemove(getModel()->getActionHeap());
{
XBT_IN("(%p)", this);
if (suspended_ != 2) {
- lmm_update_variable_weight(getModel()->getMaxminSystem(), getVariable(), 0.0);
+ getModel()->getMaxminSystem()->update_variable_weight(getVariable(), 0.0);
if (getModel()->getUpdateMechanism() == UM_LAZY){
heapRemove(getModel()->getActionHeap());
if (getModel()->getUpdateMechanism() == UM_LAZY && stateSet_ == getModel()->getRunningActionSet() &&
{
XBT_IN("(%p)", this);
if (suspended_ != 2) {
- lmm_update_variable_weight(getModel()->getMaxminSystem(), getVariable(), getPriority());
+ getModel()->getMaxminSystem()->update_variable_weight(getVariable(), getPriority());
suspended_ = 0;
if (getModel()->getUpdateMechanism() == UM_LAZY)
heapRemove(getModel()->getActionHeap());
* 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(xbt_heap_t heap, double key, enum heap_action_type hat)
+void Action::heapInsert(heap_type& heap, double key, enum heap_action_type hat)
{
hat_ = hat;
- xbt_heap_push(heap, this, key);
+ heapHandle_ = heap.emplace(std::make_pair(key, this));
}
-void Action::heapRemove(xbt_heap_t heap)
+void Action::heapRemove(heap_type& heap)
{
hat_ = NOTSET;
- if (indexHeap_ >= 0) {
- xbt_heap_remove(heap, indexHeap_);
+ if (heapHandle_) {
+ heap.erase(*heapHandle_);
+ clearHeapHandle();
}
}
-void Action::heapUpdate(xbt_heap_t heap, double key, enum heap_action_type hat)
+void Action::heapUpdate(heap_type& heap, double key, enum heap_action_type hat)
{
hat_ = hat;
- if (indexHeap_ >= 0) {
- xbt_heap_update(heap, indexHeap_, key);
- }else{
- xbt_heap_push(heap, this, key);
+ if (heapHandle_) {
+ heap.update(*heapHandle_, std::make_pair(key, this));
+ } else {
+ heapHandle_ = heap.emplace(std::make_pair(key, this));
}
}
-void Action::updateIndexHeap(int i) {
- indexHeap_ = i;
-}
-
double Action::getRemains()
{
XBT_IN("(%p)", this);
return remains_;
}
-double Action::getRemainsNoUpdate()
-{
- return remains_;
-}
-
}
}