EventUtils.hpp

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <cstddef>
#include <fstream>
#include <iosfwd>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
#include "logging/Logger.hpp"
#include "profiling/Event.hpp"
#include "utils/assertion.hpp"
 
namespace precice::profiling {
 
enum struct Mode {
  All,
  Fundamental,
  Off
};
enum struct Mode {…};
 
enum struct EventClass : bool {
  Normal      = false,
  Fundamental = true
};
enum struct EventClass : bool {…};
 
inline EventClass toEventClass(bool isFundamental)
{
  return static_cast<EventClass>(isFundamental);
}
inline EventClass toEventClass(bool isFundamental) {…}
 
struct TimedEntry {
  TimedEntry(int eid, Event::Clock::time_point c)
      : eid(eid), clock(c) {}
  TimedEntry(int eid, Event::Clock::time_point c) {…}
 
  int                      eid;
  Event::Clock::time_point clock;
};
struct TimedEntry {…};
 
struct StartEntry : TimedEntry {
  using TimedEntry::TimedEntry;
  static constexpr char type = 'b';
};
struct StartEntry : TimedEntry {…};
 
struct StopEntry : TimedEntry {
  using TimedEntry::TimedEntry;
  static constexpr char type = 'e';
};
struct StopEntry : TimedEntry {…};
 
struct DataEntry : TimedEntry {
  DataEntry(int eid, Event::Clock::time_point c, int did, int dv)
      : TimedEntry(eid, c), did(did), dvalue(dv) {}
  DataEntry(int eid, Event::Clock::time_point c, int did, int dv) {…}
 
  static constexpr char type = 'd';
  int                   did;
  int                   dvalue;
};
struct DataEntry : TimedEntry {…};
 
struct NameEntry {
  static constexpr char type = 'n';
  std::string           name;
  int                   id;
};
struct NameEntry {…};
 
using PendingEntry = std::variant<StartEntry, StopEntry, DataEntry, NameEntry>;
 
class EventRegistry {
public:
  ~EventRegistry();
 
  EventRegistry(EventRegistry const &)            = delete;
  EventRegistry(EventRegistry &&)                 = delete;
  EventRegistry &operator=(EventRegistry const &) = delete;
  EventRegistry &operator=(EventRegistry &&)      = delete;
 
  static EventRegistry &instance();
 
 
  void initialize(std::string_view applicationName, int rank = 0, int size = 1);
 
  void setWriteQueueMax(std::size_t size);
 
  void setDirectory(std::string_view directory);
 
  void setMode(Mode mode);
 
  void startBackend();
 
  void finalize();
 
  void clear();
 
  void put(PendingEntry pe);
 
  void putCritical(PendingEntry pe);
 
  void flush();
 
  inline bool accepting(EventClass ec) const
  {
    return _mode == Mode::All || (ec == EventClass::Fundamental && _mode == Mode::Fundamental);
  }
  inline bool accepting(EventClass ec) const {…}
 
  inline bool parallel() const
  {
    return _size > 1;
  }
  inline bool parallel() const {…}
 
  int nameToID(std::string_view name);
 
private:
  std::string _applicationName;
 
  std::string _directory;
 
  Mode _mode = Mode::Fundamental;
 
  int _rank = 0;
 
  int _size = 1;
 
  bool _firstwrite = true;
 
  std::optional<int> _globalId;
 
  EventRegistry() = default;
 
  std::map<std::string, int, std::less<>> _nameDict;
 
  std::vector<PendingEntry> _writeQueue;
  std::size_t               _writeQueueMax = 0;
 
  std::ofstream _output;
 
  bool _initialized = false;
 
  bool _finalized = false;
 
  bool _isBackendRunning = false;
 
  Event::Clock::time_point _initClock;
 
  std::chrono::system_clock::time_point _initTime;
 
  void stopBackend();
 
  logging::Logger _log{"Events"};
};
class EventRegistry {…};
 
} // namespace precice::profiling