#define SURF_MODEL_H_
#include "xbt/signal.hpp"
+#include "xbt/utility.hpp"
#include "src/surf/surf_private.hpp"
-#include "surf/surf.h"
+#include "surf/surf.hpp"
#include "xbt/str.h"
+#include <boost/heap/pairing_heap.hpp>
#include <boost/intrusive/list.hpp>
+#include <boost/optional.hpp>
#include <set>
#include <string>
#include <unordered_map>
* Action *
**********/
-XBT_PRIVATE void surf_action_lmm_update_index_heap(void *action, int i);
-
/** \ingroup SURF_models
* \brief List of initialized models
*/
namespace simgrid {
namespace surf {
+typedef std::pair<double, simgrid::surf::Action*> heap_element_type;
+typedef boost::heap::pairing_heap<heap_element_type, boost::heap::constant_time_size<false>, boost::heap::stable<true>,
+ boost::heap::compare<simgrid::xbt::HeapComparator<heap_element_type>>>
+ heap_type;
+
/** @ingroup SURF_interface
* @brief SURF action interface class
* @details An action is an event generated by a resource (e.g.: a communication for the network)
double getPriority() { return sharingWeight_; };
/** @brief Set the priority of the current Action */
virtual void setSharingWeight(double priority);
+ void setSharingWeightNoUpdate(double weight) { sharingWeight_ = weight; }
/** @brief Get the state set in which the action is */
ActionList* getStateSet() {return stateSet_;};
protected:
ActionList* stateSet_;
- double sharingWeight_ = 1.0; /**< priority (1.0 by default) */
int refcount_ = 1;
- double remains_; /**< How much of that cost remains to be done in the currently running task */
- double maxDuration_ = NO_MAX_DURATION; /*< max_duration (may fluctuate until the task is completed) */
- double finishTime_ = -1; /**< finish time : this is modified during the run and fluctuates until the task is completed */
private:
+ double sharingWeight_ = 1.0; /**< priority (1.0 by default) */
+ double maxDuration_ = NO_MAX_DURATION; /*< max_duration (may fluctuate until the task is completed) */
+ double remains_; /**< How much of that cost remains to be done in the currently running task */
double start_; /**< start time */
char *category_ = nullptr; /**< tracing category for categorized resource utilization monitoring */
+ double finishTime_ =
+ -1; /**< finish time : this is modified during the run and fluctuates until the task is completed */
double cost_;
simgrid::surf::Model *model_;
void *data_ = nullptr; /**< for your convenience */
/* LMM */
+ double lastUpdate_ = 0;
+ double lastValue_ = 0;
+ lmm_variable_t variable_ = nullptr;
+ enum heap_action_type hat_ = NOTSET;
+ boost::optional<heap_type::handle_type> heapHandle_ = boost::none;
+
public:
virtual void updateRemainingLazy(double now) { THROW_IMPOSSIBLE; };
- void heapInsert(xbt_heap_t heap, double key, enum heap_action_type hat);
- void heapRemove(xbt_heap_t heap);
- void heapUpdate(xbt_heap_t heap, double key, enum heap_action_type hat);
- virtual void updateIndexHeap(int i);
+ void heapInsert(heap_type& heap, double key, enum heap_action_type hat);
+ void heapRemove(heap_type& heap);
+ void heapUpdate(heap_type& heap, double key, enum heap_action_type hat);
+ void clearHeapHandle() { heapHandle_ = boost::none; }
lmm_variable_t getVariable() {return variable_;}
+ void setVariable(lmm_variable_t var) { variable_ = var; }
double getLastUpdate() {return lastUpdate_;}
void refreshLastUpdate() {lastUpdate_ = surf_get_clock();}
- enum heap_action_type getHat() {return hat_;}
+ double getLastValue() { return lastValue_; }
+ void setLastValue(double val) { lastValue_ = val; }
+ enum heap_action_type getHat() { return hat_; }
bool is_linked() {return action_lmm_hook.is_linked();}
-
protected:
- lmm_variable_t variable_ = nullptr;
- double lastValue_ = 0;
- double lastUpdate_ = 0;
int suspended_ = 0;
- int indexHeap_;
- enum heap_action_type hat_ = NOTSET;
};
typedef Action::ActionList ActionList;
* @see e_UM_t
*/
e_UM_t getUpdateMechanism() {return updateMechanism_;}
+ void setUpdateMechanism(e_UM_t mechanism) { updateMechanism_ = mechanism; }
/** @brief Get Action heap */
- xbt_heap_t getActionHeap() {return actionHeap_;}
+ heap_type& getActionHeap() { return actionHeap_; }
+
+ double actionHeapTopDate() const { return actionHeap_.top().first; }
+ Action* actionHeapPop();
+ bool actionHeapIsEmpty() const { return actionHeap_.empty(); }
/**
* @brief Share the resources between the actions
protected:
ActionLmmListPtr modifiedSet_;
lmm_system_t maxminSystem_ = nullptr;
- e_UM_t updateMechanism_ = UM_UNDEFINED;
bool selectiveUpdate_;
- xbt_heap_t actionHeap_;
private:
+ e_UM_t updateMechanism_ = UM_UNDEFINED;
ActionList* readyActionSet_; /**< Actions in state SURF_ACTION_READY */
ActionList* runningActionSet_; /**< Actions in state SURF_ACTION_RUNNING */
ActionList* failedActionSet_; /**< Actions in state SURF_ACTION_FAILED */
ActionList* doneActionSet_; /**< Actions in state SURF_ACTION_DONE */
+ heap_type actionHeap_;
};
}
/** @ingroup SURF_interface
* @brief Resource which have a metric handled by a maxmin system
*/
-typedef struct {
+struct s_surf_metric_t {
double peak; /**< The peak of the metric, ie its max value */
double scale; /**< Current availability of the metric according to the traces, in [0,1] */
tmgr_trace_event_t event; /**< The associated trace event associated to the metric */
-} s_surf_metric_t;
+};
namespace simgrid {
namespace surf {
Model* model() const;
/** @brief Get the name of the current Resource */
- const char* cname() const;
+ const std::string& getName() const;
+ /** @brief Get the name of the current Resource */
+ const char* getCname() const;
bool operator==(const Resource &other) const;
namespace std {
template <> class hash<simgrid::surf::Resource> {
public:
- std::size_t operator()(const simgrid::surf::Resource& r) const { return (std::size_t)xbt_str_hash(r.cname()); }
- };
+ std::size_t operator()(const simgrid::surf::Resource& r) const { return (std::size_t)xbt_str_hash(r.getCname()); }
+};
}
#endif /* SURF_MODEL_H_ */