class Action;
class Model;
class Resource;
+class TraceEvent;
}
namespace routing {
class ClusterCreationArgs;
#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 {
#ifndef SIMGRID_KERNEL_RESOURCE_RESOURCE_HPP
#define SIMGRID_KERNEL_RESOURCE_RESOURCE_HPP
-#include "src/surf/surf_interface.hpp"
+#include <simgrid/forward.h>
+#include <xbt/signal.hpp>
+#include <xbt/str.h>
+#include <xbt/utility.hpp>
namespace simgrid {
namespace kernel {
* @param event What happened
* @param value [TODO]
*/
- virtual void apply_event(tmgr_trace_event_t event, double value) = 0;
+ virtual void apply_event(TraceEvent* event, double value) = 0;
/** @brief Check if the current Resource is used (if it currently serves an action) */
virtual bool isUsed() = 0;
protected:
struct Metric {
- 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 */
+ 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] */
+ TraceEvent* event; /**< The associated trace event associated to the metric */
};
};
} // namespace resource
-/* Copyright (c) 2013-2016. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2013-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. */
#ifndef SURF_ROUTING_NONE_HPP_
#define SURF_ROUTING_NONE_HPP_
-#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include <simgrid/kernel/routing/NetZoneImpl.hpp>
namespace simgrid {
namespace kernel {
#ifndef SIMGRID_ROUTING_NETZONEIMPL_HPP
#define SIMGRID_ROUTING_NETZONEIMPL_HPP
-#include <map>
-
-#include "xbt/graph.h"
+#include <simgrid/forward.h>
+#include <simgrid/s4u/NetZone.hpp>
+#include <xbt/graph.h>
-#include "simgrid/forward.h"
-#include "simgrid/s4u/NetZone.hpp"
+#include <map>
namespace simgrid {
namespace kernel {
-/* Copyright (c) 2013-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2013-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. */
#ifndef SIMGRID_ROUTING_GENERIC_HPP_
#define SIMGRID_ROUTING_GENERIC_HPP_
-#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include <simgrid/kernel/routing/NetZoneImpl.hpp>
namespace simgrid {
namespace kernel {
#include "src/internal_config.h"
#if HAVE_MMALLOC
-# include <sys/types.h> /* for size_t */
-# include <stdio.h> /* for NULL */
+#include <stdio.h> /* for NULL */
+#include <sys/types.h> /* for size_t */
-#include "xbt/dynar.h"
#include "xbt/dict.h"
+#include "xbt/dynar.h"
SG_BEGIN_DECL()
* The heap structure itself is an opaque object that shouldnt be messed with.
*/
typedef struct mdesc s_xbt_mheap_t;
-typedef struct mdesc *xbt_mheap_t;
+typedef struct mdesc* xbt_mheap_t;
/* Allocate SIZE bytes of memory (and memset it to 0). */
XBT_PUBLIC void* mmalloc(xbt_mheap_t md, size_t size);
/* Allocate SIZE bytes of memory (and don't mess with it) */
-void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size);
+void* mmalloc_no_memset(xbt_mheap_t mdp, size_t size);
/* Re-allocate the previously allocated block in void*, making the new block SIZE bytes long. */
XBT_PUBLIC void* mrealloc(xbt_mheap_t md, void* ptr, size_t size);
xbt_mheap_t mmalloc_get_current_heap(void);
size_t mmalloc_get_bytes_used(xbt_mheap_t);
-ssize_t mmalloc_get_busy_size(xbt_mheap_t, void *ptr);
+ssize_t mmalloc_get_busy_size(xbt_mheap_t, void* ptr);
void* malloc_no_memset(size_t n);
SG_END_DECL()
#endif
-#endif /* SIMGRID_MMALLOC_H */
+#endif /* SIMGRID_MMALLOC_H */
#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);
{
tmgr_trace_event_t trace_iterator = nullptr;
- trace_iterator = new s_tmgr_trace_event_t;
+ trace_iterator = new simgrid::kernel::resource::TraceEvent();
trace_iterator->trace = trace;
trace_iterator->idx = 0;
trace_iterator->resource = resource;
#include <queue>
#include <vector>
-extern "C" {
/* Iterator within a trace */
-struct s_tmgr_trace_event_t {
+namespace simgrid {
+namespace kernel {
+namespace resource {
+class TraceEvent {
+public:
tmgr_trace_t trace;
unsigned int idx;
sg_resource_t resource;
bool free_me;
};
-typedef s_tmgr_trace_event_t* tmgr_trace_event_t;
+
+} // namespace resource
+} // namespace kernel
+} // namespace simgrid
+typedef simgrid::kernel::resource::TraceEvent* tmgr_trace_event_t;
+extern "C" {
/**
* \brief Free a trace event structure
src/include/simgrid/sg_config.h
src/include/surf/surf.hpp
src/include/xbt/parmap.hpp
+ src/include/xbt/mmalloc.h
src/mc/mc_mmu.hpp
src/mc/mc_record.hpp
src/mc/PageStore.hpp
include/xbt/log.hpp
include/xbt/mallocator.h
include/xbt/misc.h
- include/xbt/mmalloc.h
include/xbt/module.h
include/xbt/parmap.h
include/xbt/range.hpp
