typedef struct lmm_constraint_light *lmm_constraint_light_t;
typedef struct lmm_system *lmm_system_t;
-typedef struct tmgr_history *tmgr_history_t;
-typedef struct tmgr_trace_event *tmgr_trace_event_t;
+typedef struct tmgr_fes *tmgr_fes_t;
+typedef struct tmgr_trace_iterator *tmgr_trace_iterator_t;
#endif /* MAXMIN_DATATYPES_H */
SG_BEGIN_DECL()
/* Creation functions */
-XBT_PUBLIC(tmgr_history_t) tmgr_history_new(void);
-XBT_PUBLIC(void) tmgr_history_free(tmgr_history_t history);
+XBT_PUBLIC(tmgr_fes_t) tmgr_history_new(void);
+XBT_PUBLIC(void) tmgr_history_free(tmgr_fes_t history);
XBT_PUBLIC(tmgr_trace_t) tmgr_empty_trace_new(void);
XBT_PUBLIC(void) tmgr_trace_free(tmgr_trace_t trace);
* \param trace_event Trace event structure
* \return 1 if the structure was freed, 0 otherwise
*/
-XBT_PUBLIC(int) tmgr_trace_event_free(tmgr_trace_event_t trace_event);
+XBT_PUBLIC(int) tmgr_trace_event_free(tmgr_trace_iterator_t trace_event);
-XBT_PUBLIC(tmgr_trace_event_t) tmgr_history_add_trace(tmgr_history_t
+XBT_PUBLIC(tmgr_trace_iterator_t) tmgr_history_add_trace(tmgr_fes_t
history,
tmgr_trace_t trace,
double start_time,
void *model);
/* Access functions */
-XBT_PUBLIC(double) tmgr_history_next_date(tmgr_history_t history);
-XBT_PUBLIC(tmgr_trace_event_t)
- tmgr_history_get_next_event_leq(tmgr_history_t history, double date,
+XBT_PUBLIC(double) tmgr_history_next_date(tmgr_fes_t history);
+XBT_PUBLIC(tmgr_trace_iterator_t)
+ tmgr_history_get_next_event_leq(tmgr_fes_t history, double date,
double *value, void **model);
XBT_PUBLIC(void) tmgr_finalize(void);
xbt_dynar_free(&p_speedPeakList);
}
-void CpuCas01::setStateEvent(tmgr_trace_event_t stateEvent)
+void CpuCas01::setStateEvent(tmgr_trace_iterator_t stateEvent)
{
p_stateEvent = stateEvent;
}
-void CpuCas01::setPowerEvent(tmgr_trace_event_t powerEvent)
+void CpuCas01::setPowerEvent(tmgr_trace_iterator_t powerEvent)
{
p_speedEvent = powerEvent;
}
Cpu::onSpeedChange();
}
-void CpuCas01::updateState(tmgr_trace_event_t event_type, double value, double date)
+void CpuCas01::updateState(tmgr_trace_iterator_t event_type, double value, double date)
{
lmm_variable_t var = NULL;
lmm_element_t elem = NULL;
int pstate, double speedScale, tmgr_trace_t speedTrace, int core,
int initiallyOn, tmgr_trace_t stateTrace) ;
~CpuCas01();
- void updateState(tmgr_trace_event_t event_type, double value, double date) override;
+ void updateState(tmgr_trace_iterator_t event_type, double value, double date) override;
CpuAction *execute(double size) override;
CpuAction *sleep(double duration) override;
bool isUsed() override;
- void setStateEvent(tmgr_trace_event_t stateEvent);
- void setPowerEvent(tmgr_trace_event_t stateEvent);
+ void setStateEvent(tmgr_trace_iterator_t stateEvent);
+ void setPowerEvent(tmgr_trace_iterator_t stateEvent);
xbt_dynar_t getSpeedPeakList(); // FIXME: killme to hide our internals
private:
- tmgr_trace_event_t p_stateEvent;
- tmgr_trace_event_t p_speedEvent;
+ tmgr_trace_iterator_t p_stateEvent;
+ tmgr_trace_iterator_t p_speedEvent;
};
/**********
delete p_actionSet;
}
-void CpuTi::updateState(tmgr_trace_event_t event_type,
+void CpuTi::updateState(tmgr_trace_iterator_t event_type,
double value, double date)
{
CpuTiAction *action;
int initiallyOn, tmgr_trace_t stateTrace) ;
~CpuTi();
- void updateState(tmgr_trace_event_t event_type, double value, double date) override;
+ void updateState(tmgr_trace_iterator_t event_type, double value, double date) override;
void updateActionsFinishTime(double now);
bool isUsed() override;
CpuAction *execute(double size) override;
void modified(bool modified);
CpuTiTgmr *p_availTrace; /*< Structure with data needed to integrate trace file */
- tmgr_trace_event_t p_stateEvent = NULL; /*< trace file with states events (ON or OFF) */
- tmgr_trace_event_t p_speedEvent = NULL; /*< trace file with availability events */
+ tmgr_trace_iterator_t p_stateEvent = NULL; /*< trace file with states events (ON or OFF) */
+ tmgr_trace_iterator_t p_speedEvent = NULL; /*< trace file with availability events */
ActionTiList *p_actionSet; /*< set with all actions running on cpu */
double m_sumPriority; /*< the sum of actions' priority that are running on cpu */
double m_lastUpdate = 0; /*< last update of actions' remaining amount done */
virtual int fileMove(surf_file_t fd, const char* fullpath);
bool isUsed() override {DIE_IMPOSSIBLE;} // FIXME: Host should not be a Resource
- void updateState(tmgr_trace_event_t event_type, double value, double date) override
+ void updateState(tmgr_trace_iterator_t event_type, double value, double date) override
{THROW_IMPOSSIBLE;} // FIXME: Host should not be a Resource
public:
return lmm_constraint_used(getModel()->getMaxminSystem(), getConstraint());
}
-void CpuL07::updateState(tmgr_trace_event_t event_type, double value, double /*date*/){
+void CpuL07::updateState(tmgr_trace_iterator_t event_type, double value, double /*date*/){
XBT_DEBUG("Updating cpu %s (%p) with value %g", getName(), this, value);
if (event_type == p_speedEvent) {
m_speedScale = value;
return;
}
-void LinkL07::updateState(tmgr_trace_event_t event_type, double value, double date) {
+void LinkL07::updateState(tmgr_trace_iterator_t event_type, double value, double date) {
XBT_DEBUG("Updating link %s (%p) with value=%f for date=%g", getName(), this, value, date);
if (event_type == p_bwEvent) {
updateBandwidth(value, date);
class CpuL07 : public Cpu {
friend void HostL07Model::addTraces();
- tmgr_trace_event_t p_stateEvent;
- tmgr_trace_event_t p_speedEvent;
+ tmgr_trace_iterator_t p_stateEvent;
+ tmgr_trace_iterator_t p_speedEvent;
public:
CpuL07(CpuL07Model *model, simgrid::s4u::Host *host, xbt_dynar_t speedPeakList, int pstate,
double power_scale, tmgr_trace_t power_trace,
int core, int initiallyOn, tmgr_trace_t state_trace);
~CpuL07();
bool isUsed() override;
- void updateState(tmgr_trace_event_t event_type, double value, double date) override;
+ void updateState(tmgr_trace_iterator_t event_type, double value, double date) override;
Action *execute(double size) override;
Action *sleep(double duration) override;
protected:
e_surf_link_sharing_policy_t policy);
~LinkL07(){ };
bool isUsed() override;
- void updateState(tmgr_trace_event_t event_type, double value, double date) override;
+ void updateState(tmgr_trace_iterator_t event_type, double value, double date) override;
double getBandwidth() override;
void updateBandwidth(double value, double date=surf_get_clock()) override;
void updateLatency(double value, double date=surf_get_clock()) override;
double m_bwCurrent;
- tmgr_trace_event_t p_bwEvent;
+ tmgr_trace_iterator_t p_bwEvent;
};
/**********
NetworkCm02Link::NetworkCm02Link(NetworkCm02Model *model, const char *name, xbt_dict_t props,
lmm_system_t system,
double constraint_value,
- tmgr_history_t history,
+ tmgr_fes_t history,
int initiallyOn,
tmgr_trace_t state_trace,
double metric_peak,
-void NetworkCm02Link::updateState(tmgr_trace_event_t event_type,
+void NetworkCm02Link::updateState(tmgr_trace_iterator_t triggered,
double value, double date)
{
- /* printf("[" "%g" "] Asking to update network card \"%s\" with value " */
- /* "%g" " for event %p\n", surf_get_clock(), nw_link->name, */
- /* value, event_type); */
- if (event_type == p_speed.event) {
+ /* Find out which of my iterators was triggered, and react accordingly */
+ if (triggered == p_speed.event) {
updateBandwidth(value, date);
- if (tmgr_trace_event_free(event_type))
+ if (tmgr_trace_event_free(triggered))
p_speed.event = NULL;
- } else if (event_type == p_latEvent) {
+ } else if (triggered == p_latEvent) {
updateLatency(value, date);
- if (tmgr_trace_event_free(event_type))
+ if (tmgr_trace_event_free(triggered))
p_latEvent = NULL;
- } else if (event_type == p_stateEvent) {
+ } else if (triggered == p_stateEvent) {
if (value > 0)
turnOn();
else {
}
}
}
- if (tmgr_trace_event_free(event_type))
+ if (tmgr_trace_event_free(triggered))
p_stateEvent = NULL;
} else {
XBT_CRITICAL("Unknown event ! \n");
NetworkCm02Link(NetworkCm02Model *model, const char *name, xbt_dict_t props,
lmm_system_t system,
double constraint_value,
- tmgr_history_t history,
+ tmgr_fes_t history,
int initiallyOn,
tmgr_trace_t state_trace,
double metric_peak,
double lat_initial,
tmgr_trace_t lat_trace,
e_surf_link_sharing_policy_t policy);
- void updateState(tmgr_trace_event_t event_type, double value, double date) override;
+ void updateState(tmgr_trace_iterator_t event_type, double value, double date) override;
void updateBandwidth(double value, double date=surf_get_clock()) override;
void updateLatency(double value, double date=surf_get_clock()) override;
virtual void gapAppend(double /*size*/, const Link* /*link*/, NetworkAction * /*action*/) {};
Link::Link(simgrid::surf::NetworkModel *model, const char *name, xbt_dict_t props,
lmm_constraint_t constraint,
- tmgr_history_t history,
+ tmgr_fes_t history,
tmgr_trace_t state_trace)
: Resource(model, name, constraint),
PropertyHolder(props)
*/
Link(simgrid::surf::NetworkModel *model, const char *name, xbt_dict_t props,
lmm_constraint_t constraint,
- tmgr_history_t history,
+ tmgr_fes_t history,
tmgr_trace_t state_trace);
/* Link destruction logic */
/* Using this object with the public part of
model does not make sense */
double m_latCurrent = 0;
- tmgr_trace_event_t p_latEvent = NULL;
+ tmgr_trace_iterator_t p_latEvent = NULL;
/* LMM */
- tmgr_trace_event_t p_stateEvent = NULL;
+ tmgr_trace_iterator_t p_stateEvent = NULL;
s_surf_metric_t p_speed;
/* User data */
{
}
-void NetworkNS3Link::updateState(tmgr_trace_event_t event_type, double value, double date)
+void NetworkNS3Link::updateState(tmgr_trace_iterator_t event_type, double value, double date)
{
}
double bw_initial, double lat_initial);
~NetworkNS3Link();
- void updateState(tmgr_trace_event_t event_type, double value, double date);
+ void updateState(tmgr_trace_iterator_t event_type, double value, double date);
double getLatency(){THROW_UNIMPLEMENTED;}
double getBandwidth(){THROW_UNIMPLEMENTED;}
void updateBandwidth(double value, double date=surf_get_clock()){THROW_UNIMPLEMENTED;}
return false;
}
-void Storage::updateState(tmgr_trace_event_t /*event_type*/, double /*value*/, double /*date*/)
+void Storage::updateState(tmgr_trace_iterator_t /*event_type*/, double /*value*/, double /*date*/)
{
THROW_UNIMPLEMENTED;
}
* @param value [description]
* @param date [description]
*/
- void updateState(tmgr_trace_event_t event_type, double value, double date) override;
+ void updateState(tmgr_trace_iterator_t event_type, double value, double date) override;
void turnOn() override;
void turnOff() override;
void surf_presolve(void)
{
double next_event_date = -1.0;
- tmgr_trace_event_t event = NULL;
+ tmgr_trace_iterator_t event = NULL;
double value = -1.0;
simgrid::surf::Resource *resource = NULL;
simgrid::surf::Model *model = NULL;
double value = -1.0;
simgrid::surf::Resource *resource = NULL;
simgrid::surf::Model *model = NULL;
- tmgr_trace_event_t event = NULL;
+ tmgr_trace_iterator_t event = NULL;
unsigned int iter;
if(!host_that_restart)
xbt_dynar_t all_existing_models = NULL; /* to destroy models correctly */
xbt_dynar_t model_list_invoke = NULL; /* for invoking callbacks */
-tmgr_history_t history = NULL;
+tmgr_fes_t history = NULL;
lmm_system_t maxmin_system = NULL;
xbt_dynar_t surf_path = NULL;
xbt_dynar_t host_that_restart = NULL;
#include "src/surf/surf_private.h"
#include "src/internal_config.h"
-extern XBT_PRIVATE tmgr_history_t history;
+extern XBT_PRIVATE tmgr_fes_t history;
#define NO_MAX_DURATION -1.0
/*********
typedef struct {
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 */
+ tmgr_trace_iterator_t event; /**< The associated trace event associated to the metric */
} s_surf_metric_t;
namespace simgrid {
* @param value [TODO]
* @param date [TODO]
*/
- virtual void updateState(tmgr_trace_event_t event_type, double value, double date)=0;
+ virtual void updateState(tmgr_trace_iterator_t event_type, double value, double date)=0;
/** @brief Check if the current Resource is used (if it currently serves an action) */
virtual bool isUsed()=0;
XBT_PRIVATE FILE *surf_fopen(const char *name, const char *mode);
-extern XBT_PRIVATE tmgr_history_t history;
+extern XBT_PRIVATE tmgr_fes_t history;
/* The __surf_is_absolute_file_path() returns 1 if
* file_path is a absolute file path, in the other
static xbt_dict_t trace_list = NULL;
-XBT_INLINE tmgr_history_t tmgr_history_new(void)
+XBT_INLINE tmgr_fes_t tmgr_history_new(void)
{
- tmgr_history_t h;
+ tmgr_fes_t h;
h = xbt_new0(s_tmgr_history_t, 1);
return h;
}
-XBT_INLINE void tmgr_history_free(tmgr_history_t h)
+XBT_INLINE void tmgr_history_free(tmgr_fes_t h)
{
xbt_heap_free(h->heap);
free(h);
free(trace);
}
-tmgr_trace_event_t tmgr_history_add_trace(tmgr_history_t h,
+tmgr_trace_iterator_t tmgr_history_add_trace(tmgr_fes_t h,
tmgr_trace_t trace,
double start_time,
unsigned int offset, void *model)
{
- tmgr_trace_event_t trace_event = NULL;
+ tmgr_trace_iterator_t trace_iterator = NULL;
- trace_event = xbt_new0(s_tmgr_trace_event_t, 1);
- trace_event->trace = trace;
- trace_event->idx = offset;
- trace_event->model = model;
+ trace_iterator = xbt_new0(s_tmgr_trace_event_t, 1);
+ trace_iterator->trace = trace;
+ trace_iterator->idx = offset;
+ trace_iterator->model = model;
if(trace->type == e_trace_list) {
- xbt_assert((trace_event->idx < xbt_dynar_length(trace->s_list.event_list)),
+ xbt_assert((trace_iterator->idx < xbt_dynar_length(trace->s_list.event_list)),
"You're referring to an event that does not exist!");
}
- xbt_heap_push(h->heap, trace_event, start_time);
+ xbt_heap_push(h->heap, trace_iterator, start_time);
- return trace_event;
+ return trace_iterator;
}
-XBT_INLINE double tmgr_history_next_date(tmgr_history_t h)
+XBT_INLINE double tmgr_history_next_date(tmgr_fes_t h)
{
if (xbt_heap_size(h->heap))
return (xbt_heap_maxkey(h->heap));
return -1.0;
}
-tmgr_trace_event_t tmgr_history_get_next_event_leq(tmgr_history_t h,
+tmgr_trace_iterator_t tmgr_history_get_next_event_leq(tmgr_fes_t h,
double date,
double *value,
void **model)
{
double event_date = tmgr_history_next_date(h);
- tmgr_trace_event_t trace_event = NULL;
+ tmgr_trace_iterator_t trace_iterator = NULL;
tmgr_event_t event = NULL;
tmgr_trace_t trace = NULL;
double event_delta;
if (event_date > date)
return NULL;
- if (!(trace_event = xbt_heap_pop(h->heap)))
+ if (!(trace_iterator = xbt_heap_pop(h->heap)))
return NULL;
- trace = trace_event->trace;
- *model = trace_event->model;
+ trace = trace_iterator->trace;
+ *model = trace_iterator->model;
switch(trace->type) {
case e_trace_list:
- event = xbt_dynar_get_ptr(trace->s_list.event_list, trace_event->idx);
+ event = xbt_dynar_get_ptr(trace->s_list.event_list, trace_iterator->idx);
*value = event->value;
- if (trace_event->idx < xbt_dynar_length(trace->s_list.event_list) - 1) {
- xbt_heap_push(h->heap, trace_event, event_date + event->delta);
- trace_event->idx++;
+ if (trace_iterator->idx < xbt_dynar_length(trace->s_list.event_list) - 1) {
+ xbt_heap_push(h->heap, trace_iterator, event_date + event->delta);
+ trace_iterator->idx++;
} else if (event->delta > 0) { /* Last element, checking for periodicity */
- xbt_heap_push(h->heap, trace_event, event_date + event->delta);
- trace_event->idx = 1; /* not 0 as the first event is a placeholder to handle when events really start */
+ xbt_heap_push(h->heap, trace_iterator, event_date + event->delta);
+ trace_iterator->idx = 1; /* not 0 as the first event is a placeholder to handle when events really start */
} else { /* We don't need this trace_event anymore */
- trace_event->free_me = 1;
+ trace_iterator->free_me = 1;
}
break;
event_delta = tmgr_event_generator_next_value(trace->s_probabilist.event_generator[0]);
*value = tmgr_event_generator_next_value(trace->s_probabilist.event_generator[1]);
}
- xbt_heap_push(h->heap, trace_event, event_date + event_delta);
+ xbt_heap_push(h->heap, trace_iterator, event_date + event_delta);
XBT_DEBUG("Generating a new event at date %f, with value %f", event_date + event_delta, *value);
break;
}
- return trace_event;
+ return trace_iterator;
}
XBT_INLINE void tmgr_finalize(void)
xbt_dict_free(&trace_list);
}
-int tmgr_trace_event_free(tmgr_trace_event_t trace_event)
+int tmgr_trace_event_free(tmgr_trace_iterator_t trace_event)
{
if (trace_event->free_me) {
xbt_free(trace_event);
};
} s_tmgr_trace_t;
-
-typedef struct tmgr_trace_event {
+/* Iterator within a trace */
+typedef struct tmgr_trace_iterator {
tmgr_trace_t trace;
unsigned int idx;
void *model;
int free_me;
} s_tmgr_trace_event_t;
-typedef struct tmgr_history {
- xbt_heap_t heap;
+/* Future Event Set (collection of iterators over the traces)
+ * That's useful to quickly know which is the next occurring event in a set of traces. */
+typedef struct tmgr_fes {
+ xbt_heap_t heap; /* Content: only trace_events */
} s_tmgr_history_t;
XBT_PRIVATE double tmgr_event_generator_next_value(probabilist_event_generator_t generator);
void test(void);
void test(void)
{
- tmgr_history_t history = tmgr_history_new();
+ tmgr_fes_t history = tmgr_history_new();
tmgr_trace_t trace_A = tmgr_trace_new_from_file("trace_A.txt");
tmgr_trace_t trace_B = tmgr_trace_new_from_file("trace_B.txt");
double next_event_date = -1.0;