qfloat16: add support for native _Float16 (C2x extended floating point)
The C++ equivalent is std::float16_t, defined in P1467[1], and is coming with GCC 13 both in native mode (for x86, using AVX512FP16) and in emulated mode. The C and C++ types will be the same type (<stdfloat> simply typedefs). qfloat16 will need to remain a wrapper with an integer member to keep ABI with previous Qt versions. Because it is a trivially-copyable small type, it gets currently passed in registers; the presence of the integer member means it gets passed in general-purpose registers, while a single _Float16 member would be passed in a floating-point register. See: https://gcc.godbolt.org/z/8fEendjff [1] https://wg21.link/p1467 Change-Id: I8a5b6425b64a4e319b94fffd161be56397cb48e6 Reviewed-by: Edward Welbourne <edward.welbourne@qt.io> Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>bb10
Thiago Macieira
parent
21950e3085
commit
99c7f0419e
|
|
@ -11,6 +11,11 @@
|
|||
#include <limits>
|
||||
#include <string.h>
|
||||
|
||||
#if defined(__STDCPP_FLOAT16_T__) && __has_include(<stdfloat>)
|
||||
// P1467 implementation - https://wg21.link/p1467
|
||||
# include <stdfloat>
|
||||
#endif
|
||||
|
||||
#if defined(QT_COMPILER_SUPPORTS_F16C) && defined(__AVX2__) && !defined(__F16C__)
|
||||
// All processors that support AVX2 do support F16C too, so we could enable the
|
||||
// feature unconditionally if __AVX2__ is defined. However, all currently
|
||||
|
|
@ -45,11 +50,41 @@ class qfloat16
|
|||
quint16 b16;
|
||||
constexpr inline explicit Wrap(int value) : b16(quint16(value)) {}
|
||||
};
|
||||
|
||||
public:
|
||||
#if defined(__STDCPP_FLOAT16_T__)
|
||||
# define QFLOAT16_IS_NATIVE 1
|
||||
using NativeType = std::float16_t;
|
||||
#elif defined(Q_CC_CLANG) && defined(__FLT16_MAX__) && 0
|
||||
// disabled due to https://github.com/llvm/llvm-project/issues/56963
|
||||
# define QFLOAT16_IS_NATIVE 1
|
||||
using NativeType = decltype(__FLT16_MAX__);
|
||||
#elif defined(Q_CC_GNU_ONLY) && defined(__FLT16_MAX__)
|
||||
# define QFLOAT16_IS_NATIVE 1
|
||||
# ifdef __ARM_FP16_FORMAT_IEEE
|
||||
using NativeType = __fp16;
|
||||
# else
|
||||
using NativeType = _Float16;
|
||||
# endif
|
||||
#else
|
||||
# define QFLOAT16_IS_NATIVE 0
|
||||
using NativeType = void;
|
||||
#endif
|
||||
static constexpr bool IsNative = QFLOAT16_IS_NATIVE;
|
||||
using NearestFloat = std::conditional_t<IsNative, NativeType, float>;
|
||||
|
||||
constexpr inline qfloat16() noexcept : b16(0) {}
|
||||
explicit qfloat16(Qt::Initialization) noexcept { }
|
||||
|
||||
#if QFLOAT16_IS_NATIVE
|
||||
constexpr inline qfloat16(NativeType f) : f(f) {}
|
||||
constexpr operator NativeType() const noexcept { return f; }
|
||||
#else
|
||||
inline qfloat16(float f) noexcept;
|
||||
inline operator float() const noexcept;
|
||||
#endif
|
||||
template <typename T, typename = std::enable_if_t<std::is_arithmetic_v<T> && !std::is_same_v<T, NearestFloat>>>
|
||||
explicit qfloat16(T value) noexcept : qfloat16(NearestFloat(value)) {}
|
||||
|
||||
// Support for qIs{Inf,NaN,Finite}:
|
||||
bool isInf() const noexcept { return (b16 & 0x7fff) == 0x7c00; }
|
||||
|
|
@ -73,7 +108,18 @@ public:
|
|||
inline constexpr bool isNormal() const noexcept
|
||||
{ return (b16 & 0x7c00) && (b16 & 0x7c00) != 0x7c00; }
|
||||
private:
|
||||
quint16 b16;
|
||||
// ABI note: Qt 6's qfloat16 began with just a quint16 member so it ended
|
||||
// up passed in general purpose registers in any function call taking
|
||||
// qfloat16 by value (it has trivial copy constructors). This means the
|
||||
// integer member in the anonymous union below must remain until a
|
||||
// binary-incompatible version of Qt. If you remove it, on platforms using
|
||||
// the System V ABI for C, the native type is passed in FP registers.
|
||||
union {
|
||||
quint16 b16;
|
||||
#if QFLOAT16_IS_NATIVE
|
||||
NativeType f;
|
||||
#endif
|
||||
};
|
||||
constexpr inline explicit qfloat16(Wrap nibble) noexcept : b16(nibble.b16) {}
|
||||
|
||||
Q_CORE_EXPORT static const quint32 mantissatable[];
|
||||
|
|
@ -92,17 +138,17 @@ private:
|
|||
return f;
|
||||
}
|
||||
|
||||
friend inline qfloat16 operator+(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<float>(a) + static_cast<float>(b)); }
|
||||
friend inline qfloat16 operator-(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<float>(a) - static_cast<float>(b)); }
|
||||
friend inline qfloat16 operator*(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<float>(a) * static_cast<float>(b)); }
|
||||
friend inline qfloat16 operator/(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<float>(a) / static_cast<float>(b)); }
|
||||
friend inline qfloat16 operator+(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<NearestFloat>(a) + static_cast<NearestFloat>(b)); }
|
||||
friend inline qfloat16 operator-(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<NearestFloat>(a) - static_cast<NearestFloat>(b)); }
|
||||
friend inline qfloat16 operator*(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<NearestFloat>(a) * static_cast<NearestFloat>(b)); }
|
||||
friend inline qfloat16 operator/(qfloat16 a, qfloat16 b) noexcept { return qfloat16(static_cast<NearestFloat>(a) / static_cast<NearestFloat>(b)); }
|
||||
|
||||
#define QF16_MAKE_ARITH_OP_FP(FP, OP) \
|
||||
friend inline FP operator OP(qfloat16 lhs, FP rhs) noexcept { return static_cast<FP>(lhs) OP rhs; } \
|
||||
friend inline FP operator OP(FP lhs, qfloat16 rhs) noexcept { return lhs OP static_cast<FP>(rhs); }
|
||||
#define QF16_MAKE_ARITH_OP_EQ_FP(FP, OP_EQ, OP) \
|
||||
friend inline qfloat16& operator OP_EQ(qfloat16& lhs, FP rhs) noexcept \
|
||||
{ lhs = qfloat16(float(static_cast<FP>(lhs) OP rhs)); return lhs; }
|
||||
{ lhs = qfloat16(NearestFloat(static_cast<FP>(lhs) OP rhs)); return lhs; }
|
||||
#define QF16_MAKE_ARITH_OP(FP) \
|
||||
QF16_MAKE_ARITH_OP_FP(FP, +) \
|
||||
QF16_MAKE_ARITH_OP_FP(FP, -) \
|
||||
|
|
@ -116,6 +162,9 @@ private:
|
|||
QF16_MAKE_ARITH_OP(long double)
|
||||
QF16_MAKE_ARITH_OP(double)
|
||||
QF16_MAKE_ARITH_OP(float)
|
||||
#if QFLOAT16_IS_NATIVE
|
||||
QF16_MAKE_ARITH_OP(NativeType)
|
||||
#endif
|
||||
#undef QF16_MAKE_ARITH_OP
|
||||
#undef QF16_MAKE_ARITH_OP_FP
|
||||
|
||||
|
|
@ -132,12 +181,12 @@ private:
|
|||
QT_WARNING_PUSH
|
||||
QT_WARNING_DISABLE_FLOAT_COMPARE
|
||||
|
||||
friend inline bool operator>(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) > static_cast<float>(b); }
|
||||
friend inline bool operator<(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) < static_cast<float>(b); }
|
||||
friend inline bool operator>=(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) >= static_cast<float>(b); }
|
||||
friend inline bool operator<=(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) <= static_cast<float>(b); }
|
||||
friend inline bool operator==(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) == static_cast<float>(b); }
|
||||
friend inline bool operator!=(qfloat16 a, qfloat16 b) noexcept { return static_cast<float>(a) != static_cast<float>(b); }
|
||||
friend inline bool operator>(qfloat16 a, qfloat16 b) noexcept { return static_cast<NearestFloat>(a) > static_cast<NearestFloat>(b); }
|
||||
friend inline bool operator<(qfloat16 a, qfloat16 b) noexcept { return static_cast<NearestFloat>(a) < static_cast<NearestFloat>(b); }
|
||||
friend inline bool operator>=(qfloat16 a, qfloat16 b) noexcept { return static_cast<NearestFloat>(a) >= static_cast<NearestFloat>(b); }
|
||||
friend inline bool operator<=(qfloat16 a, qfloat16 b) noexcept { return static_cast<NearestFloat>(a) <= static_cast<NearestFloat>(b); }
|
||||
friend inline bool operator==(qfloat16 a, qfloat16 b) noexcept { return static_cast<NearestFloat>(a) == static_cast<NearestFloat>(b); }
|
||||
friend inline bool operator!=(qfloat16 a, qfloat16 b) noexcept { return static_cast<NearestFloat>(a) != static_cast<NearestFloat>(b); }
|
||||
|
||||
#define QF16_MAKE_BOOL_OP_FP(FP, OP) \
|
||||
friend inline bool operator OP(qfloat16 lhs, FP rhs) noexcept { return static_cast<FP>(lhs) OP rhs; } \
|
||||
|
|
@ -157,8 +206,8 @@ QT_WARNING_DISABLE_FLOAT_COMPARE
|
|||
#undef QF16_MAKE_BOOL_OP_FP
|
||||
|
||||
#define QF16_MAKE_BOOL_OP_INT(OP) \
|
||||
friend inline bool operator OP(qfloat16 a, int b) noexcept { return static_cast<float>(a) OP static_cast<float>(b); } \
|
||||
friend inline bool operator OP(int a, qfloat16 b) noexcept { return static_cast<float>(a) OP static_cast<float>(b); }
|
||||
friend inline bool operator OP(qfloat16 a, int b) noexcept { return static_cast<NearestFloat>(a) OP static_cast<NearestFloat>(b); } \
|
||||
friend inline bool operator OP(int a, qfloat16 b) noexcept { return static_cast<NearestFloat>(a) OP static_cast<NearestFloat>(b); }
|
||||
|
||||
QF16_MAKE_BOOL_OP_INT(>)
|
||||
QF16_MAKE_BOOL_OP_INT(<)
|
||||
|
|
@ -188,6 +237,21 @@ Q_CORE_EXPORT void qFloatFromFloat16(float *, const qfloat16 *, qsizetype length
|
|||
[[nodiscard]] inline int qFpClassify(qfloat16 f) noexcept { return f.fpClassify(); }
|
||||
// [[nodiscard]] quint32 qFloatDistance(qfloat16 a, qfloat16 b);
|
||||
|
||||
[[nodiscard]] inline qfloat16 qSqrt(qfloat16 f)
|
||||
{
|
||||
#if defined(__cpp_lib_extended_float) && defined(__STDCPP_FLOAT16_T__) && 0
|
||||
// https://wg21.link/p1467 - disabled until tested
|
||||
using namespace std;
|
||||
return sqrt(f);
|
||||
#endif
|
||||
|
||||
// WG14's N2601 does not provide a way to tell which types an
|
||||
// implementation supports, so we assume it doesn't and fall back to FP32
|
||||
float f32 = float(f);
|
||||
f32 = sqrtf(f32);
|
||||
return qfloat16::NearestFloat(f32);
|
||||
}
|
||||
|
||||
// The remainder of these utility functions complement qglobal.h
|
||||
[[nodiscard]] inline int qRound(qfloat16 d) noexcept
|
||||
{ return qRound(static_cast<float>(d)); }
|
||||
|
|
@ -197,8 +261,8 @@ Q_CORE_EXPORT void qFloatFromFloat16(float *, const qfloat16 *, qsizetype length
|
|||
|
||||
[[nodiscard]] inline bool qFuzzyCompare(qfloat16 p1, qfloat16 p2) noexcept
|
||||
{
|
||||
float f1 = static_cast<float>(p1);
|
||||
float f2 = static_cast<float>(p2);
|
||||
qfloat16::NearestFloat f1 = static_cast<qfloat16::NearestFloat>(p1);
|
||||
qfloat16::NearestFloat f2 = static_cast<qfloat16::NearestFloat>(p2);
|
||||
// The significand precision for IEEE754 half precision is
|
||||
// 11 bits (10 explicitly stored), or approximately 3 decimal
|
||||
// digits. In selecting the fuzzy comparison factor of 102.5f
|
||||
|
|
@ -222,9 +286,9 @@ Q_CORE_EXPORT void qFloatFromFloat16(float *, const qfloat16 *, qsizetype length
|
|||
}
|
||||
|
||||
inline int qIntCast(qfloat16 f) noexcept
|
||||
{ return int(static_cast<float>(f)); }
|
||||
{ return int(static_cast<qfloat16::NearestFloat>(f)); }
|
||||
|
||||
#ifndef Q_QDOC
|
||||
#if !defined(Q_QDOC) && !QFLOAT16_IS_NATIVE
|
||||
QT_WARNING_PUSH
|
||||
QT_WARNING_DISABLE_CLANG("-Wc99-extensions")
|
||||
QT_WARNING_DISABLE_GCC("-Wold-style-cast")
|
||||
|
|
@ -284,33 +348,52 @@ inline qfloat16::operator float() const noexcept
|
|||
return f;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
#endif // Q_QDOC and non-native
|
||||
|
||||
/*
|
||||
qHypot compatibility; see ../kernel/qmath.h
|
||||
*/
|
||||
namespace QtPrivate {
|
||||
template <typename R>
|
||||
struct QHypotType<R, qfloat16> { using type = decltype(std::hypot(R(1), 1.0f)); };
|
||||
template <typename R>
|
||||
struct QHypotType<qfloat16, R> { using type = decltype(std::hypot(1.0f, R(1))); };
|
||||
template <> struct QHypotType<qfloat16, qfloat16> { using type = qfloat16; };
|
||||
template <> struct QHypotType<qfloat16, qfloat16>
|
||||
{
|
||||
using type = qfloat16;
|
||||
};
|
||||
template <typename R> struct QHypotType<R, qfloat16>
|
||||
{
|
||||
using type = std::conditional_t<std::is_floating_point_v<R>, R, double>;
|
||||
};
|
||||
template <typename R> struct QHypotType<qfloat16, R> : QHypotType<R, qfloat16>
|
||||
{
|
||||
};
|
||||
}
|
||||
|
||||
// Avoid passing qfloat16 to std::hypot(), while ensuring return types
|
||||
// consistent with the above:
|
||||
template<typename F, typename ...Fs> auto qHypot(F first, Fs... rest);
|
||||
template <typename T, typename std::enable_if<!std::is_same<qfloat16, T>::value, int>::type = 0>
|
||||
auto qHypot(T x, qfloat16 y) { return qHypot(x, float(y)); }
|
||||
template <typename T, typename std::enable_if<!std::is_same<qfloat16, T>::value, int>::type = 0>
|
||||
auto qHypot(qfloat16 x, T y) { return qHypot(float(x), y); }
|
||||
template <> inline auto qHypot(qfloat16 x, qfloat16 y)
|
||||
inline auto qHypot(qfloat16 x, qfloat16 y)
|
||||
{
|
||||
#if (defined(QT_COMPILER_SUPPORTS_F16C) && defined(__F16C__)) || defined (__ARM_FP16_FORMAT_IEEE)
|
||||
#if defined(QT_COMPILER_SUPPORTS_F16C) && defined(__F16C__) || QFLOAT16_IS_NATIVE
|
||||
return QtPrivate::QHypotHelper<qfloat16>(x).add(y).result();
|
||||
#else
|
||||
return qfloat16(qHypot(float(x), float(y)));
|
||||
#endif
|
||||
}
|
||||
|
||||
// in ../kernel/qmath.h
|
||||
template<typename F, typename ...Fs> auto qHypot(F first, Fs... rest);
|
||||
|
||||
template <typename T> typename QtPrivate::QHypotType<T, qfloat16>::type
|
||||
qHypot(T x, qfloat16 y)
|
||||
{
|
||||
if constexpr (std::is_floating_point_v<T>)
|
||||
return qHypot(x, float(y));
|
||||
else
|
||||
return qHypot(qfloat16(x), y);
|
||||
}
|
||||
template <typename T> auto qHypot(qfloat16 x, T y)
|
||||
{
|
||||
return qHypot(y, x);
|
||||
}
|
||||
|
||||
#if defined(__cpp_lib_hypot) && __cpp_lib_hypot >= 201603L // Expected to be true
|
||||
// If any are not qfloat16, convert each qfloat16 to float:
|
||||
/* (The following splits the some-but-not-all-qfloat16 cases up, using
|
||||
|
|
@ -320,22 +403,22 @@ template <typename Ty, typename Tz,
|
|||
typename std::enable_if<
|
||||
// Ty, Tz aren't both qfloat16:
|
||||
!(std::is_same_v<qfloat16, Ty> && std::is_same_v<qfloat16, Tz>), int>::type = 0>
|
||||
auto qHypot(qfloat16 x, Ty y, Tz z) { return qHypot(float(x), y, z); }
|
||||
auto qHypot(qfloat16 x, Ty y, Tz z) { return qHypot(qfloat16::NearestFloat(x), y, z); }
|
||||
template <typename Tx, typename Tz,
|
||||
typename std::enable_if<
|
||||
// Tx isn't qfloat16:
|
||||
!std::is_same_v<qfloat16, Tx>, int>::type = 0>
|
||||
auto qHypot(Tx x, qfloat16 y, Tz z) { return qHypot(x, float(y), z); }
|
||||
auto qHypot(Tx x, qfloat16 y, Tz z) { return qHypot(x, qfloat16::NearestFloat(y), z); }
|
||||
template <typename Tx, typename Ty,
|
||||
typename std::enable_if<
|
||||
// Neither Tx nor Ty is qfloat16:
|
||||
!std::is_same_v<qfloat16, Tx> && !std::is_same_v<qfloat16, Ty>, int>::type = 0>
|
||||
auto qHypot(Tx x, Ty y, qfloat16 z) { return qHypot(x, y, float(z)); }
|
||||
auto qHypot(Tx x, Ty y, qfloat16 z) { return qHypot(x, y, qfloat16::NearestFloat(z)); }
|
||||
|
||||
// If all are qfloat16, stay with qfloat16 (albeit via float, if no native support):
|
||||
template <>
|
||||
inline auto qHypot(qfloat16 x, qfloat16 y, qfloat16 z)
|
||||
{
|
||||
#if (defined(QT_COMPILER_SUPPORTS_F16C) && defined(__F16C__)) || defined (__ARM_FP16_FORMAT_IEEE)
|
||||
#if (defined(QT_COMPILER_SUPPORTS_F16C) && defined(__F16C__)) || QFLOAT16_IS_NATIVE
|
||||
return QtPrivate::QHypotHelper<qfloat16>(x).add(y).add(z).result();
|
||||
#else
|
||||
return qfloat16(qHypot(float(x), float(y), float(z)));
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ class QHypotHelper
|
|||
public:
|
||||
QHypotHelper(T first) : scale(qAbs(first)), total(1) {}
|
||||
T result() const
|
||||
{ return qIsFinite(scale) ? scale > 0 ? scale * T(std::sqrt(total)) : T(0) : scale; }
|
||||
{ return qIsFinite(scale) ? scale > 0 ? scale * T(qSqrt(total)) : T(0) : scale; }
|
||||
|
||||
template<typename F, typename ...Fs>
|
||||
auto add(F first, Fs... rest) const
|
||||
|
|
@ -133,7 +133,7 @@ public:
|
|||
return QHypotHelper<R>(scale, total);
|
||||
if (val > scale) {
|
||||
const R ratio = scale / next;
|
||||
return QHypotHelper<R>(val, total * ratio * ratio + 1);
|
||||
return QHypotHelper<R>(val, total * ratio * ratio + R(1));
|
||||
}
|
||||
const R ratio = next / scale;
|
||||
return QHypotHelper<R>(scale, total + ratio * ratio);
|
||||
|
|
|
|||
|
|
@ -301,7 +301,7 @@ void tst_qfloat16::promotionTests()
|
|||
QCOMPARE(sizeof(double),sizeof(qfloat16(1.f)*1));
|
||||
QCOMPARE(sizeof(double),sizeof(qfloat16(1.f)/1));
|
||||
|
||||
QCOMPARE(QString::number(1.f),QString::number(qfloat16(1.f)));
|
||||
QCOMPARE(QString::number(1.f),QString::number(double(qfloat16(1.f))));
|
||||
}
|
||||
|
||||
void tst_qfloat16::arithOps_data()
|
||||
|
|
@ -624,7 +624,7 @@ void tst_qfloat16::mantissaOverflow()
|
|||
float f;
|
||||
memcpy(&f, &in, 4);
|
||||
|
||||
qfloat16 f16 = f;
|
||||
qfloat16 f16 = qfloat16(f);
|
||||
qfloat16 f16s[1];
|
||||
qFloatToFloat16(f16s, &f, 1);
|
||||
QCOMPARE(f16, f16s[0]);
|
||||
|
|
|
|||
Loading…
Reference in New Issue