ProfileValue.hpp

// Copyright (c) 2019 Graphcore Ltd. All rights reserved.
 
#ifndef poplar_Profile_hpp
#define poplar_Profile_hpp
 
#include <poplar/OptionFlags.hpp>
#include <poplar/StringRef.hpp>
 
#include <map>
#include <memory>
#include <string>
#include <type_traits>
 
#include <cstdint>
 
namespace poplar {
 
namespace core {
class MutableProfileValue;
}
 
class ProfileValue {
public:
  enum class Type {
    BOOL_,
    STRING,
    NUMBER,
    VECTOR,
    MAP,
  };
 
  using Boolean = bool;
  using Number = double;
  using String = std::string;
  using Vector = std::vector<ProfileValue>;
  using Map = std::map<std::string, ProfileValue>;
 
  struct Storage {
    std::aligned_union<1, Boolean, Number, String, Vector, Map>::type buffer;
  };
 
  // Get the type of this value.
  Type type() const;
 
  // String access. Throws if type() != Type::STRING.
  const String &asString() const;
 
  // Boolean access. Throws if type() != Type::BOOL_.
  Boolean asBool() const;
  // Number access (asInt() truncates). Throws if type() != Type::NUMBER.
  std::int64_t asInt() const;
  // Number access (asUInt() truncates). Throws if type() != Type::NUMBER or not
  // representable as uint64_t
  std::uint64_t asUint() const;
  double asDouble() const;
 
  // Map access.
  // Throws if type() != Type::MAP, or if the key does not exist.
  const ProfileValue &operator[](StringRef s) const;
  // Returns nullptr if the key does not exist.
  const ProfileValue *getOrNull(StringRef s) const;
  const Map &asMap() const;
 
  // Array access. Throws if type() != Type::VECTOR or if it is out of range.
  const ProfileValue &operator[](std::size_t i) const;
  const Vector &asVector() const;
 
  // Converts each element to std::uint64_t
  // Throws if type() != Type::VECTOR or element.type() != Type::NUMBER
  std::vector<std::uint64_t> toUintVector() const;
 
  // Array or map size. Throws if type() != Type::MAP && type() != Type::VECTOR.
  std::size_t size() const;
 
  // If the value is a vector that only contains numbers, these return
  // their sum. Otherwise they throw an exception.
  double sumDouble() const;
  std::int64_t sumInt() const;
  std::uint64_t sumUint() const;
  // If the value is a vector of vectors of numbers return their sum. Otherwise
  // throw an exception. Useful eg to accumulate totals over all compute sets
  // across  all tiles
  std::int64_t sum2DInt() const;
  std::uint64_t sum2DUint() const;
 
  // Compare values for equality. Note this will involve traversing the
  // entire tree of values until it finds an inequality so it may be slow.
  bool operator==(const ProfileValue &other) const;
  bool operator!=(const ProfileValue &other) const;
 
  // Default value is 0.0.
  ProfileValue() : ProfileValue(0.0) {}
 
  ProfileValue(String init);
  ProfileValue(Vector init);
  ProfileValue(Map init);
  ProfileValue(Number init);
  explicit ProfileValue(Boolean init);
 
  // Disambiguate cast from integral type to Number
  template <class T, typename = typename std::enable_if<
                         std::is_integral<T>::value>::type>
  ProfileValue(T init) : ProfileValue(ProfileValue::Number(init)) {}
 
  // Disambiguate conversion from const char* to bool, which is preferred over
  // std::string
  ProfileValue(const char *init) : ProfileValue(ProfileValue::String(init)) {}
 
  ~ProfileValue();
 
  ProfileValue(const ProfileValue &other);
  ProfileValue(ProfileValue &&other) noexcept;
 
  ProfileValue &operator=(const ProfileValue &other);
  ProfileValue &operator=(ProfileValue &&other) noexcept;
  ProfileValue &operator=(Boolean init);
  ProfileValue &operator=(Number init);
  ProfileValue &operator=(String init);
  ProfileValue &operator=(Vector init);
  ProfileValue &operator=(Map init);
 
  // Disambiguate cast from any non-boolean integral type to Number
  template <class T, typename = typename std::enable_if<
                         std::is_integral<T>::value>::type>
  ProfileValue &operator=(T init) {
    return operator=(ProfileValue::Number(init));
  }
 
private:
  friend class core::MutableProfileValue;
 
  // Size of this should be about 3 pointers (24 bytes) which uses more memory
  // than storing a single pointer (8 bytes) but is faster and simpler.
  Storage v;
  Type t;
};
 
void serializeToJSON(std::ostream &out, const ProfileValue &val,
                     bool prettyPrint = false);
 
void serializeToCBOR(std::ostream &out, const ProfileValue &val,
                     bool withTag = true);
 
std::ostream &operator<<(std::ostream &os, const ProfileValue &v);
 
void printGraphSummary(std::ostream &out, const std::string &databasePath,
                       const OptionFlags &opts);
 
void printExecutionSummary(std::ostream &out, const std::string &databasePath,
                           const OptionFlags &opts);
 
void printProfileSummary(std::ostream &out, const std::string &databasePath,
                         const OptionFlags &opts = {});
 
} // namespace poplar
 
#endif // poplar_Profile_hpp