X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/268aabc05cf124783cd4972c9bc3d8b735ce5f95..c290f6e5704d8d1e227fc32720676a2613d5d51c:/src/surf/trace_mgr.hpp diff --git a/src/surf/trace_mgr.hpp b/src/surf/trace_mgr.hpp index a6af8e0c94..1e749dedf4 100644 --- a/src/surf/trace_mgr.hpp +++ b/src/surf/trace_mgr.hpp @@ -1,121 +1,107 @@ -/* Copyright (c) 2004-2007, 2009-2014. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2004-2019. 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_PMGR_H +#define SURF_PMGR_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" +#include "xbt/sysdep.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; +#include +#include /* Iterator within a trace */ -typedef struct tmgr_trace_iterator { - tmgr_trace_t trace; +namespace simgrid { +namespace kernel { +namespace profile { +/** @brief Links a profile to a resource */ +class Event { +public: + Profile* profile; unsigned int idx; - void *resource; - int free_me; -} s_tmgr_trace_event_t; + resource::Resource* resource; + bool free_me; +}; -XBT_PRIVATE double tmgr_event_generator_next_value(probabilist_event_generator_t generator); +} // namespace resource +} // namespace kernel +} // namespace simgrid +extern XBT_PRIVATE simgrid::kernel::profile::FutureEvtSet future_evt_set; -/* 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 + * @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 -*/ -XBT_PUBLIC(int) tmgr_trace_event_free(tmgr_trace_iterator_t trace_event); + * 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 void tmgr_trace_event_unref(simgrid::kernel::profile::Event** trace_event); -XBT_PUBLIC(void) tmgr_finalize(void); +XBT_PUBLIC void tmgr_finalize(); -SG_END_DECL() +XBT_PUBLIC simgrid::kernel::profile::Profile* tmgr_trace_new_from_file(std::string filename); +XBT_PUBLIC simgrid::kernel::profile::Profile* tmgr_trace_new_from_string(std::string id, std::string input, + double periodicity); -#ifdef __cplusplus namespace simgrid { - namespace trace_mgr { +namespace kernel { +namespace profile { + +/** @brief Modeling of the availability profile (due to an external load) or the churn + * + * There is 4 main concepts in this module: + * - #simgrid::kernel::profile::DatedValue: a pair (both are of type double) + * - #simgrid::kernel::profile::Profile: a list of dated values + * - #simgrid::kernel::profile::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. + * - #simgrid::kernel::profile::FutureEvtSet: makes it easy to find the next occuring event of all profiles + */ +class XBT_PUBLIC 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 profile 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 profiles per resource: one for the on/off state and one for each + * numerical value (computational speed, bandwidth and/or latency). + */ +class XBT_PUBLIC Profile { +public: + /** Creates an empty trace */ + explicit Profile(); + virtual ~Profile(); + // 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 { +class XBT_PUBLIC FutureEvtSet { 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); + FutureEvtSet(); + virtual ~FutureEvtSet(); + double next_date() const; + Event* pop_leq(double date, double* value, resource::Resource** resource); + Event* add_trace(Profile* profile, resource::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) */ + typedef std::pair Qelt; + std::priority_queue, std::greater> heap_; }; -}} // namespace simgrid::trace_mgr -#endif /* C++ only */ +} // namespace profile +} // namespace kernel +} // namespace simgrid -#endif /* _SURF_TMGR_H */ +#endif /* SURF_PMGR_H */