HalfFloat.hpp

// Copyright (c) 2015 Graphcore Ltd. All rights reserved.
 
#ifndef poplar_HalfFloat_hpp_
#define poplar_HalfFloat_hpp_
 
#ifdef __IPU__
 
#include <ipudef.h>
 
#else
 
#include <poplar/IeeeHalf.hpp>
#include <type_traits>
 
namespace poplar {
 
template <typename T> class HalfFloatType {
private:
  T data;
 
public:
  HalfFloatType(float val) : data(val) {
    static_assert(std::is_standard_layout<HalfFloatType>::value,
                  "Invalid HalfFloatType class layout");
  }
 
  HalfFloatType(double val) : HalfFloatType((float)val) {}
 
  HalfFloatType(int val) : HalfFloatType((float)val) {}
  HalfFloatType(unsigned val) : HalfFloatType((float)val) {}
 
  HalfFloatType(int64_t val) : HalfFloatType((float)val) {}
  HalfFloatType(uint64_t val) : HalfFloatType((float)val) {}
 
  HalfFloatType() = default;
 
  HalfFloatType &operator=(const float &other) {
    this->data = other;
    return *this;
  }
 
  operator float() const { return this->data; }
 
  HalfFloatType &operator+=(const float &other) {
    this->data += other;
    return *this;
  }
 
  HalfFloatType &operator-=(const float &other) {
    this->data -= other;
    return *this;
  }
 
  HalfFloatType &operator*=(const float &other) {
    this->data *= other;
    return *this;
  }
 
  HalfFloatType &operator/=(const float &other) {
    this->data /= other;
    return *this;
  }
};
 
typedef HalfFloatType<IeeeHalf> AccurateHalf;
typedef HalfFloatType<float> FastHalf;
 
static_assert(std::is_standard_layout<AccurateHalf>::value, "");
static_assert(std::is_standard_layout<FastHalf>::value, "");
 
template <typename T> struct is_poplar_half {
  static const bool value = false;
};
 
template <> struct is_poplar_half<AccurateHalf> {
  static const bool value = true;
};
 
template <> struct is_poplar_half<const AccurateHalf> {
  static const bool value = true;
};
 
template <> struct is_poplar_half<FastHalf> { static const bool value = true; };
 
template <> struct is_poplar_half<const FastHalf> {
  static const bool value = true;
};
 
template <> struct is_poplar_half<IeeeHalf> { static const bool value = true; };
 
template <> struct is_poplar_half<const IeeeHalf> {
  static const bool value = true;
};
 
} // End namespace poplar.
 
#ifdef POPLAR_ACCURATE_HALF
typedef poplar::AccurateHalf half;
#else
typedef poplar::FastHalf half;
#endif
 
#include <limits>
 
namespace std {
 
template <> class numeric_limits<half> {
public:
  typedef half type;
 
  static constexpr bool is_specialized = true;
 
  static constexpr const bool is_signed = true;
  static constexpr const int digits = 11;
  static constexpr const int digits10 = 3;
  static constexpr const int max_digits10 = 5;
 
  static /*constexpr*/ type min() noexcept { return type(0.0f); }
  static /*constexpr*/ type max() noexcept { return type(65504.0f); }
  static /*constexpr*/ type lowest() noexcept { return type(-max()); }
 
  static constexpr const bool is_integer = false;
  static constexpr const bool is_exact = false;
  static constexpr const int radix = 2;
 
  static /*constexpr*/ type epsilon() noexcept {
    // 2^-10
    return type(0.0009765625f);
  }
  static /*constexpr*/ type round_error() noexcept {
    // If stochastic rounding is enabled the error may be up to but
    // not equal to 1 ULP.
    return type(1.0f);
  }
 
  static constexpr const int min_exponent = -13;
  static constexpr const int min_exponent10 = -4;
  static constexpr const int max_exponent = 16;
  static constexpr const int max_exponent10 = 4;
 
  // Infinity is not supported and either saturates or is converted
  // to a quiet NaN depending on the machine settings.
  static constexpr const bool has_infinity = false;
  static constexpr const bool has_quiet_NaN = true;
  static constexpr const bool has_signaling_NaN = false;
  static constexpr const float_denorm_style has_denorm = denorm_present;
  static constexpr const bool has_denorm_loss = false;
 
  // Warning: Infinity is not fully supported on hardware. Arithmetic operations
  // never produce infinity, instead they either saturate or produce a quiet NaN
  // depending on the $FP_CTL.NANOO flag (default is saturate). If an infinity
  // is used as the input to an arithmetic operation it is treated as a
  // signalling NaN. Also conversion from float infinity to half will produce a
  // quiet NaN.
  //
  // However, comparison operations do support infinity.
  //
  // See section 2.10.4.2 in the tile manual.
  static /*constexpr*/ type infinity() noexcept {
    return type(std::numeric_limits<float>::infinity());
  }
 
  static /*constexpr*/ type quiet_NaN() noexcept {
    return type(std::numeric_limits<float>::quiet_NaN());
  }
 
  // Signalling NaNs are not supported and are generally quietened.
  static /*constexpr*/ type signaling_NaN() noexcept {
    return type(std::numeric_limits<float>::quiet_NaN());
  }
 
  static /*constexpr*/ type denorm_min() noexcept {
    // 2^-24
    return type(0.00000005960464477539f);
  }
 
  // IEC559 requires signalling NaNs which are not supported.
  static constexpr const bool is_iec559 = false;
  static constexpr const bool is_bounded = true;
  static constexpr const bool is_modulo = false;
 
  static constexpr const bool traps = false;
  static constexpr const bool tinyness_before = false;
 
  // Stochastic rounding may or may not be enabled depending on the
  // machine settings.
  static constexpr const float_round_style round_style = round_indeterminate;
};
 
} // namespace std
 
#endif // __IPU__
 
#endif // poplar_HalfFloat_hpp_