database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-07-29 08:21:15 +03:00
Code Activity

MCOL-5199 This patch solves the overal performance degradation introduced with a new way of char columns hashing

Browse Source 
in aggregation code
The patch disables padding that forces hasher to calculate over the whole 2k buffer. This patch also moves hashing code
into the common place where it belongs.
This commit is contained in:
Roman Nozdrin
2022-08-16 20:04:09 +00:00
parent 20f57b713a
commit 72e264e8ef
5 changed files with 126 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
utils/common/collation.h
View File

@ -135,8 +135,10 @@ class Charset
{
protected:
const struct charset_info_st* mCharset;
private:
static constexpr const uint flags_ = MY_STRXFRM_PAD_WITH_SPACE | MY_STRXFRM_PAD_TO_MAXLEN;
public:
Charset(CHARSET_INFO& cs) : mCharset(&cs)
{
@ -187,7 +189,7 @@ class Charset
}
size_t strnxfrm(uchar* dst, size_t dstlen, uint nweights, const uchar* src, size_t srclen, uint flags)
{
idbassert(mCharset->coll);
assert(mCharset->coll);
return mCharset->coll->strnxfrm(mCharset, dst, dstlen, nweights, src, srclen, flags);
}
// The magic check that tells that bytes are mapped to weights as 1:1
@ -195,21 +197,21 @@ class Charset
{
return (mCharset->state & MY_CS_NON1TO1) == 0;
}
template<typename T>
template <typename T>
T strnxfrm(const char* src) const
{
T ret = 0;
size_t len __attribute__((unused)) = mCharset->strnxfrm((char*)&ret, sizeof(T), sizeof(T),
src, sizeof(T), flags_);
size_t len __attribute__((unused)) =
mCharset->strnxfrm((char*)&ret, sizeof(T), sizeof(T), src, sizeof(T), flags_);
assert(len <= sizeof(T));
return ret;
}
template<typename T>
T strnxfrm(const utils::ConstString &src) const
template <typename T>
T strnxfrm(const utils::ConstString& src) const
{
T ret = 0;
size_t len __attribute__((unused)) = mCharset->strnxfrm((char*)&ret, sizeof(T), sizeof(T),
(char*)src.str(), src.length(), flags_);
size_t len __attribute__((unused)) =
mCharset->strnxfrm((char*)&ret, sizeof(T), sizeof(T), (char*)src.str(), src.length(), flags_);
assert(len <= sizeof(T));
return ret;
}

7
utils/common/conststring.h
View File

@ -66,6 +66,13 @@ class ConstString
}
return *this;
}
ConstString& rtrimSpaces()
{
for (; mLength && mStr[mLength - 1] == ' '; --mLength)
{
}
return *this;
}
};
} // namespace utils

77
utils/common/hasher.h
View File

@ -26,8 +26,10 @@
#pragma once
#include <cstddef>
#include <stdint.h>
#include <string.h>
#include <string>
#include "mcs_basic_types.h"
namespace utils
@ -203,6 +205,81 @@ class Hasher_r
}
};
// This stream hasher was borrowed from RobinHood
class Hasher64_r
{
public:
inline uint64_t operator()(const void* ptr, uint32_t len, uint64_t x = 0ULL)
{
auto const* const data64 = static_cast<uint64_t const*>(ptr);
uint64_t h = seed ^ (len * m);
std::size_t const n_blocks = len / 8;
if (x)
{
x *= m;
x ^= x >> r;
x *= m;
h ^= x;
h *= m;
}
for (std::size_t i = 0; i < n_blocks; ++i)
{
uint64_t k;
memcpy(&k, data64 + i, sizeof(k));
k *= m;
k ^= k >> r;
k *= m;
h ^= k;
h *= m;
}
auto const* const data8 = reinterpret_cast<uint8_t const*>(data64 + n_blocks);
switch (len & 7U)
{
case 7:
h ^= static_cast<uint64_t>(data8[6]) << 48U;
// FALLTHROUGH
case 6:
h ^= static_cast<uint64_t>(data8[5]) << 40U;
// FALLTHROUGH
case 5:
h ^= static_cast<uint64_t>(data8[4]) << 32U;
// FALLTHROUGH
case 4:
h ^= static_cast<uint64_t>(data8[3]) << 24U;
// FALLTHROUGH
case 3:
h ^= static_cast<uint64_t>(data8[2]) << 16U;
// FALLTHROUGH
case 2:
h ^= static_cast<uint64_t>(data8[1]) << 8U;
// FALLTHROUGH
case 1:
h ^= static_cast<uint64_t>(data8[0]);
h *= m;
// FALLTHROUGH
default: break;
}
return h;
}
inline uint64_t finalize(uint64_t h, uint64_t len) const
{
h ^= h >> r;
h *= m;
h ^= h >> r;
return h;
}
private:
static constexpr uint64_t m = 0xc6a4a7935bd1e995ULL;
static constexpr uint64_t seed = 0xe17a1465ULL;
static constexpr unsigned int r = 47;
};
class Hasher128
{
public:

107
utils/rowgroup/rowstorage.cpp
View File

@ -79,73 +79,6 @@ std::string errorString(int errNo)
auto* buf = strerror_r(errNo, tmp, sizeof(tmp));
return {buf};
}
inline uint64_t hashData(const void* ptr, uint32_t len, uint64_t x = 0ULL)
{
static constexpr uint64_t m = 0xc6a4a7935bd1e995ULL;
static constexpr uint64_t seed = 0xe17a1465ULL;
static constexpr unsigned int r = 47;
auto const* const data64 = static_cast<uint64_t const*>(ptr);
uint64_t h = seed ^ (len * m);
std::size_t const n_blocks = len / 8;
if (x)
{
x *= m;
x ^= x >> r;
x *= m;
h ^= x;
h *= m;
}
for (std::size_t i = 0; i < n_blocks; ++i)
{
uint64_t k;
memcpy(&k, data64 + i, sizeof(k));
k *= m;
k ^= k >> r;
k *= m;
h ^= k;
h *= m;
}
auto const* const data8 = reinterpret_cast<uint8_t const*>(data64 + n_blocks);
switch (len & 7U)
{
case 7:
h ^= static_cast<uint64_t>(data8[6]) << 48U;
// FALLTHROUGH
case 6:
h ^= static_cast<uint64_t>(data8[5]) << 40U;
// FALLTHROUGH
case 5:
h ^= static_cast<uint64_t>(data8[4]) << 32U;
// FALLTHROUGH
case 4:
h ^= static_cast<uint64_t>(data8[3]) << 24U;
// FALLTHROUGH
case 3:
h ^= static_cast<uint64_t>(data8[2]) << 16U;
// FALLTHROUGH
case 2:
h ^= static_cast<uint64_t>(data8[1]) << 8U;
// FALLTHROUGH
case 1:
h ^= static_cast<uint64_t>(data8[0]);
h *= m;
// FALLTHROUGH
default: break;
}
h ^= h >> r;
h *= m;
h ^= h >> r;
return h;
}
} // anonymous namespace
namespace rowgroup
@ -157,7 +90,10 @@ uint64_t hashRow(const rowgroup::Row& r, std::size_t lastCol)
return 0;
datatypes::MariaDBHasher h;
utils::Hasher64_r columnHasher;
bool strHashUsed = false;
for (uint32_t i = 0; i <= lastCol; ++i)
{
switch (r.getColType(i))
@ -167,34 +103,47 @@ uint64_t hashRow(const rowgroup::Row& r, std::size_t lastCol)
case execplan::CalpontSystemCatalog::BLOB:
case execplan::CalpontSystemCatalog::TEXT:
{
auto cs = r.getCharset(i);
auto strColValue = r.getConstString(i);
if (strColValue.length() > MaxConstStrSize)
auto strColValueLen = strColValue.length();
if (strColValueLen > MaxConstStrSize)
{
h.add(r.getCharset(i), strColValue);
h.add(cs, strColValue);
strHashUsed = true;
}
else
{
auto cs = r.getCharset(i);
uchar buf[MaxConstStrBufSize];
uint nActualWeights = cs->strnxfrm(buf, MaxConstStrBufSize, MaxConstStrBufSize,
reinterpret_cast<const uchar*>(strColValue.str()), strColValue.length(),
datatypes::Charset::getDefaultFlags());
ret = hashData(buf, nActualWeights, ret);
// This is relatively big stack allocation.
// It is aligned for future vectorization of hash calculation.
uchar buf[MaxConstStrBufSize] __attribute__((aligned(64)));
// Pay attention to the last strxfrm argument value.
// It is called flags and in many cases it has padding
// enabled(MY_STRXFRM_PAD_WITH_SPACE bit). With padding enabled
// strxfrm returns MaxConstStrBufSize bytes and not the actual
// weights array length. Here I disable padding.
auto charset = datatypes::Charset(cs);
auto trimStrColValue = strColValue.rtrimSpaces();
// The padding is disabled b/c we previously use rtrimSpaces().
// strColValueLen is used here.
size_t nActualWeights = charset.strnxfrm(buf, MaxConstStrBufSize, strColValueLen,
reinterpret_cast<const uchar*>(trimStrColValue.str()),
trimStrColValue.length(), 0);
ret = columnHasher(reinterpret_cast<const void*>(buf), nActualWeights, ret);
}
break;
}
default: ret = hashData(r.getData() + r.getOffset(i), r.getColumnWidth(i), ret); break;
default: ret = columnHasher(r.getData() + r.getOffset(i), r.getColumnWidth(i), ret); break;
}
}
// The properties of the hash produced are worse if MDB hasher results are incorporated
// so late but these results must be used very infrequently.
if (strHashUsed)
{
uint64_t strhash = h.finalize();
ret = hashData(&strhash, sizeof(strhash), ret);
ret = columnHasher(&strhash, sizeof(strhash), ret);
}
return ret;
return columnHasher.finalize(ret, lastCol << 2);
}
/** @brief NoOP interface to LRU-cache used by RowGroupStorage & HashStorage