ClickHouse/dbms/Common/UInt128.h

220 lines
6.3 KiB
C++
Raw Normal View History

#pragma once
2017-07-24 12:58:01 +00:00
#include <tuple>
#include <sstream>
#include <iomanip>
#include <city.h>
#include <Core/Types.h>
#ifdef __SSE4_2__
#include <nmmintrin.h>
#endif
namespace DB
{
/// For aggregation by SipHash, UUID type or concatenation of several fields.
struct UInt128
{
2017-07-04 16:10:36 +00:00
/// Suppress gcc7 warnings: 'prev_key.DB::UInt128::low' may be used uninitialized in this function
#if !__clang__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
/// This naming assumes little endian.
2017-07-04 16:10:36 +00:00
UInt64 low;
UInt64 high;
UInt128() = default;
2019-08-03 11:02:40 +00:00
explicit UInt128(const UInt64 low_, const UInt64 high_) : low(low_), high(high_) {}
2018-08-15 15:29:57 +00:00
explicit UInt128(const UInt64 rhs) : low(rhs), high() {}
auto tuple() const { return std::tie(high, low); }
2017-07-05 10:03:24 +00:00
String toHexString() const
{
std::ostringstream os;
os << std::setw(16) << std::setfill('0') << std::hex << high << low;
return String(os.str());
}
bool inline operator== (const UInt128 rhs) const { return tuple() == rhs.tuple(); }
bool inline operator!= (const UInt128 rhs) const { return tuple() != rhs.tuple(); }
bool inline operator< (const UInt128 rhs) const { return tuple() < rhs.tuple(); }
bool inline operator<= (const UInt128 rhs) const { return tuple() <= rhs.tuple(); }
bool inline operator> (const UInt128 rhs) const { return tuple() > rhs.tuple(); }
bool inline operator>= (const UInt128 rhs) const { return tuple() >= rhs.tuple(); }
template <typename T> bool inline operator== (const T rhs) const { return *this == UInt128(rhs); }
template <typename T> bool inline operator!= (const T rhs) const { return *this != UInt128(rhs); }
template <typename T> bool inline operator>= (const T rhs) const { return *this >= UInt128(rhs); }
template <typename T> bool inline operator> (const T rhs) const { return *this > UInt128(rhs); }
template <typename T> bool inline operator<= (const T rhs) const { return *this <= UInt128(rhs); }
template <typename T> bool inline operator< (const T rhs) const { return *this < UInt128(rhs); }
2017-09-15 12:16:12 +00:00
template <typename T> explicit operator T() const { return static_cast<T>(low); }
#if !__clang__
#pragma GCC diagnostic pop
#endif
UInt128 & operator= (const UInt64 rhs) { low = rhs; high = 0; return *this; }
};
template <typename T> bool inline operator== (T a, const UInt128 b) { return UInt128(a) == b; }
template <typename T> bool inline operator!= (T a, const UInt128 b) { return UInt128(a) != b; }
template <typename T> bool inline operator>= (T a, const UInt128 b) { return UInt128(a) >= b; }
template <typename T> bool inline operator> (T a, const UInt128 b) { return UInt128(a) > b; }
template <typename T> bool inline operator<= (T a, const UInt128 b) { return UInt128(a) <= b; }
template <typename T> bool inline operator< (T a, const UInt128 b) { return UInt128(a) < b; }
2019-05-30 08:23:20 +00:00
template <> inline constexpr bool IsNumber<UInt128> = true;
template <> struct TypeName<UInt128> { static const char * get() { return "UInt128"; } };
template <> struct TypeId<UInt128> { static constexpr const TypeIndex value = TypeIndex::UInt128; };
2017-07-05 12:40:41 +00:00
struct UInt128Hash
{
size_t operator()(UInt128 x) const
{
2017-07-04 16:10:36 +00:00
return CityHash_v1_0_2::Hash128to64({x.low, x.high});
}
};
#ifdef __SSE4_2__
struct UInt128HashCRC32
{
size_t operator()(UInt128 x) const
{
UInt64 crc = -1ULL;
2017-07-04 16:10:36 +00:00
crc = _mm_crc32_u64(crc, x.low);
crc = _mm_crc32_u64(crc, x.high);
return crc;
}
};
#else
2017-05-07 20:25:26 +00:00
/// On other platforms we do not use CRC32. NOTE This can be confusing.
struct UInt128HashCRC32 : public UInt128Hash {};
#endif
struct UInt128TrivialHash
{
2017-07-04 16:10:36 +00:00
size_t operator()(UInt128 x) const { return x.low; }
};
2017-05-07 20:25:26 +00:00
/** Used for aggregation, for putting a large number of constant-length keys in a hash table.
*/
struct UInt256
{
/// Suppress gcc7 warnings: 'prev_key.DB::UInt256::a' may be used uninitialized in this function
#if !__clang__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
UInt64 a;
UInt64 b;
UInt64 c;
UInt64 d;
bool operator== (const UInt256 rhs) const
{
return a == rhs.a && b == rhs.b && c == rhs.c && d == rhs.d;
2015-02-22 15:30:31 +00:00
2017-05-07 20:25:26 +00:00
/* So it's no better.
return 0xFFFF == _mm_movemask_epi8(_mm_and_si128(
_mm_cmpeq_epi8(
_mm_loadu_si128(reinterpret_cast<const __m128i *>(&a)),
_mm_loadu_si128(reinterpret_cast<const __m128i *>(&rhs.a))),
_mm_cmpeq_epi8(
_mm_loadu_si128(reinterpret_cast<const __m128i *>(&c)),
_mm_loadu_si128(reinterpret_cast<const __m128i *>(&rhs.c)))));*/
}
bool operator!= (const UInt256 rhs) const { return !operator==(rhs); }
bool operator== (const UInt64 rhs) const { return a == rhs && b == 0 && c == 0 && d == 0; }
bool operator!= (const UInt64 rhs) const { return !operator==(rhs); }
#if !__clang__
#pragma GCC diagnostic pop
#endif
UInt256 & operator= (const UInt64 rhs) { a = rhs; b = 0; c = 0; d = 0; return *this; }
};
struct UInt256Hash
{
size_t operator()(UInt256 x) const
{
/// NOTE suboptimal
2017-06-21 08:35:38 +00:00
return CityHash_v1_0_2::Hash128to64({CityHash_v1_0_2::Hash128to64({x.a, x.b}), CityHash_v1_0_2::Hash128to64({x.c, x.d})});
}
};
#ifdef __SSE4_2__
struct UInt256HashCRC32
{
size_t operator()(UInt256 x) const
{
UInt64 crc = -1ULL;
crc = _mm_crc32_u64(crc, x.a);
crc = _mm_crc32_u64(crc, x.b);
crc = _mm_crc32_u64(crc, x.c);
crc = _mm_crc32_u64(crc, x.d);
return crc;
}
};
#else
2017-05-07 20:25:26 +00:00
/// We do not need to use CRC32 on other platforms. NOTE This can be confusing.
struct UInt256HashCRC32 : public UInt256Hash {};
#endif
2019-11-02 05:55:06 +00:00
}
template <> struct is_signed<DB::UInt128>
{
static constexpr bool value = false;
};
template <> struct is_unsigned<DB::UInt128>
{
static constexpr bool value = true;
};
2017-07-05 12:40:41 +00:00
template <> struct is_integral<DB::UInt128>
{
static constexpr bool value = true;
};
// Operator +, -, /, *, % aren't implemented so it's not an arithmetic type
template <> struct is_arithmetic<DB::UInt128>
{
static constexpr bool value = false;
};
2019-11-02 05:55:06 +00:00
/// Overload hash for type casting
namespace std
{
template <> struct hash<DB::UInt128>
{
size_t operator()(const DB::UInt128 & u) const
{
return CityHash_v1_0_2::Hash128to64({u.low, u.high});
}
};
}