122 lines
3.9 KiB
C++
122 lines
3.9 KiB
C++
// Copyright 2019 Google LLC
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
// Licensed 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 <stdint.h>
|
|
|
|
#undef HWY_TARGET_INCLUDE
|
|
#define HWY_TARGET_INCLUDE "tests/truncate_test.cc"
|
|
#include "hwy/foreach_target.h" // IWYU pragma: keep
|
|
#include "hwy/highway.h"
|
|
#include "hwy/tests/test_util-inl.h"
|
|
|
|
HWY_BEFORE_NAMESPACE();
|
|
namespace hwy {
|
|
namespace HWY_NAMESPACE {
|
|
|
|
template <typename From, typename To, class D>
|
|
constexpr bool IsSupportedTruncation() {
|
|
return (sizeof(To) < sizeof(From) && Rebind<To, D>().Pow2() >= -3 &&
|
|
Rebind<To, D>().Pow2() + 4 >= static_cast<int>(CeilLog2(sizeof(To))));
|
|
}
|
|
|
|
struct TestTruncateTo {
|
|
template <typename From, typename To, class D,
|
|
hwy::EnableIf<!IsSupportedTruncation<From, To, D>()>* = nullptr>
|
|
HWY_NOINLINE void testTo(From, To, const D) {
|
|
// do nothing
|
|
}
|
|
|
|
template <typename From, typename To, class D,
|
|
hwy::EnableIf<IsSupportedTruncation<From, To, D>()>* = nullptr>
|
|
HWY_NOINLINE void testTo(From, To, const D d) {
|
|
constexpr uint32_t base = 0xFA578D00;
|
|
const Rebind<To, D> dTo;
|
|
const Vec<D> src = Iota(d, base & hwy::LimitsMax<From>());
|
|
const Vec<decltype(dTo)> expected = Iota(dTo, base & hwy::LimitsMax<To>());
|
|
const VFromD<decltype(dTo)> actual = TruncateTo(dTo, src);
|
|
HWY_ASSERT_VEC_EQ(dTo, expected, actual);
|
|
}
|
|
|
|
template <typename T, class D>
|
|
HWY_NOINLINE void operator()(T from, const D d) {
|
|
testTo<T, uint8_t, D>(from, uint8_t(), d);
|
|
testTo<T, uint16_t, D>(from, uint16_t(), d);
|
|
testTo<T, uint32_t, D>(from, uint32_t(), d);
|
|
}
|
|
};
|
|
|
|
HWY_NOINLINE void TestAllTruncate() {
|
|
ForU163264(ForDemoteVectors<TestTruncateTo>());
|
|
}
|
|
|
|
struct TestOrderedTruncate2To {
|
|
template <typename T, class D>
|
|
HWY_NOINLINE void operator()(T /*t*/, D d) {
|
|
#if HWY_TARGET != HWY_SCALAR
|
|
const Repartition<MakeNarrow<T>, decltype(d)> dn;
|
|
using TN = TFromD<decltype(dn)>;
|
|
|
|
const size_t N = Lanes(d);
|
|
const size_t twiceN = N * 2;
|
|
auto from = AllocateAligned<T>(twiceN);
|
|
auto expected = AllocateAligned<TN>(twiceN);
|
|
|
|
const T max = LimitsMax<TN>();
|
|
|
|
constexpr uint32_t iota_base = 0xFA578D00;
|
|
const auto src_iota_a = Iota(d, iota_base);
|
|
const auto src_iota_b = Iota(d, iota_base + N);
|
|
const auto expected_iota_trunc_result = Iota(dn, iota_base);
|
|
const auto actual_iota_trunc_result =
|
|
OrderedTruncate2To(dn, src_iota_a, src_iota_b);
|
|
HWY_ASSERT_VEC_EQ(dn, expected_iota_trunc_result, actual_iota_trunc_result);
|
|
|
|
RandomState rng;
|
|
for (size_t rep = 0; rep < AdjustedReps(1000); ++rep) {
|
|
for (size_t i = 0; i < twiceN; ++i) {
|
|
const uint64_t bits = rng();
|
|
CopyBytes<sizeof(T)>(&bits, &from[i]); // not same size
|
|
expected[i] = static_cast<TN>(from[i] & max);
|
|
}
|
|
|
|
const auto in_1 = Load(d, from.get());
|
|
const auto in_2 = Load(d, from.get() + N);
|
|
const auto actual = OrderedTruncate2To(dn, in_1, in_2);
|
|
HWY_ASSERT_VEC_EQ(dn, expected.get(), actual);
|
|
}
|
|
#else
|
|
(void)d;
|
|
#endif
|
|
}
|
|
};
|
|
|
|
HWY_NOINLINE void TestAllOrderedTruncate2To() {
|
|
ForU163264(ForShrinkableVectors<TestOrderedTruncate2To>());
|
|
}
|
|
|
|
// NOLINTNEXTLINE(google-readability-namespace-comments)
|
|
} // namespace HWY_NAMESPACE
|
|
} // namespace hwy
|
|
HWY_AFTER_NAMESPACE();
|
|
|
|
#if HWY_ONCE
|
|
|
|
namespace hwy {
|
|
HWY_BEFORE_TEST(HwyTruncateTest);
|
|
HWY_EXPORT_AND_TEST_P(HwyTruncateTest, TestAllTruncate);
|
|
HWY_EXPORT_AND_TEST_P(HwyTruncateTest, TestAllOrderedTruncate2To);
|
|
} // namespace hwy
|
|
|
|
#endif
|