#ifndef SIMGRID_KERNEL_RESOURCE_ACTION_HPP
#define SIMGRID_KERNEL_RESOURCE_ACTION_HPP
-#include "src/surf/surf_interface.hpp"
+#include <simgrid/forward.h>
+#include <xbt/signal.hpp>
+#include <xbt/utility.hpp>
+
+#include <boost/heap/pairing_heap.hpp>
+#include <boost/optional.hpp>
+
+const int NO_MAX_DURATION = -1.0;
namespace simgrid {
namespace kernel {
/** @brief Update the maximum duration of the current action
* @param delta Amount to remove from the MaxDuration */
- void updateMaxDuration(double delta) { double_update(&maxDuration_, delta, sg_surf_precision); }
+ void updateMaxDuration(double delta);
/** @brief Update the remaining time of the current action
* @param delta Amount to remove from the remaining time */
- void updateRemains(double delta) { double_update(&remains_, delta, sg_maxmin_precision * sg_surf_precision); }
+ void updateRemains(double delta);
/** @brief Set the remaining time of the current action */
void setRemains(double value) { remains_ = value; }
boost::optional<heap_type::handle_type> heapHandle_ = boost::none;
public:
- virtual void updateRemainingLazy(double now) { THROW_IMPOSSIBLE; };
+ virtual void updateRemainingLazy(double now) = 0;
void heapInsert(heap_type& heap, double key, Action::Type hat);
void heapRemove(heap_type& heap);
void heapUpdate(heap_type& heap, double key, Action::Type hat);
kernel::lmm::Variable* getVariable() const { return variable_; }
void setVariable(kernel::lmm::Variable* var) { variable_ = var; }
double getLastUpdate() const { return lastUpdate_; }
- void refreshLastUpdate() { lastUpdate_ = surf_get_clock(); }
+ void refreshLastUpdate();
double getLastValue() const { return lastValue_; }
void setLastValue(double val) { lastValue_ = val; }
Action::Type getType() const { return type_; }
#include <simgrid/kernel/resource/Action.hpp>
+extern "C" {
+
+/** @brief Possible update mechanisms */
+enum e_UM_t {
+ UM_FULL, /**< Full update mechanism: the remaining time of every action is recomputed at each step */
+ UM_LAZY, /**< Lazy update mechanism: only the modified actions get recomputed.
+ It may be slower than full if your system is tightly coupled to the point where every action
+ gets recomputed anyway. In that case, you'd better not try to be cleaver with lazy and go for
+ a simple full update. */
+ UM_UNDEFINED /**< Mechanism not defined */
+};
+}
+
namespace simgrid {
namespace kernel {
namespace resource {
#include "simgrid/kernel/resource/Action.hpp"
#include "simgrid/kernel/resource/Model.hpp"
#include "src/kernel/lmm/maxmin.hpp"
+#include "src/surf/surf_interface.hpp"
XBT_LOG_NEW_CATEGORY(kernel, "Logging specific to the internals of SimGrid");
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(resource, kernel, "Logging specific to the resources");
return remains_;
}
+void Action::updateMaxDuration(double delta)
+{
+ double_update(&maxDuration_, delta, sg_surf_precision);
+}
+void Action::updateRemains(double delta)
+{
+ double_update(&remains_, delta, sg_maxmin_precision * sg_surf_precision);
+}
+
+void Action::refreshLastUpdate()
+{
+ lastUpdate_ = surf_get_clock();
+}
+
} // namespace surf
} // namespace simgrid
} // namespace simgrid
};
NetworkConstantAction::~NetworkConstantAction() = default;
+
+void NetworkConstantAction::updateRemainingLazy(double /*now*/)
+{
+ THROW_IMPOSSIBLE;
+}
}
}
NetworkConstantAction(NetworkConstantModel *model_, double size, double latency);
~NetworkConstantAction();
double initialLatency_;
+ void updateRemainingLazy(double now) override;
};
}
{
THROW_UNIMPLEMENTED;
}
+void NetworkNS3Action::updateRemainingLazy(double /*now*/)
+{
+ THROW_IMPOSSIBLE;
+}
/* Test whether a flow is suspended */
bool NetworkNS3Action::isSuspended()
void suspend() override;
void resume() override;
std::list<LinkImpl*> links() override;
+ void updateRemainingLazy(double now) override;
// private:
double lastSent_ = 0;
{
THROW_UNIMPLEMENTED;
}
-
+void StorageN11Action::updateRemainingLazy(double /*now*/)
+{
+ THROW_IMPOSSIBLE;
+}
}
}
public:
StorageN11Action(kernel::resource::Model* model, double cost, bool failed, StorageImpl* storage,
e_surf_action_storage_type_t type);
- void suspend();
- int unref();
- void cancel();
- void resume();
- bool isSuspended();
- void setMaxDuration(double duration);
- void setSharingWeight(double priority);
+ void suspend() override;
+ int unref() override;
+ void cancel() override;
+ void resume() override;
+ bool isSuspended() override;
+ void setMaxDuration(double duration) override;
+ void setSharingWeight(double priority) override;
+ void updateRemainingLazy(double now) override;
};
}
#include <string>
#include <unordered_map>
-#define NO_MAX_DURATION -1.0
-
/*********
* Utils *
*********/
#include "src/surf/trace_mgr.hpp"
#include "surf/surf.hpp"
-#define NO_MAX_DURATION -1.0
-
extern "C" {
-/** @ingroup SURF_interface
- * @brief Possible update mechanisms
- */
-enum e_UM_t {
- UM_FULL, /**< Full update mechanism: the remaining time of every action is recomputed at each step */
- UM_LAZY, /**< Lazy update mechanism: only the modified actions get recomputed.
- It may be slower than full if your system is tightly coupled to the point where every action
- gets recomputed anyway. In that case, you'd better not try to be cleaver with lazy and go for
- a simple full update. */
- UM_UNDEFINED /**< Mechanism not defined */
-};
-
/* Generic functions common to all models */
XBT_PRIVATE FILE* surf_fopen(const char* name, const char* mode);
