X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/dccf1b41e9c7b5a696f01abceaa2779fe65f154f..c290f6e5704d8d1e227fc32720676a2613d5d51c:/src/surf/trace_mgr.hpp diff --git a/src/surf/trace_mgr.hpp b/src/surf/trace_mgr.hpp index bf4519912d..1e749dedf4 100644 --- a/src/surf/trace_mgr.hpp +++ b/src/surf/trace_mgr.hpp @@ -1,97 +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 "simgrid/forward.h" -#include - -SG_BEGIN_DECL() +#include "xbt/sysdep.h" -typedef struct tmgr_event { - double delta; - double value; -} s_tmgr_event_t, *tmgr_event_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; - sg_resource_t resource; - int free_me; -} s_tmgr_trace_event_t; -typedef struct tmgr_trace_iterator *tmgr_trace_iterator_t; - -/* Creation functions */ -XBT_PUBLIC(tmgr_trace_t) tmgr_empty_trace_new(void); -XBT_PUBLIC(void) tmgr_trace_free(tmgr_trace_t trace); + resource::Resource* resource; + bool free_me; +}; + +} // namespace resource +} // namespace kernel +} // namespace simgrid +extern XBT_PRIVATE simgrid::kernel::profile::FutureEvtSet future_evt_set; + /** - * \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. * When the structure is freed, the argument is set to nullptr -*/ -XBT_PUBLIC(void) tmgr_trace_event_unref(tmgr_trace_iterator_t *trace_event); - -XBT_PUBLIC(void) tmgr_finalize(void); + */ +XBT_PUBLIC void tmgr_trace_event_unref(simgrid::kernel::profile::Event** trace_event); -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); +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 { -/** @brief Modeling of the resource variations, such as those due to an external load +namespace kernel { +namespace profile { + +/** @brief Modeling of the availability profile (due to an external load) or the churn * - * 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 + * 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 */ - namespace trace_mgr { - -/** @brief A trace_iterator links a trace to a resource */ -XBT_PUBLIC_CLASS trace_iterator { - +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 trace is a set of timed values, encoding the value that a variable takes at what time * +/** @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 traces per resource: one for the on/off state and one for each numerical value (computational speed, bandwidth and latency). + * 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). */ -XBT_PUBLIC_CLASS trace { +class XBT_PUBLIC Profile { public: /** Creates an empty trace */ - trace(); - virtual ~trace(); -//private: - std::vector event_list; + explicit Profile(); + virtual ~Profile(); + // private: + std::vector 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 { +class XBT_PUBLIC FutureEvtSet { public: - future_evt_set(); - virtual ~future_evt_set(); + FutureEvtSet(); + virtual ~FutureEvtSet(); 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); + 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 */