X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/19759270d7d4b85df2dd599fe8936278d840780a..61b77aa31cb615bf2b3a791d89309587d70760c4:/src/surf/trace_mgr.hpp diff --git a/src/surf/trace_mgr.hpp b/src/surf/trace_mgr.hpp index 1c425475ab..7784e7f807 100644 --- a/src/surf/trace_mgr.hpp +++ b/src/surf/trace_mgr.hpp @@ -8,110 +8,94 @@ #define _SURF_TMGR_H #include "xbt/heap.h" -#include "xbt/dynar.h" -#include "surf/maxmin.h" -#include "surf/datatypes.h" -#include "simgrid/platf_interface.h" +#include "simgrid/forward.h" SG_BEGIN_DECL() -#include "xbt/base.h" -#include "xbt/swag.h" #include "xbt/heap.h" -#include "trace_mgr.hpp" -#include "xbt/RngStream.h" typedef struct tmgr_event { double delta; double value; } s_tmgr_event_t, *tmgr_event_t; -enum e_trace_type { - e_trace_list, e_trace_probabilist -}; - -enum e_event_generator_type { - e_generator_uniform, e_generator_exponential, e_generator_weibull -}; - -typedef struct probabilist_event_generator { - enum e_event_generator_type type; - RngStream rng_stream; - double next_value; - union { - struct { - double min; - double max; - } s_uniform_parameters; - struct { - double rate; - } s_exponential_parameters; - struct { - double scale; - double shape; - } s_weibull_parameters; - }; -} s_probabilist_event_generator_t; - typedef struct tmgr_trace { - enum e_trace_type type; - union { - struct { - xbt_dynar_t event_list; - } s_list; - struct { - probabilist_event_generator_t event_generator[2]; - int is_state_trace; - int next_event; - } s_probabilist; - }; + } s_tmgr_trace_t; /* Iterator within a trace */ typedef struct tmgr_trace_iterator { tmgr_trace_t trace; unsigned int idx; - void *resource; + sg_resource_t resource; int free_me; } s_tmgr_trace_event_t; - -/* 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); +typedef struct tmgr_trace_iterator *tmgr_trace_iterator_t; /* Creation functions */ -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); /** * \brief Free a trace event structure * - * This function frees a trace_event if it can be freed, ie, if it has the free_me flag set to 1. This flag indicates whether the structure is still used somewhere or not. - * \param trace_event Trace event structure - * \return 1 if the structure was freed, 0 otherwise + * This function frees a trace_event if it can be freed, ie, if it has the free_me flag set to 1. + * This flag indicates whether the structure is still used somewhere or not. + * When the structure is freed, the argument is set to nullptr */ -XBT_PUBLIC(int) tmgr_trace_event_free(tmgr_trace_iterator_t trace_event); - -XBT_PUBLIC(tmgr_trace_iterator_t) tmgr_history_add_trace(tmgr_fes_t - history, - tmgr_trace_t trace, - double start_time, - unsigned int offset, - void *model); - -/* Access functions */ -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_trace_event_unref(tmgr_trace_iterator_t *trace_event); XBT_PUBLIC(void) tmgr_finalize(void); +XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_file(const char *filename); +XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_string(const char *id, const char *input, double periodicity); + SG_END_DECL() +#ifdef __cplusplus +namespace simgrid { +/** @brief Modeling of the resource variations, such as those due to an external load + * + * There is 3 main concepts in this module: + * - #trace: a set of dated values, ie a list of pair + * - #trace_iterator: links a given trace to a given simgrid resource. A Cpu for example has 2 iterators: state (ie, is it ON/OFF) and speed, while a link has 3 iterators: state, bandwidth and latency. + * - #future_evt_set: makes it easy to find the next occuring event of all traces + */ + namespace trace_mgr { + +/** @brief A trace_iterator links a trace to a resource */ +XBT_PUBLIC_CLASS trace_iterator { + +}; + +/** @brief A trace is a set of timed values, encoding the value that a variable takes at what time * + * + * It is useful to model dynamic platforms, where an external load that makes the resource availability change over time. + * To model that, you have to set several traces per resource: one for the on/off state and one for each numerical value (computational speed, bandwidt and latency). + */ +XBT_PUBLIC_CLASS trace { +public: + /** Creates an empty trace */ + trace(); + virtual ~trace(); +//private: + xbt_dynar_t event_list; +}; + +/** @brief 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. */ +XBT_PUBLIC_CLASS future_evt_set { +public: + future_evt_set(); + virtual ~future_evt_set(); + double next_date() const; + tmgr_trace_iterator_t pop_leq(double date, double *value, simgrid::surf::Resource** resource); + tmgr_trace_iterator_t add_trace(tmgr_trace_t trace, double start_time, simgrid::surf::Resource *resource); + +private: + // TODO: use a boost type for the heap (or a ladder queue) + xbt_heap_t p_heap = xbt_heap_new(8, xbt_free_f); /* Content: only trace_events (yep, 8 is an arbitrary value) */ +}; + +}} // namespace simgrid::trace_mgr +#endif /* C++ only */ + #endif /* _SURF_TMGR_H */