DebugContext.hpp

// Copyright (c) 2020 Graphcore Ltd. All rights reserved.
 
#ifndef poplar_DebugContext_hpp
#define poplar_DebugContext_hpp
 
#include "ProfileValue.hpp"
#include "SerializationFormat.hpp"
#include <cstdint>
#include <string>
 
namespace poplar {
 
#if defined(__clang__)
#define SUPPORTS_LOCATION_BUILTINS                                             \
  (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) &&       \
   __has_builtin(__builtin_LINE))
#elif __GNUC__ >= 7
#define SUPPORTS_LOCATION_BUILTINS 1
#else
#define SUPPORTS_LOCATION_BUILTINS 0
#endif
 
class SourceLocation {
  const char *functionName{""};
  const char *fileName{""};
  unsigned lineNumber{};
  bool valid{false};
 
public:
  SourceLocation() = default;
  constexpr SourceLocation(const char *functionName, const char *fileName,
                           unsigned lineNumber)
      : functionName{functionName}, fileName{fileName},
        lineNumber{lineNumber}, valid{true} {}
  constexpr const char *getFunctionName() const { return functionName; }
  constexpr const char *getFileName() const { return fileName; }
  constexpr unsigned getLineNumber() const { return lineNumber; }
  constexpr bool isValid() const { return valid; }
#if SUPPORTS_LOCATION_BUILTINS
  static SourceLocation Current(const char *functionName = __builtin_FUNCTION(),
                                const char *fileName = __builtin_FILE(),
                                unsigned lineNumber = __builtin_LINE()) {
    return {functionName, fileName, lineNumber};
  }
#else
  static SourceLocation Current() { return {}; }
#endif
};
 
enum class DebugSerializationFormat {
  JSON, 
  CBOR, 
};
 
using DebugId = std::uint64_t;
 
class DebugContext;
namespace core {
class DebugInfo;
}
 
class DebugInfo {
  std::unique_ptr<core::DebugInfo> impl;
 
public:
  DebugInfo(const DebugContext &debugContext, std::string layer);
  DebugInfo &operator=(const DebugInfo &) = delete;
  DebugInfo(const DebugInfo &) = delete;
  virtual ~DebugInfo();
  DebugId getId() const;
  std::string getPathName() const;
  core::DebugInfo &getImpl() const { return *impl; }
  static void initializeStreamer(
      const std::string &fileName,
      const DebugSerializationFormat &format = DebugSerializationFormat::CBOR);
  static void closeStreamer();
 
  bool setValue(std::string name, ProfileValue value);
};
 
namespace core {
class DebugNameAndId;
}
 
class DebugNameAndId {
  std::unique_ptr<core::DebugNameAndId> impl;
 
public:
  DebugNameAndId(std::string name = "", DebugId debugId = {},
                 std::string parentPath = "");
  DebugNameAndId(const char *name);
  DebugNameAndId(DebugId debugId);
  DebugNameAndId(const DebugInfo &debugInfo, std::string name = "");
  DebugNameAndId(const DebugNameAndId &DebugNameAndId, StringRef name = "");
  DebugNameAndId &operator=(const DebugNameAndId &other);
  ~DebugNameAndId();
  std::string getPathName() const;
  core::DebugNameAndId &getImpl() const { return *impl; }
};
 
std::ostream &operator<<(std::ostream &os, const DebugNameAndId &dnai);
 
namespace core {
struct DebugContext;
}
 
class DebugContext {
  std::unique_ptr<core::DebugContext> impl;
 
public:
  DebugContext(SourceLocation loc = SourceLocation::Current());
  DebugContext(const char *name,
               SourceLocation loc = SourceLocation::Current());
  DebugContext(StringRef name, SourceLocation loc = SourceLocation::Current());
  DebugContext(std::string name,
               SourceLocation loc = SourceLocation::Current());
  DebugContext(const DebugInfo &debugInfo, std::string name = "",
               SourceLocation loc = SourceLocation::Current());
  DebugContext(const DebugNameAndId &debugNameAndId, std::string name = "",
               SourceLocation loc = SourceLocation::Current());
  DebugContext(const DebugContext &debugContext, StringRef name = "");
  DebugContext(const DebugContext &debugContext, SourceLocation loc);
  DebugContext(DebugContext &&) noexcept;
  ~DebugContext();
  std::string getPathName() const;
  core::DebugContext &getImpl() const { return *impl; }
};
 
std::ostream &operator<<(std::ostream &os, const DebugContext &dc);
 
} // end namespace poplar
 
#endif // poplar_DebugContext_hpp