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"
 
#ifdef PRECICE_COMPRESSION
#include <lzma.h>
#endif
 
namespace precice::profiling {

enum struct Mode {
  All,
  API,
  Fundamental,
  Off
};
 
enum struct EventClass : bool {
  Normal      = false,
  Fundamental = true
};

struct TimedEntry {
  TimedEntry(int eid, Event::Clock::time_point c)
      : eid(eid), clock(c) {}
 
  int                      eid;
  Event::Clock::time_point clock;
};
 
struct StartEntry : TimedEntry {
  using TimedEntry::TimedEntry;
  static constexpr char type = 'b';
};
 
struct StopEntry : TimedEntry {
  using TimedEntry::TimedEntry;
  static constexpr char type = 'e';
};
 
struct DataEntry : TimedEntry {
  DataEntry(int eid, Event::Clock::time_point c, int did, int dv)
      : TimedEntry(eid, c), did(did), dvalue(dv) {}
 
  static constexpr char type = 'd';
  int                   did;
  int                   dvalue;
};
 
struct NameEntry {
  static constexpr char type = 'n';
  std::string           name;
  int                   id;
};
 
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(Group g) const
  {
    switch (_mode) {
    case Mode::Off:
      return false;
    case Mode::All:
      return true;
    case Mode::Fundamental:
      return g == Group::Fundamental;
    case Mode::API:
      return (g == Group::Fundamental) || (g == Group::API);
    }
    PRECICE_UNREACHABLE("Unknown mode");
  }

  inline bool parallel() const
  {
    return _size > 1;
  }
 
  int nameToID(std::string_view name);
 
private:
  std::string _applicationName;
 
  std::string _directory;

  Mode _mode = Mode::Fundamental;

  int _rank = 0;

  int _size = 1;
 
#ifdef PRECICE_COMPRESSION
  lzma_stream       _strm;
  std::vector<char> _buf = std::vector<char>(4 * 64);
#endif

  std::vector<char> _inbuf;

  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"};
};
 
} // namespace precice::profiling