X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/268aabc05cf124783cd4972c9bc3d8b735ce5f95..d4dc697d017dc90d064827165eb4f924452aeb0d:/src/surf/trace_mgr.hpp diff --git a/src/surf/trace_mgr.hpp b/src/surf/trace_mgr.hpp index a6af8e0c94..89bfc16d96 100644 --- a/src/surf/trace_mgr.hpp +++ b/src/surf/trace_mgr.hpp @@ -1,121 +1,101 @@ -/* Copyright (c) 2004-2007, 2009-2014. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2004-2017. 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_TMGR_H -#define _SURF_TMGR_H +#ifndef SURF_TMGR_H +#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 -}; +#include "xbt/sysdep.h" +#include -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; +SG_BEGIN_DECL() /* Iterator within a trace */ -typedef struct tmgr_trace_iterator { +typedef struct tmgr_trace_event { tmgr_trace_t trace; unsigned int idx; - void *resource; + sg_resource_t resource; int free_me; } s_tmgr_trace_event_t; +typedef struct tmgr_trace_event* tmgr_trace_event_t; -XBT_PRIVATE double tmgr_event_generator_next_value(probabilist_event_generator_t generator); - -/* Creation functions */ -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(void) tmgr_trace_event_unref(tmgr_trace_event_t* trace_event); + +XBT_PUBLIC(void) tmgr_finalize(); -XBT_PUBLIC(void) tmgr_finalize(void); +XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_file(std::string filename); +XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_string(std::string id, std::string input, double periodicity); SG_END_DECL() -#ifdef __cplusplus namespace simgrid { - namespace trace_mgr { +/** @brief Modeling of the availability profile (due to an external load) or the churn + * + * There is 4 main concepts in this module: + * - #DatedValue: a pair (both are of type double) + * - #trace: a list of dated values + * - #trace_event: links a given trace to a given SimGrid resource. + * A Cpu for example has 2 kinds of events: 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 { +XBT_PUBLIC_CLASS DatedValue +{ +public: + double date_ = 0; + double value_ = 0; + explicit DatedValue() = default; + explicit DatedValue(double d, double v) : date_(d), value_(v) {} + bool operator==(DatedValue e2); + bool operator!=(DatedValue e2) { return not(*this == e2); } +}; +std::ostream& operator<<(std::ostream& out, const DatedValue& e); + +/** @brief A trace_iterator links a trace to a resource */ +XBT_PUBLIC_CLASS trace_event{ + +}; + +/** @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, bandwidth and latency). + */ +XBT_PUBLIC_CLASS trace { +public: + /** Creates an empty trace */ + explicit trace(); + virtual ~trace(); +//private: + std::vector event_list; +}; -/* Future Event Set (collection of iterators over the traces) +/** @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(); - tmgr_trace_iterator_t pop_leq(double date, double *value, void** resource); - tmgr_trace_iterator_t add_trace( - tmgr_trace_t trace, - double start_time, - void *model); + double next_date() const; + tmgr_trace_event_t pop_leq(double date, double* value, simgrid::surf::Resource** resource); + tmgr_trace_event_t add_trace(tmgr_trace_t trace, 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) */ + xbt_heap_t 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 */ +#endif /* SURF_TMGR_H */