-/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2018. 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/s4u/Engine.hpp"
#include "simgrid/sg_config.h"
#include "src/instr/instr_private.hpp" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
+#include "src/kernel/lmm/maxmin.hpp" // Constraint
#include "src/kernel/routing/NetPoint.hpp"
#include "src/surf/HostImpl.hpp"
+#include "xbt/utility.hpp"
#include <fstream>
#include <set>
{
TRACE_end(); /* Just in case it was not called by the upper layer (or there is no upper layer) */
- sg_host_exit();
+ simgrid::s4u::Engine::shutdown();
sg_link_exit();
for (auto const& e : storage_types) {
simgrid::surf::StorageType* stype = e.second;
delete model;
delete all_existing_models;
- simgrid::surf::surfExitCallbacks();
if (future_evt_set) {
delete future_evt_set;
tmgr_finalize();
sg_platf_exit();
- simgrid::s4u::Engine::shutdown();
NOW = 0; /* Just in case the user plans to restart the simulation afterward */
}
delete runningActionSet_;
delete failedActionSet_;
delete doneActionSet_;
+ delete modifiedSet_;
+ delete maxminSystem_;
}
Action* Model::actionHeapPop()
continue;
/* bogus priority, skip it */
- if (action->getPriority() <= 0 || action->getHat()==LATENCY)
+ if (action->getPriority() <= 0 || action->getHat() == Action::Type::LATENCY)
continue;
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;
action->getMaxDuration());
if (min > -1) {
- action->heapUpdate(actionHeap_, min, max_dur_flag ? MAX_DURATION : NORMAL);
+ action->heapUpdate(actionHeap_, min, max_dur_flag ? Action::Type::MAX_DURATION : Action::Type::NORMAL);
XBT_DEBUG("Insert at heap action(%p) min %f now %f", action, min, now);
} else
DIE_IMPOSSIBLE;
double min = -1;
for (Action& action : *getRunningActionSet()) {
- double value = lmm_variable_getvalue(action.getVariable());
+ double value = action.getVariable()->get_value();
if (value > 0) {
if (action.getRemains() > 0)
value = action.getRemainsNoUpdate() / value;
************/
namespace simgrid {
-namespace surf {
+namespace kernel {
+namespace model {
-Resource::Resource(Model* model, const std::string& name, lmm_constraint_t constraint)
+Resource::Resource(surf::Model* model, const std::string& name, lmm::Constraint* constraint)
: name_(name), model_(model), constraint_(constraint)
{}
isOn_ = false;
}
-Model* Resource::model() const
+double Resource::getLoad()
+{
+ return constraint_->get_usage();
+}
+
+surf::Model* Resource::model() const
{
return model_;
}
return name_ == other.name_;
}
-lmm_constraint_t Resource::constraint() const
+kernel::lmm::Constraint* Resource::constraint() const
{
- return constraint_;
+ return const_cast<kernel::lmm::Constraint*>(constraint_);
}
}
+} // namespace kernel
}
/**********
* Action *
**********/
-const char *surf_action_state_names[6] = {
- "SURF_ACTION_READY",
- "SURF_ACTION_RUNNING",
- "SURF_ACTION_FAILED",
- "SURF_ACTION_DONE",
- "SURF_ACTION_TO_FREE",
- "SURF_ACTION_NOT_IN_THE_SYSTEM"
-};
-
namespace simgrid {
namespace surf {
{
}
-Action::Action(simgrid::surf::Model* model, double cost, bool failed, lmm_variable_t var)
+Action::Action(simgrid::surf::Model* model, double cost, bool failed, kernel::lmm::Variable* var)
: remains_(cost), start_(surf_get_clock()), cost_(cost), model_(model), variable_(var)
{
if (failed)
void Action::setState(Action::State state)
{
- stateSet_->erase(stateSet_->iterator_to(*this));
+ simgrid::xbt::intrusive_erase(*stateSet_, *this);
switch (state) {
case Action::State::ready:
stateSet_ = model_->getReadyActionSet();
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_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());
setState(Action::State::failed);
if (getModel()->getUpdateMechanism() == UM_LAZY) {
if (action_lmm_hook.is_linked())
- getModel()->getModifiedSet()->erase(getModel()->getModifiedSet()->iterator_to(*this));
+ simgrid::xbt::intrusive_erase(*getModel()->getModifiedSet(), *this);
heapRemove(getModel()->getActionHeap());
}
}
refcount_--;
if (not refcount_) {
if (action_hook.is_linked())
- stateSet_->erase(stateSet_->iterator_to(*this));
+ simgrid::xbt::intrusive_erase(*stateSet_, *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());
if (action_lmm_hook.is_linked())
- getModel()->getModifiedSet()->erase(getModel()->getModifiedSet()->iterator_to(*this));
+ simgrid::xbt::intrusive_erase(*getModel()->getModifiedSet(), *this);
}
delete this;
return 1;
void Action::suspend()
{
XBT_IN("(%p)", this);
- if (suspended_ != 2) {
- lmm_update_variable_weight(getModel()->getMaxminSystem(), getVariable(), 0.0);
+ if (suspended_ != SuspendStates::sleeping) {
+ getModel()->getMaxminSystem()->update_variable_weight(getVariable(), 0.0);
if (getModel()->getUpdateMechanism() == UM_LAZY){
heapRemove(getModel()->getActionHeap());
if (getModel()->getUpdateMechanism() == UM_LAZY && stateSet_ == getModel()->getRunningActionSet() &&
updateRemainingLazy(surf_get_clock());
}
}
- suspended_ = 1;
+ suspended_ = SuspendStates::suspended;
}
XBT_OUT();
}
void Action::resume()
{
XBT_IN("(%p)", this);
- if (suspended_ != 2) {
- lmm_update_variable_weight(getModel()->getMaxminSystem(), getVariable(), getPriority());
- suspended_ = 0;
+ if (suspended_ != SuspendStates::sleeping) {
+ getModel()->getMaxminSystem()->update_variable_weight(getVariable(), getPriority());
+ suspended_ = SuspendStates::not_suspended;
if (getModel()->getUpdateMechanism() == UM_LAZY)
heapRemove(getModel()->getActionHeap());
}
bool Action::isSuspended()
{
- return suspended_ == 1;
+ return suspended_ == SuspendStates::suspended;
}
/* insert action on heap using a given key and a hat (heap_action_type)
* a hat can be of three types for communications:
* 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(heap_type& heap, double key, enum heap_action_type hat)
+void Action::heapInsert(heap_type& heap, double key, Action::Type hat)
{
hat_ = hat;
heapHandle_ = heap.emplace(std::make_pair(key, this));
void Action::heapRemove(heap_type& heap)
{
- hat_ = NOTSET;
+ hat_ = Action::Type::NOTSET;
if (heapHandle_) {
heap.erase(*heapHandle_);
clearHeapHandle();
}
}
-void Action::heapUpdate(heap_type& heap, double key, enum heap_action_type hat)
+void Action::heapUpdate(heap_type& heap, double key, Action::Type hat)
{
hat_ = hat;
if (heapHandle_) {