mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-11-23 16:12:01 +00:00
Vectorize AssociativeGenericApplierImpl::apply (#43669)
* Vectorize AssociativeGenericApplierImpl::apply This commit achieved the auto-vectorization by redefining numerical values of ternary representations and corresponding implementations of And/Or operators, caching the intermediate ternary values in a continuous range of memory for the SIMD instructions to consume, and removing the short-circuit for the ternary logic evaluation. * Optimize TernaryValueBuilder for ColumnNullable The numerical representation of a ColumnNullable is calculated from the data column of any data type and the null map column of UInt8 with a bitwise operation expression, which is efficient for auto- vectorization. However, when this expression is applied to a data column of a type other than UInt8, the SIMD register is not fully utilized due to the mismatch of data types, and the data throughput regresses. To optimize the SIMD register usage, the has_value flag is firstly evaluated from the data column and stored in a UInt8 array. Then it is loaded from memory before the calculation of bitwise operation expression, so that the types of the operands are both UInt8.
This commit is contained in:
Zhiguo Zhou
GitHub
parent
e99849d031
commit
8b20e9f505
@ -16,6 +16,7 @@
|
||||
#include <Functions/FunctionUnaryArithmetic.h>
|
||||
#include <Common/FieldVisitors.h>
|
||||
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
|
||||
|
||||
@ -94,7 +95,7 @@ void convertAnyColumnToBool(const IColumn * column, UInt8Container & res)
|
||||
}
|
||||
|
||||
|
||||
template <class Op, typename Func>
|
||||
template <class Op, bool IsTernary, typename Func>
|
||||
bool extractConstColumns(ColumnRawPtrs & in, UInt8 & res, Func && func)
|
||||
{
|
||||
bool has_res = false;
|
||||
@ -112,7 +113,10 @@ bool extractConstColumns(ColumnRawPtrs & in, UInt8 & res, Func && func)
|
||||
|
||||
if (has_res)
|
||||
{
|
||||
res = Op::apply(res, x);
|
||||
if constexpr (IsTernary)
|
||||
res = Op::ternaryApply(res, x);
|
||||
else
|
||||
res = Op::apply(res, x);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -129,7 +133,7 @@ bool extractConstColumns(ColumnRawPtrs & in, UInt8 & res, Func && func)
|
||||
template <class Op>
|
||||
inline bool extractConstColumnsAsBool(ColumnRawPtrs & in, UInt8 & res)
|
||||
{
|
||||
return extractConstColumns<Op>(
|
||||
return extractConstColumns<Op, false>(
|
||||
in, res,
|
||||
[](const Field & value)
|
||||
{
|
||||
@ -141,7 +145,7 @@ inline bool extractConstColumnsAsBool(ColumnRawPtrs & in, UInt8 & res)
|
||||
template <class Op>
|
||||
inline bool extractConstColumnsAsTernary(ColumnRawPtrs & in, UInt8 & res_3v)
|
||||
{
|
||||
return extractConstColumns<Op>(
|
||||
return extractConstColumns<Op, true>(
|
||||
in, res_3v,
|
||||
[](const Field & value)
|
||||
{
|
||||
@ -192,47 +196,74 @@ private:
|
||||
};
|
||||
|
||||
|
||||
/// A helper class used by AssociativeGenericApplierImpl
|
||||
/// Allows for on-the-fly conversion of any data type into intermediate ternary representation
|
||||
using TernaryValueGetter = std::function<Ternary::ResultType (size_t)>;
|
||||
|
||||
template <typename ... Types>
|
||||
struct ValueGetterBuilderImpl;
|
||||
struct TernaryValueBuilderImpl;
|
||||
|
||||
template <typename Type, typename ...Types>
|
||||
struct ValueGetterBuilderImpl<Type, Types...>
|
||||
struct TernaryValueBuilderImpl<Type, Types...>
|
||||
{
|
||||
static TernaryValueGetter build(const IColumn * x)
|
||||
static void build(const IColumn * x, UInt8* __restrict ternary_column_data)
|
||||
{
|
||||
size_t size = x->size();
|
||||
if (x->onlyNull())
|
||||
{
|
||||
return [](size_t){ return Ternary::Null; };
|
||||
memset(ternary_column_data, Ternary::Null, size);
|
||||
}
|
||||
else if (const auto * nullable_column = typeid_cast<const ColumnNullable *>(x))
|
||||
{
|
||||
if (const auto * nested_column = typeid_cast<const ColumnVector<Type> *>(nullable_column->getNestedColumnPtr().get()))
|
||||
{
|
||||
return [
|
||||
&null_data = nullable_column->getNullMapData(),
|
||||
&column_data = nested_column->getData()](size_t i)
|
||||
const auto& null_data = nullable_column->getNullMapData();
|
||||
const auto& column_data = nested_column->getData();
|
||||
|
||||
if constexpr (sizeof(Type) == 1)
|
||||
{
|
||||
return Ternary::makeValue(column_data[i], null_data[i]);
|
||||
};
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
auto has_value = static_cast<UInt8>(column_data[i] != 0);
|
||||
auto is_null = !!null_data[i];
|
||||
|
||||
ternary_column_data[i] = ((has_value << 1) | is_null) & (1 << !is_null);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
auto has_value = static_cast<UInt8>(column_data[i] != 0);
|
||||
ternary_column_data[i] = has_value;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
auto has_value = ternary_column_data[i];
|
||||
auto is_null = !!null_data[i];
|
||||
|
||||
ternary_column_data[i] = ((has_value << 1) | is_null) & (1 << !is_null);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
return ValueGetterBuilderImpl<Types...>::build(x);
|
||||
TernaryValueBuilderImpl<Types...>::build(x, ternary_column_data);
|
||||
}
|
||||
else if (const auto column = typeid_cast<const ColumnVector<Type> *>(x))
|
||||
return [&column_data = column->getData()](size_t i) { return Ternary::makeValue(column_data[i]); };
|
||||
{
|
||||
auto &column_data = column->getData();
|
||||
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
ternary_column_data[i] = (column_data[i] != 0) << 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
return ValueGetterBuilderImpl<Types...>::build(x);
|
||||
TernaryValueBuilderImpl<Types...>::build(x, ternary_column_data);
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct ValueGetterBuilderImpl<>
|
||||
struct TernaryValueBuilderImpl<>
|
||||
{
|
||||
static TernaryValueGetter build(const IColumn * x)
|
||||
[[noreturn]] static void build(const IColumn * x, UInt8 * /* nullable_ternary_column_data */)
|
||||
{
|
||||
throw Exception(
|
||||
std::string("Unknown numeric column of type: ") + demangle(typeid(*x).name()),
|
||||
@ -240,12 +271,12 @@ struct ValueGetterBuilderImpl<>
|
||||
}
|
||||
};
|
||||
|
||||
using ValueGetterBuilder =
|
||||
ValueGetterBuilderImpl<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
|
||||
using TernaryValueBuilder =
|
||||
TernaryValueBuilderImpl<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
|
||||
|
||||
/// This class together with helper class ValueGetterBuilder can be used with columns of arbitrary data type
|
||||
/// Allows for on-the-fly conversion of any type of data into intermediate ternary representation
|
||||
/// and eliminates the need to materialize data columns in intermediate representation
|
||||
/// This class together with helper class TernaryValueBuilder can be used with columns of arbitrary data type
|
||||
/// Converts column of any data type into an intermediate UInt8Column of ternary representation for the
|
||||
/// vectorized ternary logic evaluation.
|
||||
template <typename Op, size_t N>
|
||||
class AssociativeGenericApplierImpl
|
||||
{
|
||||
@ -254,20 +285,19 @@ class AssociativeGenericApplierImpl
|
||||
public:
|
||||
/// Remembers the last N columns from `in`.
|
||||
explicit AssociativeGenericApplierImpl(const ColumnRawPtrs & in)
|
||||
: val_getter{ValueGetterBuilder::build(in[in.size() - N])}, next{in} {}
|
||||
: vec(in[in.size() - N]->size()), next{in}
|
||||
{
|
||||
TernaryValueBuilder::build(in[in.size() - N], vec.data());
|
||||
}
|
||||
|
||||
/// Returns a combination of values in the i-th row of all columns stored in the constructor.
|
||||
inline ResultValueType apply(const size_t i) const
|
||||
{
|
||||
const auto a = val_getter(i);
|
||||
if constexpr (Op::isSaturable())
|
||||
return Op::isSaturatedValueTernary(a) ? a : Op::apply(a, next.apply(i));
|
||||
else
|
||||
return Op::apply(a, next.apply(i));
|
||||
return Op::ternaryApply(vec[i], next.apply(i));
|
||||
}
|
||||
|
||||
private:
|
||||
const TernaryValueGetter val_getter;
|
||||
UInt8Container vec;
|
||||
const AssociativeGenericApplierImpl<Op, N - 1> next;
|
||||
};
|
||||
|
||||
@ -280,12 +310,15 @@ class AssociativeGenericApplierImpl<Op, 1>
|
||||
public:
|
||||
/// Remembers the last N columns from `in`.
|
||||
explicit AssociativeGenericApplierImpl(const ColumnRawPtrs & in)
|
||||
: val_getter{ValueGetterBuilder::build(in[in.size() - 1])} {}
|
||||
: vec(UInt8Container(in[in.size() - 1]->size()))
|
||||
{
|
||||
TernaryValueBuilder::build(in[in.size() - 1], vec.data());
|
||||
}
|
||||
|
||||
inline ResultValueType apply(const size_t i) const { return val_getter(i); }
|
||||
inline ResultValueType apply(const size_t i) const { return vec[i]; }
|
||||
|
||||
private:
|
||||
const TernaryValueGetter val_getter;
|
||||
UInt8Container vec;
|
||||
};
|
||||
|
||||
|
||||
@ -318,7 +351,12 @@ struct OperationApplier
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
if constexpr (CarryResult)
|
||||
result_data[i] = Op::apply(result_data[i], operation_applier_impl.apply(i));
|
||||
{
|
||||
if constexpr (std::is_same_v<OperationApplierImpl<Op, N>, AssociativeApplierImpl<Op, N>>)
|
||||
result_data[i] = Op::apply(result_data[i], operation_applier_impl.apply(i));
|
||||
else
|
||||
result_data[i] = Op::ternaryApply(result_data[i], operation_applier_impl.apply(i));
|
||||
}
|
||||
else
|
||||
result_data[i] = operation_applier_impl.apply(i);
|
||||
}
|
||||
|
||||
@ -44,21 +44,29 @@ namespace Ternary
|
||||
{
|
||||
using ResultType = UInt8;
|
||||
|
||||
/** These carefully picked values magically work so bitwise "and", "or" on them
|
||||
* corresponds to the expected results in three-valued logic.
|
||||
/** These values are carefully picked so that they could be efficiently evaluated with bitwise operations, which
|
||||
* are feasible for auto-vectorization by the compiler. The expression for the ternary value evaluation writes:
|
||||
*
|
||||
* False and True are represented by all-0 and all-1 bits, so all bitwise operations on them work as expected.
|
||||
* Null is represented as single 1 bit. So, it is something in between False and True.
|
||||
* And "or" works like maximum and "and" works like minimum:
|
||||
* "or" keeps True as is and lifts False with Null to Null.
|
||||
* "and" keeps False as is and downs True with Null to Null.
|
||||
* ternary_value = ((value << 1) | is_null) & (1 << !is_null)
|
||||
*
|
||||
* The truth table of the above formula lists:
|
||||
* +---------------+--------------+-------------+
|
||||
* | is_null\value | 0 | 1 |
|
||||
* +---------------+--------------+-------------+
|
||||
* | 0 | 0b00 (False) | 0b10 (True) |
|
||||
* | 1 | 0b01 (Null) | 0b01 (Null) |
|
||||
* +---------------+--------------+-------------+
|
||||
*
|
||||
* As the numerical values of False, Null and True are assigned in ascending order, the "and" and "or" of
|
||||
* ternary logic could be implemented with minimum and maximum respectively, which are also vectorizable.
|
||||
* https://en.wikipedia.org/wiki/Three-valued_logic
|
||||
*
|
||||
* This logic does not apply for "not" and "xor" - they work with default implementation for NULLs:
|
||||
* anything with NULL returns NULL, otherwise use conventional two-valued logic.
|
||||
*/
|
||||
static constexpr UInt8 False = 0; /// All zero bits.
|
||||
static constexpr UInt8 True = -1; /// All one bits.
|
||||
static constexpr UInt8 Null = 1; /// Single one bit.
|
||||
static constexpr UInt8 False = 0; /// 0b00
|
||||
static constexpr UInt8 Null = 1; /// 0b01
|
||||
static constexpr UInt8 True = 2; /// 0b10
|
||||
|
||||
template <typename T>
|
||||
inline ResultType makeValue(T value)
|
||||
@ -90,6 +98,8 @@ struct AndImpl
|
||||
|
||||
static inline constexpr ResultType apply(UInt8 a, UInt8 b) { return a & b; }
|
||||
|
||||
static inline constexpr ResultType ternaryApply(UInt8 a, UInt8 b) { return std::min(a, b); }
|
||||
|
||||
/// Will use three-valued logic for NULLs (see above) or default implementation (any operation with NULL returns NULL).
|
||||
static inline constexpr bool specialImplementationForNulls() { return true; }
|
||||
};
|
||||
@ -102,6 +112,7 @@ struct OrImpl
|
||||
static inline constexpr bool isSaturatedValue(bool a) { return a; }
|
||||
static inline constexpr bool isSaturatedValueTernary(UInt8 a) { return a == Ternary::True; }
|
||||
static inline constexpr ResultType apply(UInt8 a, UInt8 b) { return a | b; }
|
||||
static inline constexpr ResultType ternaryApply(UInt8 a, UInt8 b) { return std::max(a, b); }
|
||||
static inline constexpr bool specialImplementationForNulls() { return true; }
|
||||
};
|
||||
|
||||
@ -113,6 +124,7 @@ struct XorImpl
|
||||
static inline constexpr bool isSaturatedValue(bool) { return false; }
|
||||
static inline constexpr bool isSaturatedValueTernary(UInt8) { return false; }
|
||||
static inline constexpr ResultType apply(UInt8 a, UInt8 b) { return a != b; }
|
||||
static inline constexpr ResultType ternaryApply(UInt8 a, UInt8 b) { return a != b; }
|
||||
static inline constexpr bool specialImplementationForNulls() { return false; }
|
||||
|
||||
#if USE_EMBEDDED_COMPILER
|
||||
|
||||
354
src/Functions/tests/gtest_ternary_logic.cpp
Normal file
354
src/Functions/tests/gtest_ternary_logic.cpp
Normal file
@ -0,0 +1,354 @@
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
#include <gtest/gtest.h>
|
||||
#include <Columns/ColumnNothing.h>
|
||||
#include <Columns/ColumnsNumber.h>
|
||||
#include <Functions/FunctionsLogical.h>
|
||||
|
||||
// I know that inclusion of .cpp is not good at all
|
||||
#include <Functions/FunctionsLogical.cpp> // NOLINT
|
||||
|
||||
using namespace DB;
|
||||
using TernaryValues = std::vector<Ternary::ResultType>;
|
||||
|
||||
struct LinearCongruentialGenerator
|
||||
{
|
||||
/// Constants from `man lrand48_r`.
|
||||
static constexpr UInt64 a = 0x5DEECE66D;
|
||||
static constexpr UInt64 c = 0xB;
|
||||
|
||||
/// And this is from `head -c8 /dev/urandom | xxd -p`
|
||||
UInt64 current = 0x09826f4a081cee35ULL;
|
||||
|
||||
UInt32 next()
|
||||
{
|
||||
current = current * a + c;
|
||||
return static_cast<UInt32>(current >> 16);
|
||||
}
|
||||
};
|
||||
|
||||
void generateRandomTernaryValue(LinearCongruentialGenerator & gen, Ternary::ResultType * output, size_t size, double false_ratio, double null_ratio)
|
||||
{
|
||||
/// The LinearCongruentialGenerator generates nonnegative integers uniformly distributed over the interval [0, 2^32).
|
||||
/// See https://linux.die.net/man/3/nrand48
|
||||
|
||||
double false_percentile = false_ratio;
|
||||
double null_percentile = false_ratio + null_ratio;
|
||||
|
||||
false_percentile = false_percentile > 1 ? 1 : false_percentile;
|
||||
null_percentile = null_percentile > 1 ? 1 : null_percentile;
|
||||
|
||||
UInt32 false_threshold = static_cast<UInt32>(static_cast<double>(std::numeric_limits<UInt32>::max()) * false_percentile);
|
||||
UInt32 null_threshold = static_cast<UInt32>(static_cast<double>(std::numeric_limits<UInt32>::max()) * null_percentile);
|
||||
|
||||
for (Ternary::ResultType * end = output + size; output != end; ++output)
|
||||
{
|
||||
UInt32 val = gen.next();
|
||||
*output = val < false_threshold ? Ternary::False : (val < null_threshold ? Ternary::Null : Ternary::True);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
ColumnPtr createColumnNullable(const Ternary::ResultType * ternary_values, size_t size)
|
||||
{
|
||||
auto nested_column = ColumnVector<T>::create(size);
|
||||
auto null_map = ColumnUInt8::create(size);
|
||||
auto & nested_column_data = nested_column->getData();
|
||||
auto & null_map_data = null_map->getData();
|
||||
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
if (ternary_values[i] == Ternary::Null)
|
||||
{
|
||||
null_map_data[i] = 1;
|
||||
nested_column_data[i] = 0;
|
||||
}
|
||||
else if (ternary_values[i] == Ternary::True)
|
||||
{
|
||||
null_map_data[i] = 0;
|
||||
nested_column_data[i] = 100;
|
||||
}
|
||||
else
|
||||
{
|
||||
null_map_data[i] = 0;
|
||||
nested_column_data[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
return ColumnNullable::create(std::move(nested_column), std::move(null_map));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
ColumnPtr createColumnVector(const Ternary::ResultType * ternary_values, size_t size)
|
||||
{
|
||||
auto column = ColumnVector<T>::create(size);
|
||||
auto & column_data = column->getData();
|
||||
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
if (ternary_values[i] == Ternary::True)
|
||||
{
|
||||
column_data[i] = 100;
|
||||
}
|
||||
else
|
||||
{
|
||||
column_data[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
return column;
|
||||
}
|
||||
|
||||
template<typename ColumnType, typename T>
|
||||
ColumnPtr createRandomColumn(LinearCongruentialGenerator & gen, TernaryValues & ternary_values)
|
||||
{
|
||||
size_t size = ternary_values.size();
|
||||
Ternary::ResultType * ternary_data = ternary_values.data();
|
||||
|
||||
if constexpr (std::is_same_v<ColumnType, ColumnNullable>)
|
||||
{
|
||||
generateRandomTernaryValue(gen, ternary_data, size, 0.3, 0.7);
|
||||
return createColumnNullable<T>(ternary_data, size);
|
||||
}
|
||||
else if constexpr (std::is_same_v<ColumnType, ColumnVector<UInt8>>)
|
||||
{
|
||||
generateRandomTernaryValue(gen, ternary_data, size, 0.5, 0);
|
||||
return createColumnVector<T>(ternary_data, size);
|
||||
}
|
||||
else
|
||||
{
|
||||
auto nested_col = ColumnNothing::create(size);
|
||||
auto null_map = ColumnUInt8::create(size);
|
||||
|
||||
memset(ternary_data, Ternary::Null, size);
|
||||
|
||||
return ColumnNullable::create(std::move(nested_col), std::move(null_map));
|
||||
}
|
||||
}
|
||||
|
||||
/* The truth table of ternary And and Or operations:
|
||||
* +-------+-------+---------+--------+
|
||||
* | a | b | a And b | a Or b |
|
||||
* +-------+-------+---------+--------+
|
||||
* | False | False | False | False |
|
||||
* | False | Null | False | Null |
|
||||
* | False | True | False | True |
|
||||
* | Null | False | False | Null |
|
||||
* | Null | Null | Null | Null |
|
||||
* | Null | True | Null | True |
|
||||
* | True | False | False | True |
|
||||
* | True | Null | Null | True |
|
||||
* | True | True | True | True |
|
||||
* +-------+-------+---------+--------+
|
||||
*
|
||||
* https://en.wikibooks.org/wiki/Structured_Query_Language/NULLs_and_the_Three_Valued_Logic
|
||||
*/
|
||||
template <typename Op, typename T>
|
||||
bool testTernaryLogicTruthTable()
|
||||
{
|
||||
constexpr size_t size = 9;
|
||||
|
||||
Ternary::ResultType col_a_ternary[] = {Ternary::False, Ternary::False, Ternary::False, Ternary::Null, Ternary::Null, Ternary::Null, Ternary::True, Ternary::True, Ternary::True};
|
||||
Ternary::ResultType col_b_ternary[] = {Ternary::False, Ternary::Null, Ternary::True, Ternary::False, Ternary::Null, Ternary::True,Ternary::False, Ternary::Null, Ternary::True};
|
||||
Ternary::ResultType and_expected_ternary[] = {Ternary::False, Ternary::False, Ternary::False, Ternary::False, Ternary::Null, Ternary::Null,Ternary::False, Ternary::Null, Ternary::True};
|
||||
Ternary::ResultType or_expected_ternary[] = {Ternary::False, Ternary::Null, Ternary::True, Ternary::Null, Ternary::Null, Ternary::True,Ternary::True, Ternary::True, Ternary::True};
|
||||
Ternary::ResultType * expected_ternary;
|
||||
|
||||
|
||||
if constexpr (std::is_same_v<Op, AndImpl>)
|
||||
{
|
||||
expected_ternary = and_expected_ternary;
|
||||
}
|
||||
else
|
||||
{
|
||||
expected_ternary = or_expected_ternary;
|
||||
}
|
||||
|
||||
auto col_a = createColumnNullable<T>(col_a_ternary, size);
|
||||
auto col_b = createColumnNullable<T>(col_b_ternary, size);
|
||||
ColumnRawPtrs arguments = {col_a.get(), col_b.get()};
|
||||
|
||||
auto col_res = ColumnUInt8::create(size);
|
||||
auto & col_res_data = col_res->getData();
|
||||
|
||||
OperationApplier<Op, AssociativeGenericApplierImpl>::apply(arguments, col_res->getData(), false);
|
||||
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
if (col_res_data[i] != expected_ternary[i]) return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Op, typename LeftColumn, typename RightColumn>
|
||||
bool testTernaryLogicOfTwoColumns(size_t size)
|
||||
{
|
||||
LinearCongruentialGenerator gen;
|
||||
|
||||
TernaryValues left_column_ternary(size);
|
||||
TernaryValues right_column_ternary(size);
|
||||
TernaryValues expected_ternary(size);
|
||||
|
||||
ColumnPtr left = createRandomColumn<LeftColumn, UInt8>(gen, left_column_ternary);
|
||||
ColumnPtr right = createRandomColumn<RightColumn, UInt8>(gen, right_column_ternary);
|
||||
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
/// Given that False is less than Null and Null is less than True, the And operation can be implemented
|
||||
/// with std::min, and the Or operation can be implemented with std::max.
|
||||
if constexpr (std::is_same_v<Op, AndImpl>)
|
||||
{
|
||||
expected_ternary[i] = std::min(left_column_ternary[i], right_column_ternary[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
expected_ternary[i] = std::max(left_column_ternary[i], right_column_ternary[i]);
|
||||
}
|
||||
}
|
||||
|
||||
ColumnRawPtrs arguments = {left.get(), right.get()};
|
||||
|
||||
auto col_res = ColumnUInt8::create(size);
|
||||
auto & col_res_data = col_res->getData();
|
||||
|
||||
OperationApplier<Op, AssociativeGenericApplierImpl>::apply(arguments, col_res->getData(), false);
|
||||
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
if (col_res_data[i] != expected_ternary[i]) return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedUInt8)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, UInt8>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, UInt8>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedUInt16)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, UInt16>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, UInt16>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedUInt32)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, UInt32>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, UInt32>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedUInt64)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, UInt64>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, UInt64>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedInt8)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, Int8>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, Int8>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedInt16)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, Int16>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, Int16>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedInt32)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, Int32>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, Int32>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedInt64)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, Int64>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, Int64>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedFloat32)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, Float32>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, Float32>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTruthTable, NestedFloat64)
|
||||
{
|
||||
bool test_1 = testTernaryLogicTruthTable<AndImpl, Float64>();
|
||||
bool test_2 = testTernaryLogicTruthTable<OrImpl, Float64>();
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTwoColumns, TwoNullable)
|
||||
{
|
||||
bool test_1 = testTernaryLogicOfTwoColumns<AndImpl, ColumnNullable, ColumnNullable>(100 /*size*/);
|
||||
bool test_2 = testTernaryLogicOfTwoColumns<OrImpl, ColumnNullable, ColumnNullable>(100 /*size*/);
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTwoColumns, TwoVector)
|
||||
{
|
||||
bool test_1 = testTernaryLogicOfTwoColumns<AndImpl, ColumnUInt8, ColumnUInt8>(100 /*size*/);
|
||||
bool test_2 = testTernaryLogicOfTwoColumns<OrImpl, ColumnUInt8, ColumnUInt8>(100 /*size*/);
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTwoColumns, TwoNothing)
|
||||
{
|
||||
bool test_1 = testTernaryLogicOfTwoColumns<AndImpl, ColumnNothing, ColumnNothing>(100 /*size*/);
|
||||
bool test_2 = testTernaryLogicOfTwoColumns<OrImpl, ColumnNothing, ColumnNothing>(100 /*size*/);
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTwoColumns, NullableVector)
|
||||
{
|
||||
bool test_1 = testTernaryLogicOfTwoColumns<AndImpl, ColumnNullable, ColumnUInt8>(100 /*size*/);
|
||||
bool test_2 = testTernaryLogicOfTwoColumns<OrImpl, ColumnNullable, ColumnUInt8>(100 /*size*/);
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTwoColumns, NullableNothing)
|
||||
{
|
||||
bool test_1 = testTernaryLogicOfTwoColumns<AndImpl, ColumnNullable, ColumnNothing>(100 /*size*/);
|
||||
bool test_2 = testTernaryLogicOfTwoColumns<OrImpl, ColumnNullable, ColumnNothing>(100 /*size*/);
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
|
||||
TEST(TernaryLogicTwoColumns, VectorNothing)
|
||||
{
|
||||
bool test_1 = testTernaryLogicOfTwoColumns<AndImpl, ColumnUInt8, ColumnNothing>(100 /*size*/);
|
||||
bool test_2 = testTernaryLogicOfTwoColumns<OrImpl, ColumnUInt8, ColumnNothing>(100 /*size*/);
|
||||
ASSERT_EQ(test_1, true);
|
||||
ASSERT_EQ(test_2, true);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user