* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <immintrin.h>
#include <Columns/IColumn.h>
#include <DataTypes/IDataType.h>
#include <base/Decimal.h>
#include <base/extended_types.h>
#include <benchmark/benchmark.h>
#include <Common/PODArray.h>
#include <Common/TargetSpecific.h>
using namespace DB;
template <typename T>
struct MyAdd
{
static void NO_SANITIZE_UNDEFINED ALWAYS_INLINE add(T & lhs, const T & rhs) { lhs += rhs; }
};
template <typename DecimalNativeType>
struct MyAdd<Decimal<DecimalNativeType>>
{
static void NO_SANITIZE_UNDEFINED ALWAYS_INLINE add(Decimal<DecimalNativeType> & lhs, const Decimal<DecimalNativeType> & rhs)
{
lhs.addOverflow(rhs);
}
};
template <typename T>
struct MySumData
{
using Impl = MyAdd<T>;
T sum{};
MULTITARGET_FUNCTION_AVX512BW_AVX512F_AVX2_SSE42(
MULTITARGET_FUNCTION_HEADER(template <typename Value, bool add_if_zero> void NO_SANITIZE_UNDEFINED NO_INLINE),
addManyConditionalInternalImpl,
MULTITARGET_FUNCTION_BODY((
const Value * __restrict ptr, const UInt8 * __restrict condition_map, size_t start, size_t end)
{
ptr += start;
condition_map += start;
size_t count = end - start;
const auto * end_ptr = ptr + count;
if constexpr (
(is_integer<T> && !is_big_int_v<T>)
|| (is_decimal<T> && !std::is_same_v<T, Decimal256> && !std::is_same_v<T, Decimal128>))
{
T local_sum{};
while (ptr < end_ptr)
{
T multiplier = !*condition_map == add_if_zero;
Impl::add(local_sum, *ptr * multiplier);
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
return;
}
if constexpr (std::is_floating_point_v<T>)
{
static_assert(sizeof(Value) == 4 || sizeof(Value) == 8);
using equivalent_integer = typename std::conditional_t<sizeof(Value) == 4, UInt32, UInt64>;
constexpr size_t unroll_count = 128 / sizeof(T);
T partial_sums[unroll_count]{};
const auto * unrolled_end = ptr + (count / unroll_count * unroll_count);
while (ptr < unrolled_end)
{
for (size_t i = 0; i < unroll_count; ++i)
{
equivalent_integer value;
std::memcpy(&value, &ptr[i], sizeof(Value));
value &= (!condition_map[i] != add_if_zero) - 1;
Value d;
std::memcpy(&d, &value, sizeof(Value));
Impl::add(partial_sums[i], d);
}
ptr += unroll_count;
condition_map += unroll_count;
}
for (size_t i = 0; i < unroll_count; ++i)
Impl::add(sum, partial_sums[i]);
}
T local_sum{};
while (ptr < end_ptr)
{
if (!*condition_map == add_if_zero)
Impl::add(local_sum, *ptr);
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
}))
template <typename Value, bool add_if_zero>
void NO_INLINE
addManyConditionalInternal(const Value * __restrict ptr, const UInt8 * __restrict condition_map, size_t start, size_t end)
{
#if USE_MULTITARGET_CODE
if (isArchSupported(TargetArch::AVX512BW))
{
addManyConditionalInternalImplAVX512BW<Value, add_if_zero>(ptr, condition_map, start, end);
return;
}
if (isArchSupported(TargetArch::AVX512F))
{
addManyConditionalInternalImplAVX512F<Value, add_if_zero>(ptr, condition_map, start, end);
return;
}
if (isArchSupported(TargetArch::AVX2))
{
addManyConditionalInternalImplAVX2<Value, add_if_zero>(ptr, condition_map, start, end);
return;
}
if (isArchSupported(TargetArch::SSE42))
{
addManyConditionalInternalImplSSE42<Value, add_if_zero>(ptr, condition_map, start, end);
return;
}
#endif
addManyConditionalInternalImpl<Value, add_if_zero>(ptr, condition_map, start, end);
}
MULTITARGET_FUNCTION_AVX512BW_AVX512F_AVX2_SSE42(
MULTITARGET_FUNCTION_HEADER(template <typename Value, bool add_if_zero> void NO_SANITIZE_UNDEFINED NO_INLINE),
addManyConditionalInternalImplNew,
MULTITARGET_FUNCTION_BODY((
const Value * __restrict ptr, const UInt8 * __restrict condition_map, size_t start, size_t end)
{
ptr += start;
condition_map += start;
size_t count = end - start;
const auto * end_ptr = ptr + count;
if constexpr ((is_integer<T> || is_decimal<T>)&&!is_over_big_int<T>)
{
T local_sum{};
while (ptr < end_ptr)
{
T multiplier = !*condition_map == add_if_zero;
Impl::add(local_sum, *ptr * multiplier);
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
return;
}
else if constexpr (is_integer<T>)
{
T local_sum{};
using MaskType = std::conditional_t<sizeof(T) == 16, Int8, Int8>;
alignas(64) const MaskType masks[2] = {0, -1};
while (ptr < end_ptr)
{
Value v = *ptr;
if constexpr (!add_if_zero)
v &= masks[!!*condition_map];
else
v &= masks[!*condition_map];
Impl::add(local_sum, v);
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
return;
}
else if constexpr (is_decimal<T>)
{
T local_sum{};
using MaskType = std::conditional_t<sizeof(T) == 16, Int8, Int8>;
alignas(64) const MaskType masks[2] = {0, -1};
while (ptr < end_ptr)
{
Value v = *ptr;
if constexpr (!add_if_zero)
v.value &= masks[!!*condition_map];
else
v.value &= masks[!*condition_map];
Impl::add(local_sum, v);
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
return;
}
else if constexpr (std::is_floating_point_v<T>)
{
static_assert(sizeof(Value) == 4 || sizeof(Value) == 8);
using equivalent_integer = typename std::conditional_t<sizeof(Value) == 4, UInt32, UInt64>;
constexpr size_t unroll_count = 128 / sizeof(T);
T partial_sums[unroll_count]{};
const auto * unrolled_end = ptr + (count / unroll_count * unroll_count);
while (ptr < unrolled_end)
{
for (size_t i = 0; i < unroll_count; ++i)
{
equivalent_integer value;
std::memcpy(&value, &ptr[i], sizeof(Value));
value &= (!condition_map[i] != add_if_zero) - 1;
Value d;
std::memcpy(&d, &value, sizeof(Value));
Impl::add(partial_sums[i], d);
}
ptr += unroll_count;
condition_map += unroll_count;
}
for (size_t i = 0; i < unroll_count; ++i)
Impl::add(sum, partial_sums[i]);
}
T local_sum{};
while (ptr < end_ptr)
{
Impl::add(local_sum, !*condition_map == add_if_zero ? *ptr : T{});
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
}))
template <typename Value, bool add_if_zero>
void NO_INLINE
addManyConditionalInternalNew(const Value * __restrict ptr, const UInt8 * __restrict condition_map, size_t start, size_t end)
{
#if USE_MULTITARGET_CODE
if (isArchSupported(TargetArch::AVX512BW))
{
addManyConditionalInternalImplNewAVX512BW<Value, add_if_zero>(ptr, condition_map, start, end);
return;
}
if (isArchSupported(TargetArch::AVX512F))
{
addManyConditionalInternalImplNewAVX512F<Value, add_if_zero>(ptr, condition_map, start, end);
return;
}
if (isArchSupported(TargetArch::AVX2))
{
addManyConditionalInternalImplNewAVX2<Value, add_if_zero>(ptr, condition_map, start, end);
return;
}
if (isArchSupported(TargetArch::SSE42))
{
addManyConditionalInternalImplNewSSE42<Value, add_if_zero>(ptr, condition_map, start, end);
return;
}
#endif
addManyConditionalInternalImplNew<Value, add_if_zero>(ptr, condition_map, start, end);
}
template <typename Value, bool add_if_zero>
void NO_SANITIZE_UNDEFINED NO_INLINE addManyConditionalInternalImplSIMD(
const Value * __restrict ptr, const UInt8 * __restrict condition_map, size_t start, size_t end) /// NOLINT
{
ptr += start;
condition_map += start;
size_t count = end - start;
const auto * end_ptr = ptr + count;
if constexpr ((is_integer<T> || is_decimal<T>)&&!is_over_big_int<T>)
{
/// For integers we can vectorize the operation if we replace the null check using a multiplication (by 0 for null, 1 for not null)
/// https://quick-bench.com/q/MLTnfTvwC2qZFVeWHfOBR3U7a8I
T local_sum{};
while (ptr < end_ptr)
{
T multiplier = !*condition_map == add_if_zero;
Impl::add(local_sum, *ptr * multiplier);
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
return;
}
else if constexpr (is_integer<T>)
{
T local_sum{};
using MaskType = std::conditional_t<sizeof(T) == 16, Int8, Int64>;
alignas(64) const MaskType masks[2] = {0, -1};
while (ptr < end_ptr)
{
T value = *ptr;
if constexpr (sizeof(T) == 16)
{
__m128i v = _mm_loadu_si128((__m128i *)&value);
__m128i c = _mm_set1_epi8(!*condition_map == add_if_zero);
__m128i r = _mm_and_si128(v, c);
_mm_storeu_si128((__m128i *)&value, r);
}
else
{
__m256i v = _mm256_loadu_si256((__m256i *)&value);
__m256i c = _mm256_set1_epi8(!*condition_map == add_if_zero);
__m256i r = _mm256_and_si256(v, c);
_mm256_storeu_si256((__m256i *)&value, r);
}
Impl::add(local_sum, value);
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
return;
}
else if constexpr (is_decimal<T>)
{
T local_sum{};
using MaskType = std::conditional_t<sizeof(T) == 16, Int8, Int64>;
alignas(64) const MaskType masks[2] = {0, -1};
while (ptr < end_ptr)
{
Value v = *ptr;
if constexpr (!add_if_zero)
v.value &= masks[*condition_map];
else
v.value &= masks[!*condition_map];
Impl::add(local_sum, v);
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
return;
}
else if constexpr (std::is_floating_point_v<T>)
{
/// For floating point we use a similar trick as above, except that now we reinterpret the floating point number as an unsigned
/// integer of the same size and use a mask instead (0 to discard, 0xFF..FF to keep)
static_assert(sizeof(Value) == 4 || sizeof(Value) == 8);
using equivalent_integer = typename std::conditional_t<sizeof(Value) == 4, UInt32, UInt64>;
constexpr size_t unroll_count = 128 / sizeof(T);
T partial_sums[unroll_count]{};
const auto * unrolled_end = ptr + (count / unroll_count * unroll_count);
while (ptr < unrolled_end)
{
for (size_t i = 0; i < unroll_count; ++i)
{
equivalent_integer value;
std::memcpy(&value, &ptr[i], sizeof(Value));
value &= (!condition_map[i] != add_if_zero) - 1;
Value d;
std::memcpy(&d, &value, sizeof(Value));
Impl::add(partial_sums[i], d);
}
ptr += unroll_count;
condition_map += unroll_count;
}
for (size_t i = 0; i < unroll_count; ++i)
Impl::add(sum, partial_sums[i]);
}
T local_sum{};
while (ptr < end_ptr)
{
Impl::add(local_sum, !*condition_map == add_if_zero ? *ptr : T{});
++ptr;
++condition_map;
}
Impl::add(sum, local_sum);
}
template <typename Value, bool add_if_zero>
void NO_INLINE
addManyConditionalInternalSIMD(const Value * __restrict ptr, const UInt8 * __restrict condition_map, size_t start, size_t end)
{
addManyConditionalInternalImplSIMD<Value, add_if_zero>(ptr, condition_map, start, end);
}
*/
};
static constexpr size_t ROWS = 65536;
static void initCondition(PaddedPODArray<UInt8> & cond)
{
cond.resize(ROWS);
for (size_t i = 0; i < ROWS; ++i)
cond[i] = std::rand() % 2;
}
template <typename T>
static void initColumn(PaddedPODArray<T> & data)
{
data.resize(ROWS);
for (size_t i = 0; i < ROWS; ++i)
data[i] = static_cast<T>(std::rand());
}
template <typename T>
static void BM_SumWithCondition(benchmark::State & state)
{
PaddedPODArray<T> data;
initColumn(data);
PaddedPODArray<UInt8> cond;
initCondition(cond);
for (auto _ : state)
{
MySumData<T> sum_data;
sum_data.template addManyConditionalInternal<T, false>(data.data(), cond.data(), 0, ROWS);
benchmark::DoNotOptimize(sum_data);
}
}
template <typename T>
static void BM_SumWithConditionNew(benchmark::State & state)
{
PaddedPODArray<T> data;
initColumn(data);
PaddedPODArray<UInt8> cond;
initCondition(cond);
for (auto _ : state)
{
MySumData<T> sum_data;
sum_data.template addManyConditionalInternalNew<T, false>(data.data(), cond.data(), 0, ROWS);
benchmark::DoNotOptimize(sum_data);
}
}
template <typename T>
static void BM_SumWithConditionSIMD(benchmark::State & state)
{
PaddedPODArray<T> data;
initColumn(data);
PaddedPODArray<UInt8> cond;
initCondition(cond);
for (auto _ : state)
{
MySumData<T> sum_data;
sum_data.template addManyConditionalInternalSIMD<T, false>(data.data(), cond.data(), 0, ROWS);
benchmark::DoNotOptimize(sum_data);
}
}
*/
BENCHMARK_TEMPLATE(BM_SumWithCondition, Int64);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, Int64);
BENCHMARK_TEMPLATE(BM_SumWithCondition, UInt64);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, UInt64);
BENCHMARK_TEMPLATE(BM_SumWithCondition, Float64);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, Float64);
BENCHMARK_TEMPLATE(BM_SumWithCondition, Int128);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, Int128);
BENCHMARK_TEMPLATE(BM_SumWithCondition, UInt128);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, UInt128);
BENCHMARK_TEMPLATE(BM_SumWithCondition, Int256);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, Int256);
BENCHMARK_TEMPLATE(BM_SumWithCondition, UInt256);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, UInt256);
BENCHMARK_TEMPLATE(BM_SumWithCondition, Decimal32);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, Decimal32);
BENCHMARK_TEMPLATE(BM_SumWithCondition, Decimal64);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, Decimal64);
BENCHMARK_TEMPLATE(BM_SumWithCondition, Decimal128);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, Decimal128);
BENCHMARK_TEMPLATE(BM_SumWithCondition, Decimal256);
BENCHMARK_TEMPLATE(BM_SumWithConditionNew, Decimal256);
Run on (32 X 2100 MHz CPU s)
CPU Caches:
L1 Data 32 KiB (x16)
L1 Instruction 32 KiB (x16)
L2 Unified 1024 KiB (x16)
L3 Unified 11264 KiB (x2)
Load Average: 7.56, 5.47, 5.16
-----------------------------------------------------------------------------
Benchmark Time CPU Iterations
-----------------------------------------------------------------------------
BM_SumWithCondition<Int64> 8930 ns 8929 ns 77846
BM_SumWithConditionNew<Int64> 8768 ns 8767 ns 80325
BM_SumWithCondition<UInt64> 8816 ns 8816 ns 80369
BM_SumWithConditionNew<UInt64> 8725 ns 8724 ns 80186
BM_SumWithCondition<Float64> 10229 ns 10228 ns 68275
BM_SumWithConditionNew<Float64> 10213 ns 10212 ns 68308
BM_SumWithCondition<Int128> 444262 ns 444247 ns 1575
BM_SumWithConditionNew<Int128> 87837 ns 87834 ns 7991
BM_SumWithCondition<UInt128> 433537 ns 433518 ns 1615
BM_SumWithConditionNew<UInt128> 88010 ns 88008 ns 7955
BM_SumWithCondition<Int256> 659032 ns 658995 ns 1048
BM_SumWithConditionNew<Int256> 189202 ns 189195 ns 3713
BM_SumWithCondition<UInt256> 479715 ns 479695 ns 1457
BM_SumWithConditionNew<UInt256> 198451 ns 198447 ns 3696
BM_SumWithCondition<Decimal32> 4662 ns 4662 ns 150015
BM_SumWithConditionNew<Decimal32> 4670 ns 4669 ns 149746
BM_SumWithCondition<Decimal64> 8742 ns 8742 ns 80315
BM_SumWithConditionNew<Decimal64> 8943 ns 8943 ns 76422
BM_SumWithCondition<Decimal128> 445999 ns 445990 ns 1550
BM_SumWithConditionNew<Decimal128> 88954 ns 88952 ns 8002
BM_SumWithCondition<Decimal256> 515128 ns 515111 ns 1371
BM_SumWithConditionNew<Decimal256> 223425 ns 223420 ns 3184
*/
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbit-int-extension"
using NewInt128 = signed _BitInt(128);
using NewUInt128 = unsigned _BitInt(128);
using NewInt256 = signed _BitInt(256);
using NewUInt256 = unsigned _BitInt(256);
#pragma clang diagnostic pop
using OldInt128 = Int128;
using OldUInt128 = UInt128;
using OldInt256 = Int256;
using OldUInt256 = UInt256;
template <typename T>
static T generateRandomValue()
{
T value;
for (size_t i = 0; i < sizeof(T); ++i)
{
reinterpret_cast<uint8_t *>(&value)[i] = static_cast<uint8_t>(std::rand() % 256);
}
return value;
}
template <typename T>
static void BM_Addition(benchmark::State & state)
{
T a = generateRandomValue<T>();
T b = generateRandomValue<T>();
for (auto _ : state)
{
T result = a + b;
benchmark::DoNotOptimize(&result);
}
}
template <typename T>
static void BM_Subtraction(benchmark::State & state)
{
T a = generateRandomValue<T>();
T b = generateRandomValue<T>();
for (auto _ : state)
{
T result = a - b;
benchmark::DoNotOptimize(&result);
}
}
template <typename T>
static void BM_Multiplication(benchmark::State & state)
{
T a = generateRandomValue<T>();
T b = generateRandomValue<T>();
for (auto _ : state)
{
T result = a * b;
benchmark::DoNotOptimize(&result);
}
}
template <typename T>
static void BM_Division(benchmark::State & state)
{
T a = generateRandomValue<T>();
T b = generateRandomValue<T>() + 1;
for (auto _ : state)
{
T result = a / b;
benchmark::DoNotOptimize(&result);
}
}
BENCHMARK_TEMPLATE(BM_Addition, OldInt128);
BENCHMARK_TEMPLATE(BM_Subtraction, OldInt128);
BENCHMARK_TEMPLATE(BM_Multiplication, OldInt128);
BENCHMARK_TEMPLATE(BM_Division, OldInt128);
BENCHMARK_TEMPLATE(BM_Addition, NewInt128);
BENCHMARK_TEMPLATE(BM_Subtraction, NewInt128);
BENCHMARK_TEMPLATE(BM_Multiplication, NewInt128);
BENCHMARK_TEMPLATE(BM_Division, NewInt128);
BENCHMARK_TEMPLATE(BM_Addition, OldUInt128);
BENCHMARK_TEMPLATE(BM_Subtraction, OldUInt128);
BENCHMARK_TEMPLATE(BM_Multiplication, OldUInt128);
BENCHMARK_TEMPLATE(BM_Division, OldUInt128);
BENCHMARK_TEMPLATE(BM_Addition, NewUInt128);
BENCHMARK_TEMPLATE(BM_Subtraction, NewUInt128);
BENCHMARK_TEMPLATE(BM_Multiplication, NewUInt128);
BENCHMARK_TEMPLATE(BM_Division, NewUInt128);
BENCHMARK_TEMPLATE(BM_Addition, OldInt256);
BENCHMARK_TEMPLATE(BM_Subtraction, OldInt256);
BENCHMARK_TEMPLATE(BM_Multiplication, OldInt256);
BENCHMARK_TEMPLATE(BM_Division, OldInt256);
BENCHMARK_TEMPLATE(BM_Addition, NewInt256);
BENCHMARK_TEMPLATE(BM_Subtraction, NewInt256);
BENCHMARK_TEMPLATE(BM_Multiplication, NewInt256);
BENCHMARK_TEMPLATE(BM_Division, NewInt256);
BENCHMARK_TEMPLATE(BM_Addition, OldUInt256);
BENCHMARK_TEMPLATE(BM_Subtraction, OldUInt256);
BENCHMARK_TEMPLATE(BM_Multiplication, OldUInt256);
BENCHMARK_TEMPLATE(BM_Division, OldUInt256);
BENCHMARK_TEMPLATE(BM_Addition, NewUInt256);
BENCHMARK_TEMPLATE(BM_Subtraction, NewUInt256);
BENCHMARK_TEMPLATE(BM_Multiplication, NewUInt256);
BENCHMARK_TEMPLATE(BM_Division, NewUInt256);
Running ./build_gcc/utils/extern-local-engine/tests/benchmark_local_engine
Run on (32 X 2100 MHz CPU s)
CPU Caches:
L1 Data 32 KiB (x16)
L1 Instruction 32 KiB (x16)
L2 Unified 1024 KiB (x16)
L3 Unified 11264 KiB (x2)
Load Average: 4.79, 5.12, 5.49
./build_gcc/utils/extern-local-engine/tests/benchmark_local_engine --benchmark_filter="(Addition|Subtraction|Multiplication|Division)<New.*>"
------------------------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------------------------
BM_Addition<NewInt128> 1.43 ns 1.43 ns 488198747
BM_Subtraction<NewInt128> 1.51 ns 1.51 ns 486720421
BM_Multiplication<NewInt128> 1.52 ns 1.52 ns 450071487
BM_Division<NewInt128> 1.48 ns 1.48 ns 471973890
BM_Addition<NewUInt128> 1.46 ns 1.46 ns 480687874
BM_Subtraction<NewUInt128> 1.46 ns 1.46 ns 488204076
BM_Multiplication<NewUInt128> 1.45 ns 1.45 ns 468576127
BM_Division<NewUInt128> 1.48 ns 1.48 ns 477379447
BM_Addition<NewInt256> 2.49 ns 2.48 ns 291377319
BM_Subtraction<NewInt256> 2.52 ns 2.52 ns 284595240
BM_Multiplication<NewInt256> 2.48 ns 2.48 ns 276363723
BM_Division<NewInt256> 2.44 ns 2.44 ns 286877215
BM_Addition<NewUInt256> 2.53 ns 2.53 ns 266497385
BM_Subtraction<NewUInt256> 2.48 ns 2.48 ns 287899525
BM_Multiplication<NewUInt256> 2.45 ns 2.45 ns 287882140
BM_Division<NewUInt256> 2.47 ns 2.47 ns 288479037
*/
./build_gcc/utils/extern-local-engine/tests/benchmark_local_engine --benchmark_filter="(Addition|Subtraction|Multiplication|Division)<Old.*>"
------------------------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------------------------
BM_Addition<OldInt128> 1.45 ns 1.45 ns 484711423
BM_Subtraction<OldInt128> 1.45 ns 1.45 ns 475188736
BM_Multiplication<OldInt128> 1.47 ns 1.47 ns 483199322
BM_Division<OldInt128> 1.49 ns 1.49 ns 488830649
BM_Addition<OldUInt128> 1.45 ns 1.45 ns 487019006
BM_Subtraction<OldUInt128> 1.45 ns 1.45 ns 477626299
BM_Multiplication<OldUInt128> 1.47 ns 1.47 ns 475294481
BM_Division<OldUInt128> 1.48 ns 1.48 ns 461236815
BM_Addition<OldInt256> 4.39 ns 4.39 ns 159221253
BM_Subtraction<OldInt256> 5.01 ns 5.01 ns 100000000
BM_Multiplication<OldInt256> 11.3 ns 11.3 ns 54204439
BM_Division<OldInt256> 48.5 ns 48.5 ns 18505649
BM_Addition<OldUInt256> 4.37 ns 4.37 ns 180812154
BM_Subtraction<OldUInt256> 5.41 ns 5.41 ns 133516077
BM_Multiplication<OldUInt256> 2.47 ns 2.47 ns 286377591
BM_Division<OldUInt256> 21.8 ns 21.8 ns 25876643
*/
