Type.hpp

// Copyright (c) 2017 Graphcore Ltd. All rights reserved.
 
#ifndef poplar_Type_hpp
#define poplar_Type_hpp
#include <ostream>
#include <poplar/Quarter.hpp>
#include <poplar/SSOPointer.hpp>
#include <poplar/StringRef.hpp>
 
namespace poplar {
namespace core {
class Type;
} // namespace core
 
class Type {
public:
  Type();
  ~Type();
  Type(const Type &other);
  Type(Type &&other) noexcept;
  Type &operator=(const Type &other);
  Type &operator=(Type &&other) noexcept;
 
  StringRef toString() const;
  bool operator==(const Type &other) const;
  bool operator!=(const Type &other) const { return !(*this == other); }
  bool operator<(const Type &other) const;
 
  // Implementation
  Type(SSOPointer<core::Type>);
  const core::Type &getImpl() const;
 
  std::size_t hash() const;
 
  bool isFloatingPoint() const;
 
  bool requiresMetadata() const;
 
private:
  SSOPointer<core::Type> impl;
};
 
inline std::ostream &operator<<(std::ostream &os, const Type &t) {
  return os << t.toString();
}
 
/* Valid types are as follows.
 *
 * | Type                    | Kind      | Signed  |
 * |-------------------------|-----------|---------|
 * | `bool`                  | boolean   | No      |
 * | `char`                  | integral  | Yes     |
 * | `signed char`           | integral  | Yes     |
 * | `unsigned char`         | integral  | No      |
 * | `short`                 | integral  | Yes     |
 * | `signed short`          | integral  | Yes     |
 * | `unsigned short`        | integral  | No      |
 * | `int`                   | integral  | Yes     |
 * | `unsigned int`          | integral  | No      |
 * | `long`                  | integral  | Yes     |
 * | `unsigned long`         | integral  | No      |
 * | `long long`             | integral  | Yes     |
 * | `unsigned long long`    | integral  | No      |
 * | `half`                  | real      | Yes     |
 * | `float`                 | real      | Yes     |
 * | `double`                | real      | Yes     |
 *
 * The sizes follow the rules in the C specification: sizeof(short) >= 2,
 * sizeof(int) >= sizeof(short), and so on. For using CPU-based Poplar backends,
 * the type sizes will be the same as the host.
 *
 * For IPU based backends the following types are NOT supported:
 *
 *     * long
 *     * unsigned long
 *     * double
 *
 *
 * And limited support for operations with the following types:
 *
 *     * long long
 *     * unsigned long long
 *
 * For supported types the sizes on the IPU architectures are:
 *
 * | Type                    | Size (bytes) |
 * |-------------------------|--------------|
 * | `bool`                  | 1            |
 * | `char`                  | 1            |
 * | `signed char`           | 1            |
 * | `unsigned char`         | 1            |
 * | `short`                 | 2            |
 * | `signed short`          | 2            |
 * | `unsigned short`        | 2            |
 * | `int`                   | 4            |
 * | `signed int`            | 4            |
 * | `signed`                | 4            |
 * | `unsigned int`          | 4            |
 * | `unsigned`              | 4            |
 * | `unsigned long long`    | 8            |
 * | `long long`             | 8            |
 * | `half`                  | 2            |
 * | `float`                 | 4            |
 *
 */
 
extern Type BOOL;
 
extern Type CHAR;
 
extern Type UNSIGNED_CHAR;
 
extern Type SIGNED_CHAR;
 
extern Type UNSIGNED_SHORT;
 
extern Type SHORT;
 
extern Type UNSIGNED_INT;
 
extern Type INT;
 
extern Type UNSIGNED_LONG;
 
extern Type LONG;
 
extern Type UNSIGNED_LONGLONG;
 
extern Type LONGLONG;
 
extern Type QUARTER;
 
extern Type QUARTER_METADATA;
 
extern Type HALF;
 
extern Type FLOAT;
 
template <typename T> struct equivalent_device_type {};
 
#define POPLAR_DECLARE_EQUIV_TYPE(T1, T2)                                      \
  template <> struct equivalent_device_type<T1> {                              \
    const Type &value = T2;                                                    \
  };
 
POPLAR_DECLARE_EQUIV_TYPE(bool, BOOL)
POPLAR_DECLARE_EQUIV_TYPE(char, CHAR)
POPLAR_DECLARE_EQUIV_TYPE(unsigned char, UNSIGNED_CHAR)
POPLAR_DECLARE_EQUIV_TYPE(signed char, SIGNED_CHAR)
POPLAR_DECLARE_EQUIV_TYPE(unsigned short, UNSIGNED_SHORT)
POPLAR_DECLARE_EQUIV_TYPE(signed short, SHORT)
POPLAR_DECLARE_EQUIV_TYPE(unsigned int, UNSIGNED_INT)
POPLAR_DECLARE_EQUIV_TYPE(signed int, INT)
POPLAR_DECLARE_EQUIV_TYPE(unsigned long, UNSIGNED_LONG)
POPLAR_DECLARE_EQUIV_TYPE(signed long, LONG)
POPLAR_DECLARE_EQUIV_TYPE(unsigned long long, UNSIGNED_LONGLONG)
POPLAR_DECLARE_EQUIV_TYPE(signed long long, LONGLONG)
POPLAR_DECLARE_EQUIV_TYPE(float, FLOAT)
POPLAR_DECLARE_EQUIV_TYPE(QuarterMetadata, QUARTER_METADATA)
 
#undef POPLAR_DECLARE_EQUIV_TYPE
 
} // end namespace poplar
 
namespace std {
 
template <> struct hash<poplar::Type> {
  size_t operator()(const poplar::Type &t) const { return t.hash(); }
};
 
} // namespace std
 
#endif // poplar_Type_hpp