3548 lines
85 KiB
C++
3548 lines
85 KiB
C++
// SPDX-License-Identifier: Apache-2.0
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright 2020-2022 Arm Limited
|
|
//
|
|
// 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.
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* @brief Unit tests for the vectorized SIMD functionality.
|
|
*/
|
|
|
|
#include <limits>
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "../astcenc_internal.h"
|
|
#include "../astcenc_vecmathlib.h"
|
|
|
|
namespace astcenc
|
|
{
|
|
|
|
// Misc utility tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
static unsigned int round_down(unsigned int x)
|
|
{
|
|
unsigned int remainder = x % ASTCENC_SIMD_WIDTH;
|
|
return x - remainder;
|
|
}
|
|
|
|
static unsigned int round_up(unsigned int x)
|
|
{
|
|
unsigned int remainder = x % ASTCENC_SIMD_WIDTH;
|
|
if (!remainder)
|
|
{
|
|
return x;
|
|
}
|
|
|
|
return x - remainder + ASTCENC_SIMD_WIDTH;
|
|
}
|
|
|
|
/** @brief Test VLA loop limit round down. */
|
|
TEST(misc, RoundDownVLA)
|
|
{
|
|
// Static ones which are valid for all VLA widths
|
|
EXPECT_EQ(round_down_to_simd_multiple_vla(0), 0u);
|
|
EXPECT_EQ(round_down_to_simd_multiple_vla(8), 8u);
|
|
EXPECT_EQ(round_down_to_simd_multiple_vla(16), 16u);
|
|
|
|
// Variable ones which depend on VLA width
|
|
EXPECT_EQ(round_down_to_simd_multiple_vla(3), round_down(3));
|
|
EXPECT_EQ(round_down_to_simd_multiple_vla(5), round_down(5));
|
|
EXPECT_EQ(round_down_to_simd_multiple_vla(7), round_down(7));
|
|
EXPECT_EQ(round_down_to_simd_multiple_vla(231), round_down(231));
|
|
}
|
|
|
|
/** @brief Test VLA loop limit round up. */
|
|
TEST(misc, RoundUpVLA)
|
|
{
|
|
// Static ones which are valid for all VLA widths
|
|
EXPECT_EQ(round_up_to_simd_multiple_vla(0), 0u);
|
|
EXPECT_EQ(round_up_to_simd_multiple_vla(8), 8u);
|
|
EXPECT_EQ(round_up_to_simd_multiple_vla(16), 16u);
|
|
|
|
// Variable ones which depend on VLA width
|
|
EXPECT_EQ(round_up_to_simd_multiple_vla(3), round_up(3));
|
|
EXPECT_EQ(round_up_to_simd_multiple_vla(5), round_up(5));
|
|
EXPECT_EQ(round_up_to_simd_multiple_vla(7), round_up(7));
|
|
EXPECT_EQ(round_up_to_simd_multiple_vla(231), round_up(231));
|
|
}
|
|
|
|
#if ASTCENC_SIMD_WIDTH == 1
|
|
|
|
// VLA (1-wide) tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
/** @brief Test VLA change_sign. */
|
|
TEST(vfloat, ChangeSign)
|
|
{
|
|
vfloat a0(-1.0f);
|
|
vfloat b0(-1.0f);
|
|
vfloat r0 = change_sign(a0, b0);
|
|
EXPECT_EQ(r0.lane<0>(), 1.0f);
|
|
|
|
vfloat a1( 1.0f);
|
|
vfloat b1(-1.0f);
|
|
vfloat r1 = change_sign(a1, b1);
|
|
EXPECT_EQ(r1.lane<0>(), -1.0f);
|
|
|
|
vfloat a2(-3.12f);
|
|
vfloat b2( 3.12f);
|
|
vfloat r2 = change_sign(a2, b2);
|
|
EXPECT_EQ(r2.lane<0>(), -3.12f);
|
|
|
|
vfloat a3( 3.12f);
|
|
vfloat b3( 3.12f);
|
|
vfloat r3 = change_sign(a3, b3);
|
|
EXPECT_EQ(r3.lane<0>(), 3.12f);
|
|
}
|
|
|
|
/** @brief Test VLA atan. */
|
|
TEST(vfloat, Atan)
|
|
{
|
|
vfloat a0(-0.15f);
|
|
vfloat r0 = atan(a0);
|
|
EXPECT_NEAR(r0.lane<0>(), -0.149061f, 0.005f);
|
|
|
|
vfloat a1(0.0f);
|
|
vfloat r1 = atan(a1);
|
|
EXPECT_NEAR(r1.lane<0>(), 0.000000f, 0.005f);
|
|
|
|
vfloat a2(0.9f);
|
|
vfloat r2 = atan(a2);
|
|
EXPECT_NEAR(r2.lane<0>(), 0.733616f, 0.005f);
|
|
|
|
vfloat a3(2.1f);
|
|
vfloat r3 = atan(a3);
|
|
EXPECT_NEAR(r3.lane<0>(), 1.123040f, 0.005f);
|
|
}
|
|
|
|
/** @brief Test VLA atan2. */
|
|
TEST(vfloat, Atan2)
|
|
{
|
|
vfloat a0(-0.15f);
|
|
vfloat b0( 1.15f);
|
|
vfloat r0 = atan2(a0, b0);
|
|
EXPECT_NEAR(r0.lane<0>(), -0.129816f, 0.005f);
|
|
|
|
vfloat a1( 0.0f);
|
|
vfloat b1(-3.0f);
|
|
vfloat r1 = atan2(a1, b1);
|
|
EXPECT_NEAR(r1.lane<0>(), 3.141592f, 0.005f);
|
|
|
|
vfloat a2( 0.9f);
|
|
vfloat b2(-0.9f);
|
|
vfloat r2 = atan2(a2, b2);
|
|
EXPECT_NEAR(r2.lane<0>(), 2.360342f, 0.005f);
|
|
|
|
vfloat a3( 2.1f);
|
|
vfloat b3( 1.1f);
|
|
vfloat r3 = atan2(a3, b3);
|
|
EXPECT_NEAR(r3.lane<0>(), 1.084357f, 0.005f);
|
|
}
|
|
|
|
#elif ASTCENC_SIMD_WIDTH == 4
|
|
|
|
// VLA (4-wide) tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
/** @brief Test VLA change_sign. */
|
|
TEST(vfloat, ChangeSign)
|
|
{
|
|
vfloat a(-1.0f, 1.0f, -3.12f, 3.12f);
|
|
vfloat b(-1.0f, -1.0f, 3.12f, 3.12f);
|
|
vfloat r = change_sign(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), -1.0f);
|
|
EXPECT_EQ(r.lane<2>(), -3.12f);
|
|
EXPECT_EQ(r.lane<3>(), 3.12f);
|
|
}
|
|
|
|
/** @brief Test VLA atan. */
|
|
TEST(vfloat, Atan)
|
|
{
|
|
vfloat a(-0.15f, 0.0f, 0.9f, 2.1f);
|
|
vfloat r = atan(a);
|
|
EXPECT_NEAR(r.lane<0>(), -0.149061f, 0.005f);
|
|
EXPECT_NEAR(r.lane<1>(), 0.000000f, 0.005f);
|
|
EXPECT_NEAR(r.lane<2>(), 0.733616f, 0.005f);
|
|
EXPECT_NEAR(r.lane<3>(), 1.123040f, 0.005f);
|
|
}
|
|
|
|
/** @brief Test VLA atan2. */
|
|
TEST(vfloat, Atan2)
|
|
{
|
|
vfloat a(-0.15f, 0.0f, 0.9f, 2.1f);
|
|
vfloat b(1.15f, -3.0f, -0.9f, 1.1f);
|
|
vfloat r = atan2(a, b);
|
|
EXPECT_NEAR(r.lane<0>(), -0.129816f, 0.005f);
|
|
EXPECT_NEAR(r.lane<1>(), 3.141592f, 0.005f);
|
|
EXPECT_NEAR(r.lane<2>(), 2.360342f, 0.005f);
|
|
EXPECT_NEAR(r.lane<3>(), 1.084357f, 0.005f);
|
|
}
|
|
|
|
#elif ASTCENC_SIMD_WIDTH == 8
|
|
|
|
// VLA (8-wide) tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
/** @brief Test VLA change_sign. */
|
|
TEST(vfloat, ChangeSign)
|
|
{
|
|
vfloat a(-1.0f, 1.0f, -3.12f, 3.12f, -1.0f, 1.0f, -3.12f, 3.12f);
|
|
vfloat b(-1.0f, -1.0f, 3.12f, 3.12f, -1.0f, -1.0f, 3.12f, 3.12f);
|
|
vfloat r = change_sign(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), -1.0f);
|
|
EXPECT_EQ(r.lane<2>(), -3.12f);
|
|
EXPECT_EQ(r.lane<3>(), 3.12f);
|
|
EXPECT_EQ(r.lane<4>(), 1.0f);
|
|
EXPECT_EQ(r.lane<5>(), -1.0f);
|
|
EXPECT_EQ(r.lane<6>(), -3.12f);
|
|
EXPECT_EQ(r.lane<7>(), 3.12f);
|
|
}
|
|
|
|
/** @brief Test VLA atan. */
|
|
TEST(vfloat, Atan)
|
|
{
|
|
vfloat a(-0.15f, 0.0f, 0.9f, 2.1f, -0.15f, 0.0f, 0.9f, 2.1f);
|
|
vfloat r = atan(a);
|
|
EXPECT_NEAR(r.lane<0>(), -0.149061f, 0.005f);
|
|
EXPECT_NEAR(r.lane<1>(), 0.000000f, 0.005f);
|
|
EXPECT_NEAR(r.lane<2>(), 0.733616f, 0.005f);
|
|
EXPECT_NEAR(r.lane<3>(), 1.123040f, 0.005f);
|
|
EXPECT_NEAR(r.lane<4>(), -0.149061f, 0.005f);
|
|
EXPECT_NEAR(r.lane<5>(), 0.000000f, 0.005f);
|
|
EXPECT_NEAR(r.lane<6>(), 0.733616f, 0.005f);
|
|
EXPECT_NEAR(r.lane<7>(), 1.123040f, 0.005f);
|
|
}
|
|
|
|
/** @brief Test VLA atan2. */
|
|
TEST(vfloat, Atan2)
|
|
{
|
|
vfloat a(-0.15f, 0.0f, 0.9f, 2.1f, -0.15f, 0.0f, 0.9f, 2.1f);
|
|
vfloat b(1.15f, -3.0f, -0.9f, 1.1f, 1.15f, -3.0f, -0.9f, 1.1f);
|
|
vfloat r = atan2(a, b);
|
|
EXPECT_NEAR(r.lane<0>(), -0.129816f, 0.005f);
|
|
EXPECT_NEAR(r.lane<1>(), 3.141592f, 0.005f);
|
|
EXPECT_NEAR(r.lane<2>(), 2.360342f, 0.005f);
|
|
EXPECT_NEAR(r.lane<3>(), 1.084357f, 0.005f);
|
|
EXPECT_NEAR(r.lane<4>(), -0.129816f, 0.005f);
|
|
EXPECT_NEAR(r.lane<5>(), 3.141592f, 0.005f);
|
|
EXPECT_NEAR(r.lane<6>(), 2.360342f, 0.005f);
|
|
EXPECT_NEAR(r.lane<7>(), 1.084357f, 0.005f);
|
|
}
|
|
|
|
#endif
|
|
|
|
static const float qnan = std::numeric_limits<float>::quiet_NaN();
|
|
|
|
alignas(32) static const float f32_data[9] {
|
|
0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f
|
|
};
|
|
|
|
alignas(32) static const int s32_data[9] {
|
|
0, 1, 2, 3, 4, 5 , 6, 7, 8
|
|
};
|
|
|
|
alignas(32) static const uint8_t u8_data[9] {
|
|
0, 1, 2, 3, 4, 5 , 6, 7, 8
|
|
};
|
|
|
|
// VFLOAT4 tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
/** @brief Test unaligned vfloat4 data load. */
|
|
TEST(vfloat4, UnalignedLoad)
|
|
{
|
|
vfloat4 a(&(f32_data[1]));
|
|
EXPECT_EQ(a.lane<0>(), 1.0f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test scalar duplicated vfloat4 load. */
|
|
TEST(vfloat4, ScalarDupLoad)
|
|
{
|
|
vfloat4 a(1.1f);
|
|
EXPECT_EQ(a.lane<0>(), 1.1f);
|
|
EXPECT_EQ(a.lane<1>(), 1.1f);
|
|
EXPECT_EQ(a.lane<2>(), 1.1f);
|
|
EXPECT_EQ(a.lane<3>(), 1.1f);
|
|
}
|
|
|
|
/** @brief Test scalar vfloat4 load. */
|
|
TEST(vfloat4, ScalarLoad)
|
|
{
|
|
vfloat4 a(1.1f, 2.2f, 3.3f, 4.4f);
|
|
EXPECT_EQ(a.lane<0>(), 1.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.4f);
|
|
}
|
|
|
|
/** @brief Test copy vfloat4 load. */
|
|
TEST(vfloat4, CopyLoad)
|
|
{
|
|
vfloat4 s(1.1f, 2.2f, 3.3f, 4.4f);
|
|
vfloat4 a(s.m);
|
|
EXPECT_EQ(a.lane<0>(), 1.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.4f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 scalar lane set. */
|
|
TEST(vfloat4, SetLane)
|
|
{
|
|
vfloat4 a(0.0f);
|
|
|
|
a.set_lane<0>(1.0f);
|
|
EXPECT_EQ(a.lane<0>(), 1.0f);
|
|
EXPECT_EQ(a.lane<1>(), 0.0f);
|
|
EXPECT_EQ(a.lane<2>(), 0.0f);
|
|
EXPECT_EQ(a.lane<3>(), 0.0f);
|
|
|
|
a.set_lane<1>(2.0f);
|
|
EXPECT_EQ(a.lane<0>(), 1.0f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f);
|
|
EXPECT_EQ(a.lane<2>(), 0.0f);
|
|
EXPECT_EQ(a.lane<3>(), 0.0f);
|
|
|
|
a.set_lane<2>(3.0f);
|
|
EXPECT_EQ(a.lane<0>(), 1.0f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f);
|
|
EXPECT_EQ(a.lane<3>(), 0.0f);
|
|
|
|
a.set_lane<3>(4.0f);
|
|
EXPECT_EQ(a.lane<0>(), 1.0f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 zero. */
|
|
TEST(vfloat4, Zero)
|
|
{
|
|
vfloat4 a = vfloat4::zero();
|
|
EXPECT_EQ(a.lane<0>(), 0.0f);
|
|
EXPECT_EQ(a.lane<1>(), 0.0f);
|
|
EXPECT_EQ(a.lane<2>(), 0.0f);
|
|
EXPECT_EQ(a.lane<3>(), 0.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 load1. */
|
|
TEST(vfloat4, Load1)
|
|
{
|
|
float s = 3.14f;
|
|
vfloat4 a = vfloat4::load1(&s);
|
|
EXPECT_EQ(a.lane<0>(), 3.14f);
|
|
EXPECT_EQ(a.lane<1>(), 3.14f);
|
|
EXPECT_EQ(a.lane<2>(), 3.14f);
|
|
EXPECT_EQ(a.lane<3>(), 3.14f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 loada. */
|
|
TEST(vfloat4, Loada)
|
|
{
|
|
vfloat4 a = vfloat4::loada(&(f32_data[0]));
|
|
EXPECT_EQ(a.lane<0>(), 0.0f);
|
|
EXPECT_EQ(a.lane<1>(), 1.0f);
|
|
EXPECT_EQ(a.lane<2>(), 2.0f);
|
|
EXPECT_EQ(a.lane<3>(), 3.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 lane_id. */
|
|
TEST(vfloat4, LaneID)
|
|
{
|
|
vfloat4 a = vfloat4::lane_id();
|
|
EXPECT_EQ(a.lane<0>(), 0.0f);
|
|
EXPECT_EQ(a.lane<1>(), 1.0f);
|
|
EXPECT_EQ(a.lane<2>(), 2.0f);
|
|
EXPECT_EQ(a.lane<3>(), 3.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 swz to float4. */
|
|
TEST(vfloat4, swz4)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 r = a.swz<0, 3, 2, 1>();
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 4.0f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 2.0f);
|
|
|
|
r = a.swz<3, 1, 1, 0>();
|
|
EXPECT_EQ(r.lane<0>(), 4.0f);
|
|
EXPECT_EQ(r.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r.lane<2>(), 2.0f);
|
|
EXPECT_EQ(r.lane<3>(), 1.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 swz to float3. */
|
|
TEST(vfloat4, swz3)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 r = a.swz<0, 3, 2>();
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 4.0f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 0.0f);
|
|
|
|
r = a.swz<3, 1, 1>();
|
|
EXPECT_EQ(r.lane<0>(), 4.0f);
|
|
EXPECT_EQ(r.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r.lane<2>(), 2.0f);
|
|
EXPECT_EQ(r.lane<3>(), 0.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 swz to float2. */
|
|
TEST(vfloat4, swz2)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 r = a.swz<0, 3>();
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 4.0f);
|
|
|
|
r = a.swz<2, 1>();
|
|
EXPECT_EQ(r.lane<0>(), 3.0f);
|
|
EXPECT_EQ(r.lane<1>(), 2.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 add. */
|
|
TEST(vfloat4, vadd)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);
|
|
a = a + b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f + 0.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f + 0.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f + 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f + 0.4f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 self-add. */
|
|
TEST(vfloat4, vselfadd1)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);
|
|
|
|
// Test increment by another variable
|
|
a += b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f + 0.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f + 0.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f + 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f + 0.4f);
|
|
|
|
// Test increment by an expression
|
|
a += b + b;
|
|
EXPECT_NEAR(a.lane<0>(), 1.0f + 0.3f, 0.001f);
|
|
EXPECT_NEAR(a.lane<1>(), 2.0f + 0.6f, 0.001f);
|
|
EXPECT_NEAR(a.lane<2>(), 3.0f + 0.9f, 0.001f);
|
|
EXPECT_NEAR(a.lane<3>(), 4.0f + 1.2f, 0.001f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 sub. */
|
|
TEST(vfloat4, vsub)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);
|
|
a = a - b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f - 0.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f - 0.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f - 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f - 0.4f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 mul. */
|
|
TEST(vfloat4, vmul)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);
|
|
a = a * b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f * 0.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f * 0.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f * 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f * 0.4f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 mul. */
|
|
TEST(vfloat4, vsmul)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
float b = 3.14f;
|
|
a = a * b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f * 3.14f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 mul. */
|
|
TEST(vfloat4, svmul)
|
|
{
|
|
float a = 3.14f;
|
|
vfloat4 b(1.0f, 2.0f, 3.0f, 4.0f);
|
|
b = a * b;
|
|
EXPECT_EQ(b.lane<0>(), 3.14f * 1.0f);
|
|
EXPECT_EQ(b.lane<1>(), 3.14f * 2.0f);
|
|
EXPECT_EQ(b.lane<2>(), 3.14f * 3.0f);
|
|
EXPECT_EQ(b.lane<3>(), 3.14f * 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 div. */
|
|
TEST(vfloat4, vdiv)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);
|
|
a = a / b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f / 0.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f / 0.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f / 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f / 0.4f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 div. */
|
|
TEST(vfloat4, vsdiv)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
float b = 0.3f;
|
|
a = a / b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f / 0.3f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f / 0.3f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f / 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f / 0.3f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 div. */
|
|
TEST(vfloat4, svdiv)
|
|
{
|
|
float a = 3.0f;
|
|
vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);
|
|
b = a / b;
|
|
EXPECT_EQ(b.lane<0>(), 3.0f / 0.1f);
|
|
EXPECT_EQ(b.lane<1>(), 3.0f / 0.2f);
|
|
EXPECT_EQ(b.lane<2>(), 3.0f / 0.3f);
|
|
EXPECT_EQ(b.lane<3>(), 3.0f / 0.4f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 ceq. */
|
|
TEST(vfloat4, ceq)
|
|
{
|
|
vfloat4 a1(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b1(0.1f, 0.2f, 0.3f, 0.4f);
|
|
vmask4 r1 = a1 == b1;
|
|
EXPECT_EQ(0u, mask(r1));
|
|
EXPECT_EQ(false, any(r1));
|
|
EXPECT_EQ(false, all(r1));
|
|
|
|
vfloat4 a2(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b2(1.0f, 0.2f, 0.3f, 0.4f);
|
|
vmask4 r2 = a2 == b2;
|
|
EXPECT_EQ(0x1u, mask(r2));
|
|
EXPECT_EQ(true, any(r2));
|
|
EXPECT_EQ(false, all(r2));
|
|
|
|
vfloat4 a3(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b3(1.0f, 0.2f, 3.0f, 0.4f);
|
|
vmask4 r3 = a3 == b3;
|
|
EXPECT_EQ(0x5u, mask(r3));
|
|
EXPECT_EQ(true, any(r3));
|
|
EXPECT_EQ(false, all(r3));
|
|
|
|
vfloat4 a4(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vmask4 r4 = a4 == a4;
|
|
EXPECT_EQ(0xFu, mask(r4));
|
|
EXPECT_EQ(true, any(r4));
|
|
EXPECT_EQ(true, all(r4));
|
|
}
|
|
|
|
/** @brief Test vfloat4 cne. */
|
|
TEST(vfloat4, cne)
|
|
{
|
|
vfloat4 a1(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b1(0.1f, 0.2f, 0.3f, 0.4f);
|
|
vmask4 r1 = a1 != b1;
|
|
EXPECT_EQ(0xFu, mask(r1));
|
|
EXPECT_EQ(true, any(r1));
|
|
EXPECT_EQ(true, all(r1));
|
|
|
|
vfloat4 a2(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b2(1.0f, 0.2f, 0.3f, 0.4f);
|
|
vmask4 r2 = a2 != b2;
|
|
EXPECT_EQ(0xEu, mask(r2));
|
|
EXPECT_EQ(true, any(r2));
|
|
EXPECT_EQ(false, all(r2));
|
|
|
|
vfloat4 a3(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b3(1.0f, 0.2f, 3.0f, 0.4f);
|
|
vmask4 r3 = a3 != b3;
|
|
EXPECT_EQ(0xAu, mask(r3));
|
|
EXPECT_EQ(true, any(r3));
|
|
EXPECT_EQ(false, all(r3));
|
|
|
|
vfloat4 a4(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vmask4 r4 = a4 != a4;
|
|
EXPECT_EQ(0u, mask(r4));
|
|
EXPECT_EQ(false, any(r4));
|
|
EXPECT_EQ(false, all(r4));
|
|
}
|
|
|
|
/** @brief Test vfloat4 clt. */
|
|
TEST(vfloat4, clt)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);
|
|
vmask4 r = a < b;
|
|
EXPECT_EQ(0xAu, mask(r));
|
|
}
|
|
|
|
/** @brief Test vfloat4 cle. */
|
|
TEST(vfloat4, cle)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);
|
|
vmask4 r = a <= b;
|
|
EXPECT_EQ(0xEu, mask(r));
|
|
}
|
|
|
|
/** @brief Test vfloat4 cgt. */
|
|
TEST(vfloat4, cgt)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);
|
|
vmask4 r = a > b;
|
|
EXPECT_EQ(0x1u, mask(r));
|
|
}
|
|
|
|
/** @brief Test vfloat4 cge. */
|
|
TEST(vfloat4, cge)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);
|
|
vmask4 r = a >= b;
|
|
EXPECT_EQ(0x5u, mask(r));
|
|
}
|
|
|
|
/** @brief Test vfloat4 min. */
|
|
TEST(vfloat4, min)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);
|
|
vfloat4 r = min(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 0.9f);
|
|
EXPECT_EQ(r.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 4.0f);
|
|
|
|
float c = 0.3f;
|
|
r = min(a, c);
|
|
EXPECT_EQ(r.lane<0>(), 0.3f);
|
|
EXPECT_EQ(r.lane<1>(), 0.3f);
|
|
EXPECT_EQ(r.lane<2>(), 0.3f);
|
|
EXPECT_EQ(r.lane<3>(), 0.3f);
|
|
|
|
float d = 1.5f;
|
|
r = min(a, d);
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 1.5f);
|
|
EXPECT_EQ(r.lane<2>(), 1.5f);
|
|
EXPECT_EQ(r.lane<3>(), 1.5f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 max. */
|
|
TEST(vfloat4, max)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);
|
|
vfloat4 r = max(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 2.1f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 4.1f);
|
|
|
|
float c = 4.3f;
|
|
r = max(a, c);
|
|
EXPECT_EQ(r.lane<0>(), 4.3f);
|
|
EXPECT_EQ(r.lane<1>(), 4.3f);
|
|
EXPECT_EQ(r.lane<2>(), 4.3f);
|
|
EXPECT_EQ(r.lane<3>(), 4.3f);
|
|
|
|
float d = 1.5f;
|
|
r = max(a, d);
|
|
EXPECT_EQ(r.lane<0>(), 1.5f);
|
|
EXPECT_EQ(r.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 clamp. */
|
|
TEST(vfloat4, clamp)
|
|
{
|
|
vfloat4 a1(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 r1 = clamp(2.1f, 3.0f, a1);
|
|
EXPECT_EQ(r1.lane<0>(), 2.1f);
|
|
EXPECT_EQ(r1.lane<1>(), 2.1f);
|
|
EXPECT_EQ(r1.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 3.0f);
|
|
|
|
vfloat4 a2(1.0f, 2.0f, qnan, 4.0f);
|
|
vfloat4 r2 = clamp(2.1f, 3.0f, a2);
|
|
EXPECT_EQ(r2.lane<0>(), 2.1f);
|
|
EXPECT_EQ(r2.lane<1>(), 2.1f);
|
|
EXPECT_EQ(r2.lane<2>(), 2.1f);
|
|
EXPECT_EQ(r2.lane<3>(), 3.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 clampz. */
|
|
TEST(vfloat4, clampz)
|
|
{
|
|
vfloat4 a1(-1.0f, 0.0f, 0.1f, 4.0f);
|
|
vfloat4 r1 = clampz(3.0f, a1);
|
|
EXPECT_EQ(r1.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 0.1f);
|
|
EXPECT_EQ(r1.lane<3>(), 3.0f);
|
|
|
|
vfloat4 a2(-1.0f, 0.0f, qnan, 4.0f);
|
|
vfloat4 r2 = clampz(3.0f, a2);
|
|
EXPECT_EQ(r2.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<2>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<3>(), 3.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 clampz. */
|
|
TEST(vfloat4, clampzo)
|
|
{
|
|
vfloat4 a1(-1.0f, 0.0f, 0.1f, 4.0f);
|
|
vfloat4 r1 = clampzo(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 0.1f);
|
|
EXPECT_EQ(r1.lane<3>(), 1.0f);
|
|
|
|
vfloat4 a2(-1.0f, 0.0f, qnan, 4.0f);
|
|
vfloat4 r2 = clampzo(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<2>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<3>(), 1.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 abs. */
|
|
TEST(vfloat4, abs)
|
|
{
|
|
vfloat4 a(-1.0f, 0.0f, 0.1f, 4.0f);
|
|
vfloat4 r = abs(a);
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r.lane<2>(), 0.1f);
|
|
EXPECT_EQ(r.lane<3>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 round. */
|
|
TEST(vfloat4, round)
|
|
{
|
|
vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);
|
|
vfloat4 r1 = round(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 2.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 4.0f);
|
|
|
|
vfloat4 a2(-2.5f, -2.5f, -3.5f, -3.5f);
|
|
vfloat4 r2 = round(a2);
|
|
EXPECT_EQ(r2.lane<0>(), -2.0f);
|
|
EXPECT_EQ(r2.lane<2>(), -4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 hmin. */
|
|
TEST(vfloat4, hmin)
|
|
{
|
|
vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);
|
|
vfloat4 r1 = hmin(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<1>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<2>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<3>(), 1.1f);
|
|
|
|
vfloat4 a2(1.1f, 1.5f, 1.6f, 0.2f);
|
|
vfloat4 r2 = hmin(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<1>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<2>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<3>(), 0.2f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 hmin_s. */
|
|
TEST(vfloat4, hmin_s)
|
|
{
|
|
vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);
|
|
float r1 = hmin_s(a1);
|
|
EXPECT_EQ(r1, 1.1f);
|
|
|
|
vfloat4 a2(1.1f, 1.5f, 1.6f, 0.2f);
|
|
float r2 = hmin_s(a2);
|
|
EXPECT_EQ(r2, 0.2f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 hmin_rgb_s. */
|
|
TEST(vfloat4, hmin_rgb_s)
|
|
{
|
|
vfloat4 a1(1.1f, 1.5f, 1.6f, 0.2f);
|
|
float r1 = hmin_rgb_s(a1);
|
|
EXPECT_EQ(r1, 1.1f);
|
|
|
|
vfloat4 a2(1.5f, 0.9f, 1.6f, 1.2f);
|
|
float r2 = hmin_rgb_s(a2);
|
|
EXPECT_EQ(r2, 0.9f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 hmax. */
|
|
TEST(vfloat4, hmax)
|
|
{
|
|
vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);
|
|
vfloat4 r1 = hmax(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 4.0f);
|
|
|
|
vfloat4 a2(1.1f, 1.5f, 1.6f, 0.2f);
|
|
vfloat4 r2 = hmax(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<1>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<2>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<3>(), 1.6f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 hmax_s. */
|
|
TEST(vfloat4, hmax_s)
|
|
{
|
|
vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);
|
|
float r1 = hmax_s(a1);
|
|
EXPECT_EQ(r1, 4.0f);
|
|
|
|
vfloat4 a2(1.1f, 1.5f, 1.6f, 0.2f);
|
|
float r2 = hmax_s(a2);
|
|
EXPECT_EQ(r2, 1.6f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 hadd_s. */
|
|
TEST(vfloat4, hadd_s)
|
|
{
|
|
vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);
|
|
float sum = 1.1f + 1.5f + 1.6f + 4.0f;
|
|
float r = hadd_s(a1);
|
|
EXPECT_NEAR(r, sum, 0.005f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 hadd_rgb_s. */
|
|
TEST(vfloat4, hadd_rgb_s)
|
|
{
|
|
vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);
|
|
float sum = 1.1f + 1.5f + 1.6f;
|
|
float r = hadd_rgb_s(a1);
|
|
EXPECT_NEAR(r, sum, 0.005f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 sqrt. */
|
|
TEST(vfloat4, sqrt)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 r = sqrt(a);
|
|
EXPECT_EQ(r.lane<0>(), std::sqrt(1.0f));
|
|
EXPECT_EQ(r.lane<1>(), std::sqrt(2.0f));
|
|
EXPECT_EQ(r.lane<2>(), std::sqrt(3.0f));
|
|
EXPECT_EQ(r.lane<3>(), std::sqrt(4.0f));
|
|
}
|
|
|
|
/** @brief Test vfloat4 select. */
|
|
TEST(vfloat4, select)
|
|
{
|
|
vfloat4 m1(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vfloat4 m2(1.0f, 2.0f, 1.0f, 2.0f);
|
|
vmask4 cond = m1 == m2;
|
|
|
|
vfloat4 a(1.0f, 3.0f, 3.0f, 1.0f);
|
|
vfloat4 b(4.0f, 2.0f, 2.0f, 4.0f);
|
|
|
|
// Select in one direction
|
|
vfloat4 r1 = select(a, b, cond);
|
|
EXPECT_EQ(r1.lane<0>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 2.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 1.0f);
|
|
|
|
// Select in the other
|
|
vfloat4 r2 = select(b, a, cond);
|
|
EXPECT_EQ(r2.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r2.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r2.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r2.lane<3>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 select MSB only. */
|
|
TEST(vfloat4, select_msb)
|
|
{
|
|
int msb_set = static_cast<int>(0x80000000);
|
|
vint4 msb(msb_set, 0, msb_set, 0);
|
|
vmask4 cond(msb.m);
|
|
|
|
vfloat4 a(1.0f, 3.0f, 3.0f, 1.0f);
|
|
vfloat4 b(4.0f, 2.0f, 2.0f, 4.0f);
|
|
|
|
// Select in one direction
|
|
vfloat4 r1 = select_msb(a, b, cond);
|
|
EXPECT_EQ(r1.lane<0>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 2.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 1.0f);
|
|
|
|
// Select in the other
|
|
vfloat4 r2 = select_msb(b, a, cond);
|
|
EXPECT_EQ(r2.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r2.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r2.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r2.lane<3>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 gatherf. */
|
|
TEST(vfloat4, gatherf)
|
|
{
|
|
vint4 indices(0, 4, 3, 2);
|
|
vfloat4 r = gatherf(f32_data, indices);
|
|
EXPECT_EQ(r.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r.lane<1>(), 4.0f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 2.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 storea. */
|
|
TEST(vfloat4, storea)
|
|
{
|
|
alignas(16) float out[4];
|
|
vfloat4 a(f32_data);
|
|
storea(a, out);
|
|
EXPECT_EQ(out[0], 0.0f);
|
|
EXPECT_EQ(out[1], 1.0f);
|
|
EXPECT_EQ(out[2], 2.0f);
|
|
EXPECT_EQ(out[3], 3.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 store. */
|
|
TEST(vfloat4, store)
|
|
{
|
|
alignas(16) float out[5];
|
|
vfloat4 a(f32_data);
|
|
store(a, &(out[1]));
|
|
EXPECT_EQ(out[1], 0.0f);
|
|
EXPECT_EQ(out[2], 1.0f);
|
|
EXPECT_EQ(out[3], 2.0f);
|
|
EXPECT_EQ(out[4], 3.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 dot. */
|
|
TEST(vfloat4, dot)
|
|
{
|
|
vfloat4 a1(1.0f, 2.0f, 4.0f, 8.0f);
|
|
vfloat4 b1(1.0f, 0.5f, 0.25f, 0.125f);
|
|
vfloat4 r1 = dot(a1, b1);
|
|
EXPECT_EQ(r1.lane<0>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 4.0f);
|
|
|
|
// These values will fail to add to the same value if reassociated
|
|
float l0 = 141.2540435791015625f;
|
|
float l1 = 5345345.5000000000000000f;
|
|
float l2 = 234234.7031250000000000f;
|
|
float l3 = 124353454080.0000000000000000f;
|
|
|
|
vfloat4 a2(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vfloat4 b2(l0, l1, l2, l3);
|
|
vfloat4 r2 = dot(a2, b2);
|
|
|
|
// Test that reassociation causes a failure with the numbers we chose
|
|
EXPECT_FALSE(any(r2 == vfloat4(l0 + l1 + l2 + l3)));
|
|
|
|
// Test that the sum works, for the association pattern we want used
|
|
EXPECT_TRUE(all(r2 == vfloat4((l0 + l2) + (l1 + l3))));
|
|
}
|
|
|
|
/** @brief Test vfloat4 dot_s. */
|
|
TEST(vfloat4, dot_s)
|
|
{
|
|
vfloat4 a1(1.0f, 2.0f, 4.0f, 8.0f);
|
|
vfloat4 b1(1.0f, 0.5f, 0.25f, 0.125f);
|
|
float r1 = dot_s(a1, b1);
|
|
EXPECT_EQ(r1, 4.0f);
|
|
|
|
// These values will fail to add to the same value if reassociated
|
|
float l0 = 141.2540435791015625f;
|
|
float l1 = 5345345.5000000000000000f;
|
|
float l2 = 234234.7031250000000000f;
|
|
float l3 = 124353454080.0000000000000000f;
|
|
|
|
vfloat4 a2(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vfloat4 b2(l0, l1, l2, l3);
|
|
float r2 = dot_s(a2, b2);
|
|
|
|
// Test that reassociation causes a failure with the numbers we chose
|
|
EXPECT_NE(r2, l0 + l1 + l2 + l3);
|
|
|
|
// Test that the sum works, for the association pattern we want used
|
|
EXPECT_EQ(r2, (l0 + l2) + (l1 + l3));
|
|
}
|
|
|
|
/** @brief Test vfloat4 dot3. */
|
|
TEST(vfloat4, dot3)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 4.0f, 8.0f);
|
|
vfloat4 b(1.0f, 0.5f, 0.25f, 0.125f);
|
|
vfloat4 r = dot3(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 3.0f);
|
|
EXPECT_EQ(r.lane<1>(), 3.0f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 0.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 dot3_s. */
|
|
TEST(vfloat4, dot3_s)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 4.0f, 8.0f);
|
|
vfloat4 b(1.0f, 0.5f, 0.25f, 0.125f);
|
|
float r = dot3_s(a, b);
|
|
EXPECT_EQ(r, 3.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 normalize. */
|
|
TEST(vfloat4, normalize)
|
|
{
|
|
vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 r = normalize(a);
|
|
EXPECT_NEAR(r.lane<0>(), 1.0f / astc::sqrt(30.0f), 0.0005f);
|
|
EXPECT_NEAR(r.lane<1>(), 2.0f / astc::sqrt(30.0f), 0.0005f);
|
|
EXPECT_NEAR(r.lane<2>(), 3.0f / astc::sqrt(30.0f), 0.0005f);
|
|
EXPECT_NEAR(r.lane<3>(), 4.0f / astc::sqrt(30.0f), 0.0005f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 normalize_safe. */
|
|
TEST(vfloat4, normalize_safe)
|
|
{
|
|
vfloat4 s(-1.0f, -1.0f, -1.0f, -1.0f);
|
|
|
|
vfloat4 a1(1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat4 r1 = normalize_safe(a1, s);
|
|
EXPECT_NEAR(r1.lane<0>(), 1.0f / astc::sqrt(30.0f), 0.0005f);
|
|
EXPECT_NEAR(r1.lane<1>(), 2.0f / astc::sqrt(30.0f), 0.0005f);
|
|
EXPECT_NEAR(r1.lane<2>(), 3.0f / astc::sqrt(30.0f), 0.0005f);
|
|
EXPECT_NEAR(r1.lane<3>(), 4.0f / astc::sqrt(30.0f), 0.0005f);
|
|
|
|
vfloat4 a2(0.0f, 0.0f, 0.0f, 0.0f);
|
|
vfloat4 r2 = normalize_safe(a2, s);
|
|
EXPECT_EQ(r2.lane<0>(), -1.0f);
|
|
EXPECT_EQ(r2.lane<1>(), -1.0f);
|
|
EXPECT_EQ(r2.lane<2>(), -1.0f);
|
|
EXPECT_EQ(r2.lane<3>(), -1.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 float_to_int. */
|
|
TEST(vfloat4, float_to_int)
|
|
{
|
|
vfloat4 a(1.1f, 1.5f, -1.6f, 4.0f);
|
|
vint4 r = float_to_int(a);
|
|
EXPECT_EQ(r.lane<0>(), 1);
|
|
EXPECT_EQ(r.lane<1>(), 1);
|
|
EXPECT_EQ(r.lane<2>(), -1);
|
|
EXPECT_EQ(r.lane<3>(), 4);
|
|
}
|
|
|
|
/** @brief Test vfloat4 round. */
|
|
TEST(vfloat4, float_to_int_rtn)
|
|
{
|
|
vfloat4 a(1.1f, 1.5f, 1.6f, 4.0f);
|
|
vint4 r = float_to_int_rtn(a);
|
|
EXPECT_EQ(r.lane<0>(), 1);
|
|
EXPECT_EQ(r.lane<1>(), 2);
|
|
EXPECT_EQ(r.lane<2>(), 2);
|
|
EXPECT_EQ(r.lane<3>(), 4);
|
|
}
|
|
|
|
/** @brief Test vfloat4 round. */
|
|
TEST(vfloat4, int_to_float)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vfloat4 r = int_to_float(a);
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat4 float to fp16 conversion. */
|
|
TEST(vfloat4, float_to_float16)
|
|
{
|
|
vfloat4 a(1.5, 234.5, 345345.0, qnan);
|
|
vint4 r = float_to_float16(a);
|
|
|
|
// Normal numbers
|
|
EXPECT_EQ(r.lane<0>(), 0x3E00);
|
|
EXPECT_EQ(r.lane<1>(), 0x5B54);
|
|
|
|
// Large numbers convert to infinity
|
|
EXPECT_EQ(r.lane<2>(), 0x7C00);
|
|
|
|
// NaN must convert to any valid NaN encoding
|
|
EXPECT_EQ((r.lane<3>() >> 10) & 0x1F, 0x1F); // Exponent must be all 1s
|
|
EXPECT_NE(r.lane<3>() & (0x3FF), 0); // Mantissa must be non-zero
|
|
}
|
|
|
|
/** @brief Test float to fp16 conversion. */
|
|
TEST(sfloat, float_to_float16)
|
|
{
|
|
int r = float_to_float16(234.5);
|
|
EXPECT_EQ(r, 0x5B54);
|
|
}
|
|
|
|
/** @brief Test vfloat4 fp16 to float conversion. */
|
|
TEST(vfloat4, float16_to_float)
|
|
{ vint4 a(0x3E00, 0x5B54, 0x7C00, 0xFFFF);
|
|
vfloat4 r = float16_to_float(a);
|
|
|
|
// Normal numbers
|
|
EXPECT_EQ(r.lane<0>(), 1.5);
|
|
EXPECT_EQ(r.lane<1>(), 234.5);
|
|
|
|
// Infinities must be preserved
|
|
EXPECT_NE(std::isinf(r.lane<2>()), 0);
|
|
|
|
// NaNs must be preserved
|
|
EXPECT_NE(std::isnan(r.lane<3>()), 0);
|
|
}
|
|
|
|
/** @brief Test fp16 to float conversion. */
|
|
TEST(sfloat, float16_to_float)
|
|
{
|
|
float r = float16_to_float(0x5B54);
|
|
EXPECT_EQ(r, 234.5);
|
|
}
|
|
|
|
// VINT4 tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
/** @brief Test unaligned vint4 data load. */
|
|
TEST(vint4, UnalignedLoad)
|
|
{
|
|
vint4 a(&(s32_data[1]));
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 3);
|
|
EXPECT_EQ(a.lane<3>(), 4);
|
|
}
|
|
|
|
/** @brief Test unaligned vint4 data load. */
|
|
TEST(vint4, UnalignedLoad8)
|
|
{
|
|
vint4 a(&(u8_data[1]));
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 3);
|
|
EXPECT_EQ(a.lane<3>(), 4);
|
|
}
|
|
|
|
/** @brief Test scalar duplicated vint4 load. */
|
|
TEST(vint4, ScalarDupLoad)
|
|
{
|
|
vint4 a(42);
|
|
EXPECT_EQ(a.lane<0>(), 42);
|
|
EXPECT_EQ(a.lane<1>(), 42);
|
|
EXPECT_EQ(a.lane<2>(), 42);
|
|
EXPECT_EQ(a.lane<3>(), 42);
|
|
}
|
|
|
|
/** @brief Test scalar vint4 load. */
|
|
TEST(vint4, ScalarLoad)
|
|
{
|
|
vint4 a(11, 22, 33, 44);
|
|
EXPECT_EQ(a.lane<0>(), 11);
|
|
EXPECT_EQ(a.lane<1>(), 22);
|
|
EXPECT_EQ(a.lane<2>(), 33);
|
|
EXPECT_EQ(a.lane<3>(), 44);
|
|
}
|
|
|
|
/** @brief Test copy vint4 load. */
|
|
TEST(vint4, CopyLoad)
|
|
{
|
|
vint4 s(11, 22, 33, 44);
|
|
vint4 a(s.m);
|
|
EXPECT_EQ(a.lane<0>(), 11);
|
|
EXPECT_EQ(a.lane<1>(), 22);
|
|
EXPECT_EQ(a.lane<2>(), 33);
|
|
EXPECT_EQ(a.lane<3>(), 44);
|
|
}
|
|
|
|
/** @brief Test vint4 scalar lane set. */
|
|
TEST(int4, SetLane)
|
|
{
|
|
vint4 a(0);
|
|
|
|
a.set_lane<0>(1);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 0);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), 0);
|
|
|
|
a.set_lane<1>(2);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), 0);
|
|
|
|
a.set_lane<2>(3);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 3);
|
|
EXPECT_EQ(a.lane<3>(), 0);
|
|
|
|
a.set_lane<3>(4);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 3);
|
|
EXPECT_EQ(a.lane<3>(), 4);
|
|
}
|
|
|
|
/** @brief Test vint4 zero. */
|
|
TEST(vint4, Zero)
|
|
{
|
|
vint4 a = vint4::zero();
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 0);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), 0);
|
|
}
|
|
|
|
/** @brief Test vint4 load1. */
|
|
TEST(vint4, Load1)
|
|
{
|
|
int s = 42;
|
|
vint4 a = vint4::load1(&s);
|
|
EXPECT_EQ(a.lane<0>(), 42);
|
|
EXPECT_EQ(a.lane<1>(), 42);
|
|
EXPECT_EQ(a.lane<2>(), 42);
|
|
EXPECT_EQ(a.lane<3>(), 42);
|
|
}
|
|
|
|
/** @brief Test vint4 loada. */
|
|
TEST(vint4, Loada)
|
|
{
|
|
vint4 a = vint4::loada(&(s32_data[0]));
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 2);
|
|
EXPECT_EQ(a.lane<3>(), 3);
|
|
}
|
|
|
|
/** @brief Test vint4 lane_id. */
|
|
TEST(vint4, LaneID)
|
|
{
|
|
vint4 a = vint4::lane_id();
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 2);
|
|
EXPECT_EQ(a.lane<3>(), 3);
|
|
}
|
|
|
|
/** @brief Test vint4 add. */
|
|
TEST(vint4, vadd)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 b(2, 3, 4, 5);
|
|
a = a + b;
|
|
EXPECT_EQ(a.lane<0>(), 1 + 2);
|
|
EXPECT_EQ(a.lane<1>(), 2 + 3);
|
|
EXPECT_EQ(a.lane<2>(), 3 + 4);
|
|
EXPECT_EQ(a.lane<3>(), 4 + 5);
|
|
}
|
|
|
|
/** @brief Test vint4 self-add. */
|
|
TEST(vint4, vselfadd)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 b(2, 3, 4, 5);
|
|
a += b;
|
|
|
|
EXPECT_EQ(a.lane<0>(), 1 + 2);
|
|
EXPECT_EQ(a.lane<1>(), 2 + 3);
|
|
EXPECT_EQ(a.lane<2>(), 3 + 4);
|
|
EXPECT_EQ(a.lane<3>(), 4 + 5);
|
|
}
|
|
|
|
/** @brief Test vint4 add. */
|
|
TEST(vint4, vsadd)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
int b = 5;
|
|
a = a + b;
|
|
EXPECT_EQ(a.lane<0>(), 1 + 5);
|
|
EXPECT_EQ(a.lane<1>(), 2 + 5);
|
|
EXPECT_EQ(a.lane<2>(), 3 + 5);
|
|
EXPECT_EQ(a.lane<3>(), 4 + 5);
|
|
}
|
|
|
|
/** @brief Test vint4 sub. */
|
|
TEST(vint4, vsub)
|
|
{
|
|
vint4 a(1, 2, 4, 4);
|
|
vint4 b(2, 3, 3, 5);
|
|
a = a - b;
|
|
EXPECT_EQ(a.lane<0>(), 1 - 2);
|
|
EXPECT_EQ(a.lane<1>(), 2 - 3);
|
|
EXPECT_EQ(a.lane<2>(), 4 - 3);
|
|
EXPECT_EQ(a.lane<3>(), 4 - 5);
|
|
}
|
|
|
|
/** @brief Test vint4 sub. */
|
|
TEST(vint4, vssub)
|
|
{
|
|
vint4 a(1, 2, 4, 4);
|
|
int b = 5;
|
|
a = a - b;
|
|
EXPECT_EQ(a.lane<0>(), 1 - 5);
|
|
EXPECT_EQ(a.lane<1>(), 2 - 5);
|
|
EXPECT_EQ(a.lane<2>(), 4 - 5);
|
|
EXPECT_EQ(a.lane<3>(), 4 - 5);
|
|
}
|
|
|
|
/** @brief Test vint4 mul. */
|
|
TEST(vint4, vmul)
|
|
{
|
|
vint4 a(1, 2, 4, 4);
|
|
vint4 b(2, 3, 3, 5);
|
|
a = a * b;
|
|
EXPECT_EQ(a.lane<0>(), 1 * 2);
|
|
EXPECT_EQ(a.lane<1>(), 2 * 3);
|
|
EXPECT_EQ(a.lane<2>(), 4 * 3);
|
|
EXPECT_EQ(a.lane<3>(), 4 * 5);
|
|
}
|
|
|
|
/** @brief Test vint4 mul. */
|
|
TEST(vint4, vsmul)
|
|
{
|
|
vint4 a(1, 2, 4, 4);
|
|
a = a * 3;
|
|
EXPECT_EQ(a.lane<0>(), 1 * 3);
|
|
EXPECT_EQ(a.lane<1>(), 2 * 3);
|
|
EXPECT_EQ(a.lane<2>(), 4 * 3);
|
|
EXPECT_EQ(a.lane<3>(), 4 * 3);
|
|
|
|
vint4 b(1, 2, -4, 4);
|
|
b = b * -3;
|
|
EXPECT_EQ(b.lane<0>(), 1 * -3);
|
|
EXPECT_EQ(b.lane<1>(), 2 * -3);
|
|
EXPECT_EQ(b.lane<2>(), -4 * -3);
|
|
EXPECT_EQ(b.lane<3>(), 4 * -3);
|
|
}
|
|
|
|
/** @brief Test vint4 bitwise invert. */
|
|
TEST(vint4, bit_invert)
|
|
{
|
|
vint4 a(-1, 0, 1, 2);
|
|
a = ~a;
|
|
EXPECT_EQ(a.lane<0>(), ~-1);
|
|
EXPECT_EQ(a.lane<1>(), ~0);
|
|
EXPECT_EQ(a.lane<2>(), ~1);
|
|
EXPECT_EQ(a.lane<3>(), ~2);
|
|
}
|
|
|
|
/** @brief Test vint4 bitwise or. */
|
|
TEST(vint4, bit_vor)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 b(2, 3, 4, 5);
|
|
a = a | b;
|
|
EXPECT_EQ(a.lane<0>(), 3);
|
|
EXPECT_EQ(a.lane<1>(), 3);
|
|
EXPECT_EQ(a.lane<2>(), 7);
|
|
EXPECT_EQ(a.lane<3>(), 5);
|
|
}
|
|
|
|
TEST(vint4, bit_vsor)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
int b = 2;
|
|
a = a | b;
|
|
EXPECT_EQ(a.lane<0>(), 3);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 3);
|
|
EXPECT_EQ(a.lane<3>(), 6);
|
|
}
|
|
|
|
/** @brief Test vint4 bitwise and. */
|
|
TEST(vint4, bit_vand)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 b(2, 3, 4, 5);
|
|
a = a & b;
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), 4);
|
|
}
|
|
|
|
/** @brief Test vint4 bitwise and. */
|
|
TEST(vint4, bit_vsand)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
int b = 2;
|
|
a = a & b;
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 2);
|
|
EXPECT_EQ(a.lane<3>(), 0);
|
|
}
|
|
|
|
/** @brief Test vint4 bitwise xor. */
|
|
TEST(vint4, bit_vxor)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 b(2, 3, 4, 5);
|
|
a = a ^ b;
|
|
EXPECT_EQ(a.lane<0>(), 3);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 7);
|
|
EXPECT_EQ(a.lane<3>(), 1);
|
|
}
|
|
|
|
/** @brief Test vint4 bitwise xor. */
|
|
TEST(vint4, bit_vsxor)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
int b = 2;
|
|
a = a ^ b;
|
|
EXPECT_EQ(a.lane<0>(), 3);
|
|
EXPECT_EQ(a.lane<1>(), 0);
|
|
EXPECT_EQ(a.lane<2>(), 1);
|
|
EXPECT_EQ(a.lane<3>(), 6);
|
|
}
|
|
|
|
/** @brief Test vint4 ceq. */
|
|
TEST(vint4, ceq)
|
|
{
|
|
vint4 a1(1, 2, 3, 4);
|
|
vint4 b1(0, 1, 2, 3);
|
|
vmask4 r1 = a1 == b1;
|
|
EXPECT_EQ(0u, mask(r1));
|
|
EXPECT_EQ(false, any(r1));
|
|
EXPECT_EQ(false, all(r1));
|
|
|
|
vint4 a2(1, 2, 3, 4);
|
|
vint4 b2(1, 0, 0, 0);
|
|
vmask4 r2 = a2 == b2;
|
|
EXPECT_EQ(0x1u, mask(r2));
|
|
EXPECT_EQ(true, any(r2));
|
|
EXPECT_EQ(false, all(r2));
|
|
|
|
vint4 a3(1, 2, 3, 4);
|
|
vint4 b3(1, 0, 3, 0);
|
|
vmask4 r3 = a3 == b3;
|
|
EXPECT_EQ(0x5u, mask(r3));
|
|
EXPECT_EQ(true, any(r3));
|
|
EXPECT_EQ(false, all(r3));
|
|
|
|
vint4 a4(1, 2, 3, 4);
|
|
vmask4 r4 = a4 == a4;
|
|
EXPECT_EQ(0xFu, mask(r4));
|
|
EXPECT_EQ(true, any(r4));
|
|
EXPECT_EQ(true, all(r4));
|
|
}
|
|
|
|
/** @brief Test vint4 cne. */
|
|
TEST(vint4, cne)
|
|
{
|
|
vint4 a1(1, 2, 3, 4);
|
|
vint4 b1(0, 1, 2, 3);
|
|
vmask4 r1 = a1 != b1;
|
|
EXPECT_EQ(0xFu, mask(r1));
|
|
EXPECT_EQ(true, any(r1));
|
|
EXPECT_EQ(true, all(r1));
|
|
|
|
vint4 a2(1, 2, 3, 4);
|
|
vint4 b2(1, 0, 0, 0);
|
|
vmask4 r2 = a2 != b2;
|
|
EXPECT_EQ(0xEu, mask(r2));
|
|
EXPECT_EQ(true, any(r2));
|
|
EXPECT_EQ(false, all(r2));
|
|
|
|
vint4 a3(1, 2, 3, 4);
|
|
vint4 b3(1, 0, 3, 0);
|
|
vmask4 r3 = a3 != b3;
|
|
EXPECT_EQ(0xAu, mask(r3));
|
|
EXPECT_EQ(true, any(r3));
|
|
EXPECT_EQ(false, all(r3));
|
|
|
|
vint4 a4(1, 2, 3, 4);
|
|
vmask4 r4 = a4 != a4;
|
|
EXPECT_EQ(0u, mask(r4));
|
|
EXPECT_EQ(false, any(r4));
|
|
EXPECT_EQ(false, all(r4));
|
|
}
|
|
|
|
/** @brief Test vint4 clt. */
|
|
TEST(vint4, clt)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 b(0, 3, 3, 5);
|
|
vmask4 r = a < b;
|
|
EXPECT_EQ(0xAu, mask(r));
|
|
}
|
|
|
|
/** @brief Test vint4 cgt. */
|
|
TEST(vint4, cle)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 b(0, 3, 3, 5);
|
|
vmask4 r = a > b;
|
|
EXPECT_EQ(0x1u, mask(r));
|
|
}
|
|
|
|
/** @brief Test vint4 lsl. */
|
|
TEST(vint4, lsl)
|
|
{
|
|
vint4 a(1, 2, 4, 4);
|
|
a = lsl<0>(a);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 4);
|
|
EXPECT_EQ(a.lane<3>(), 4);
|
|
|
|
a = lsl<1>(a);
|
|
EXPECT_EQ(a.lane<0>(), 2);
|
|
EXPECT_EQ(a.lane<1>(), 4);
|
|
EXPECT_EQ(a.lane<2>(), 8);
|
|
EXPECT_EQ(a.lane<3>(), 8);
|
|
|
|
a = lsl<2>(a);
|
|
EXPECT_EQ(a.lane<0>(), 8);
|
|
EXPECT_EQ(a.lane<1>(), 16);
|
|
EXPECT_EQ(a.lane<2>(), 32);
|
|
EXPECT_EQ(a.lane<3>(), 32);
|
|
}
|
|
|
|
/** @brief Test vint4 lsr. */
|
|
TEST(vint4, lsr)
|
|
{
|
|
vint4 a(1, 2, 4, -4);
|
|
a = lsr<0>(a);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 4);
|
|
EXPECT_EQ(a.lane<3>(), static_cast<int>(0xFFFFFFFC));
|
|
|
|
a = lsr<1>(a);
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 2);
|
|
EXPECT_EQ(a.lane<3>(), 0x7FFFFFFE);
|
|
|
|
a = lsr<2>(a);
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 0);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), 0x1FFFFFFF);
|
|
}
|
|
|
|
/** @brief Test vint4 asr. */
|
|
TEST(vint4, asr)
|
|
{
|
|
vint4 a(1, 2, 4, -4);
|
|
a = asr<0>(a);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 4);
|
|
EXPECT_EQ(a.lane<3>(), -4);
|
|
|
|
a = asr<1>(a);
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 2);
|
|
EXPECT_EQ(a.lane<3>(), -2);
|
|
|
|
// Note - quirk of asr is that you will get "stuck" at -1
|
|
a = asr<2>(a);
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 0);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), -1);
|
|
}
|
|
|
|
/** @brief Test vint4 min. */
|
|
TEST(vint4, min)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 b(0, 3, 3, 5);
|
|
vint4 r = min(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 0);
|
|
EXPECT_EQ(r.lane<1>(), 2);
|
|
EXPECT_EQ(r.lane<2>(), 3);
|
|
EXPECT_EQ(r.lane<3>(), 4);
|
|
}
|
|
|
|
/** @brief Test vint4 max. */
|
|
TEST(vint4, max)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 b(0, 3, 3, 5);
|
|
vint4 r = max(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 1);
|
|
EXPECT_EQ(r.lane<1>(), 3);
|
|
EXPECT_EQ(r.lane<2>(), 3);
|
|
EXPECT_EQ(r.lane<3>(), 5);
|
|
}
|
|
|
|
/** @brief Test vint4 clamp. */
|
|
TEST(vint4, clamp)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 r = clamp(2, 3, a);
|
|
EXPECT_EQ(r.lane<0>(), 2);
|
|
EXPECT_EQ(r.lane<1>(), 2);
|
|
EXPECT_EQ(r.lane<2>(), 3);
|
|
EXPECT_EQ(r.lane<3>(), 3);
|
|
}
|
|
|
|
/** @brief Test vint4 hmin. */
|
|
TEST(vint4, hmin)
|
|
{
|
|
vint4 a1(1, 2, 1, 2);
|
|
vint4 r1 = hmin(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 1);
|
|
EXPECT_EQ(r1.lane<1>(), 1);
|
|
EXPECT_EQ(r1.lane<2>(), 1);
|
|
EXPECT_EQ(r1.lane<3>(), 1);
|
|
|
|
vint4 a2(1, 2, -1, 5);
|
|
vint4 r2 = hmin(a2);
|
|
EXPECT_EQ(r2.lane<0>(), -1);
|
|
EXPECT_EQ(r2.lane<1>(), -1);
|
|
EXPECT_EQ(r2.lane<2>(), -1);
|
|
EXPECT_EQ(r2.lane<3>(), -1);
|
|
}
|
|
|
|
/** @brief Test vint4 hmax. */
|
|
TEST(vint4, hmax)
|
|
{
|
|
vint4 a1(1, 3, 1, 2);
|
|
vint4 r1 = hmax(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 3);
|
|
EXPECT_EQ(r1.lane<1>(), 3);
|
|
EXPECT_EQ(r1.lane<2>(), 3);
|
|
EXPECT_EQ(r1.lane<3>(), 3);
|
|
|
|
vint4 a2(1, 2, -1, 5);
|
|
vint4 r2 = hmax(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 5);
|
|
EXPECT_EQ(r2.lane<1>(), 5);
|
|
EXPECT_EQ(r2.lane<2>(), 5);
|
|
EXPECT_EQ(r2.lane<3>(), 5);
|
|
}
|
|
|
|
/** @brief Test vint4 hadd_s. */
|
|
TEST(vint4, hadd_s)
|
|
{
|
|
vint4 a1(1, 3, 5, 7);
|
|
int r1 = hadd_s(a1);
|
|
EXPECT_EQ(r1, 16);
|
|
|
|
vint4 a2(1, 2, -1, 5);
|
|
int r2 = hadd_s(a2);
|
|
EXPECT_EQ(r2, 7);
|
|
}
|
|
|
|
/** @brief Test vint4 hadd_rgb_s. */
|
|
TEST(vint4, hadd_rgb_s)
|
|
{
|
|
vint4 a1(1, 3, 5, 7);
|
|
int r1 = hadd_rgb_s(a1);
|
|
EXPECT_EQ(r1, 9);
|
|
|
|
vint4 a2(1, 2, -1, 5);
|
|
int r2 = hadd_rgb_s(a2);
|
|
EXPECT_EQ(r2, 2);
|
|
}
|
|
|
|
/** @brief Test vint4 clz. */
|
|
TEST(vint4, clz)
|
|
{
|
|
int msb_set = static_cast<int>(0x80000000);
|
|
vint4 a1(msb_set, 0x40000000, 0x20000000, 0x10000000);
|
|
vint4 r1 = clz(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 0);
|
|
EXPECT_EQ(r1.lane<1>(), 1);
|
|
EXPECT_EQ(r1.lane<2>(), 2);
|
|
EXPECT_EQ(r1.lane<3>(), 3);
|
|
|
|
vint4 a2(0x0, 0x1, 0x2, 0x4);
|
|
vint4 r2 = clz(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 32);
|
|
EXPECT_EQ(r2.lane<1>(), 31);
|
|
EXPECT_EQ(r2.lane<2>(), 30);
|
|
EXPECT_EQ(r2.lane<3>(), 29);
|
|
}
|
|
|
|
/** @brief Test vint4 two_to_the_n. */
|
|
TEST(vint4, two_to_the_n)
|
|
{
|
|
vint4 a1(0, 1, 2, 3);
|
|
vint4 r1 = two_to_the_n(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 1 << 0);
|
|
EXPECT_EQ(r1.lane<1>(), 1 << 1);
|
|
EXPECT_EQ(r1.lane<2>(), 1 << 2);
|
|
EXPECT_EQ(r1.lane<3>(), 1 << 3);
|
|
|
|
vint4 a2(27, 28, 29, 30);
|
|
vint4 r2 = two_to_the_n(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 1 << 27);
|
|
EXPECT_EQ(r2.lane<1>(), 1 << 28);
|
|
EXPECT_EQ(r2.lane<2>(), 1 << 29);
|
|
EXPECT_EQ(r2.lane<3>(), 1 << 30);
|
|
|
|
// Shifts higher than 30 are not allowed as it overflows the int type;
|
|
// and results in implementation-defined behavior because of how we
|
|
// generate the shifted result in two_to_the_n().
|
|
// - Shift by 31 shifts into sign bit
|
|
// - Shift by 32 shifts off the end
|
|
}
|
|
|
|
/** @brief Test vint4 storea. */
|
|
TEST(vint4, storea)
|
|
{
|
|
alignas(16) int out[4];
|
|
vint4 a(s32_data);
|
|
storea(a, out);
|
|
EXPECT_EQ(out[0], 0);
|
|
EXPECT_EQ(out[1], 1);
|
|
EXPECT_EQ(out[2], 2);
|
|
EXPECT_EQ(out[3], 3);
|
|
}
|
|
|
|
/** @brief Test vint4 store. */
|
|
TEST(vint4, store)
|
|
{
|
|
alignas(16) int out[5];
|
|
vint4 a(s32_data);
|
|
store(a, &(out[1]));
|
|
EXPECT_EQ(out[1], 0);
|
|
EXPECT_EQ(out[2], 1);
|
|
EXPECT_EQ(out[3], 2);
|
|
EXPECT_EQ(out[4], 3);
|
|
}
|
|
|
|
/** @brief Test vint4 store_nbytes. */
|
|
TEST(vint4, store_nbytes)
|
|
{
|
|
alignas(16) int out;
|
|
vint4 a(42, 314, 75, 90);
|
|
store_nbytes(a, reinterpret_cast<uint8_t*>(&out));
|
|
EXPECT_EQ(out, 42);
|
|
}
|
|
|
|
/** @brief Test vint8 store_lanes_masked. */
|
|
TEST(vint4, store_lanes_masked)
|
|
{
|
|
int resulta[4] { 0 };
|
|
|
|
// Store nothing
|
|
vmask4 mask1 = vint4(0) == vint4(1);
|
|
vint4 data1 = vint4(1);
|
|
|
|
store_lanes_masked(resulta, data1, mask1);
|
|
vint4 result1v(resulta);
|
|
vint4 expect1v = vint4::zero();
|
|
EXPECT_TRUE(all(result1v == expect1v));
|
|
|
|
// Store half
|
|
vmask4 mask2 = vint4(1, 1, 0, 0) == vint4(1);
|
|
vint4 data2 = vint4(2);
|
|
|
|
store_lanes_masked(resulta, data2, mask2);
|
|
vint4 result2v(resulta);
|
|
vint4 expect2v = vint4(2, 2, 0, 0);
|
|
EXPECT_TRUE(all(result2v == expect2v));
|
|
|
|
// Store all
|
|
vmask4 mask3 = vint4(1) == vint4(1);
|
|
vint4 data3 = vint4(3);
|
|
|
|
store_lanes_masked(resulta, data3, mask3);
|
|
vint4 result3v(resulta);
|
|
vint4 expect3v = vint4(3);
|
|
EXPECT_TRUE(all(result3v == expect3v));
|
|
}
|
|
|
|
/** @brief Test vint8 store_lanes_masked to unaligned address. */
|
|
TEST(vint4, store_lanes_masked_unaligned)
|
|
{
|
|
int8_t resulta[17] { 0 };
|
|
|
|
// Store nothing
|
|
vmask4 mask1 = vint4(0) == vint4(1);
|
|
vint4 data1 = vint4(1);
|
|
|
|
store_lanes_masked(reinterpret_cast<int*>(resulta + 1), data1, mask1);
|
|
vint4 result1v(reinterpret_cast<int*>(resulta + 1));
|
|
vint4 expect1v = vint4::zero();
|
|
EXPECT_TRUE(all(result1v == expect1v));
|
|
|
|
// Store half
|
|
vmask4 mask2 = vint4(1, 1, 0, 0) == vint4(1);
|
|
vint4 data2 = vint4(2);
|
|
|
|
store_lanes_masked(reinterpret_cast<int*>(resulta + 1), data2, mask2);
|
|
vint4 result2v(reinterpret_cast<int*>(resulta + 1));
|
|
vint4 expect2v = vint4(2, 2, 0, 0);
|
|
EXPECT_TRUE(all(result2v == expect2v));
|
|
|
|
// Store all
|
|
vmask4 mask3 = vint4(1) == vint4(1);
|
|
vint4 data3 = vint4(3);
|
|
|
|
store_lanes_masked(reinterpret_cast<int*>(resulta + 1), data3, mask3);
|
|
vint4 result3v(reinterpret_cast<int*>(resulta + 1));
|
|
vint4 expect3v = vint4(3);
|
|
EXPECT_TRUE(all(result3v == expect3v));
|
|
}
|
|
|
|
/** @brief Test vint4 gatheri. */
|
|
TEST(vint4, gatheri)
|
|
{
|
|
vint4 indices(0, 4, 3, 2);
|
|
vint4 r = gatheri(s32_data, indices);
|
|
EXPECT_EQ(r.lane<0>(), 0);
|
|
EXPECT_EQ(r.lane<1>(), 4);
|
|
EXPECT_EQ(r.lane<2>(), 3);
|
|
EXPECT_EQ(r.lane<3>(), 2);
|
|
}
|
|
|
|
/** @brief Test vint4 pack_low_bytes. */
|
|
TEST(vint4, pack_low_bytes)
|
|
{
|
|
vint4 a(1, 2, 3, 4);
|
|
vint4 r = pack_low_bytes(a);
|
|
EXPECT_EQ(r.lane<0>(), (4 << 24) | (3 << 16) | (2 << 8) | (1 << 0));
|
|
}
|
|
|
|
/** @brief Test vint4 select. */
|
|
TEST(vint4, select)
|
|
{
|
|
vint4 m1(1, 1, 1, 1);
|
|
vint4 m2(1, 2, 1, 2);
|
|
vmask4 cond = m1 == m2;
|
|
|
|
vint4 a(1, 3, 3, 1);
|
|
vint4 b(4, 2, 2, 4);
|
|
|
|
vint4 r1 = select(a, b, cond);
|
|
EXPECT_EQ(r1.lane<0>(), 4);
|
|
EXPECT_EQ(r1.lane<1>(), 3);
|
|
EXPECT_EQ(r1.lane<2>(), 2);
|
|
EXPECT_EQ(r1.lane<3>(), 1);
|
|
|
|
vint4 r2 = select(b, a, cond);
|
|
EXPECT_EQ(r2.lane<0>(), 1);
|
|
EXPECT_EQ(r2.lane<1>(), 2);
|
|
EXPECT_EQ(r2.lane<2>(), 3);
|
|
EXPECT_EQ(r2.lane<3>(), 4);
|
|
}
|
|
|
|
// VMASK4 tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
/** @brief Test vmask4 scalar literal constructor. */
|
|
TEST(vmask4, scalar_literal_construct)
|
|
{
|
|
vfloat4 m1a(0.0f, 0.0f, 0.0f, 0.0f);
|
|
vfloat4 m1b(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vmask4 m1(true);
|
|
|
|
vfloat4 r = select(m1a, m1b, m1);
|
|
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 1.0f);
|
|
EXPECT_EQ(r.lane<2>(), 1.0f);
|
|
EXPECT_EQ(r.lane<3>(), 1.0f);
|
|
|
|
r = select(m1b, m1a, m1);
|
|
|
|
EXPECT_EQ(r.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r.lane<2>(), 0.0f);
|
|
EXPECT_EQ(r.lane<3>(), 0.0f);
|
|
}
|
|
|
|
/** @brief Test vmask4 literal constructor. */
|
|
TEST(vmask4, literal_construct)
|
|
{
|
|
vfloat4 m1a(0.0f, 0.0f, 0.0f, 0.0f);
|
|
vfloat4 m1b(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vmask4 m1(true, false, true, false);
|
|
|
|
vfloat4 r = select(m1a, m1b, m1);
|
|
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r.lane<2>(), 1.0f);
|
|
EXPECT_EQ(r.lane<3>(), 0.0f);
|
|
}
|
|
|
|
/** @brief Test vmask4 or. */
|
|
TEST(vmask4, or)
|
|
{
|
|
vfloat4 m1a(0, 1, 0, 1);
|
|
vfloat4 m1b(1, 1, 1, 1);
|
|
vmask4 m1 = m1a == m1b;
|
|
|
|
vfloat4 m2a(1, 1, 0, 0);
|
|
vfloat4 m2b(1, 1, 1, 1);
|
|
vmask4 m2 = m2a == m2b;
|
|
|
|
vmask4 r = m1 | m2;
|
|
EXPECT_EQ(mask(r), 0xBu);
|
|
}
|
|
|
|
/** @brief Test vmask4 and. */
|
|
TEST(vmask4, and)
|
|
{
|
|
vfloat4 m1a(0, 1, 0, 1);
|
|
vfloat4 m1b(1, 1, 1, 1);
|
|
vmask4 m1 = m1a == m1b;
|
|
|
|
vfloat4 m2a(1, 1, 0, 0);
|
|
vfloat4 m2b(1, 1, 1, 1);
|
|
vmask4 m2 = m2a == m2b;
|
|
|
|
vmask4 r = m1 & m2;
|
|
EXPECT_EQ(mask(r), 0x2u);
|
|
}
|
|
|
|
/** @brief Test vmask4 xor. */
|
|
TEST(vmask4, xor)
|
|
{
|
|
vfloat4 m1a(0, 1, 0, 1);
|
|
vfloat4 m1b(1, 1, 1, 1);
|
|
vmask4 m1 = m1a == m1b;
|
|
|
|
vfloat4 m2a(1, 1, 0, 0);
|
|
vfloat4 m2b(1, 1, 1, 1);
|
|
vmask4 m2 = m2a == m2b;
|
|
|
|
vmask4 r = m1 ^ m2;
|
|
EXPECT_EQ(mask(r), 0x9u);
|
|
}
|
|
|
|
/** @brief Test vmask4 not. */
|
|
TEST(vmask4, not)
|
|
{
|
|
vfloat4 m1a(0, 1, 0, 1);
|
|
vfloat4 m1b(1, 1, 1, 1);
|
|
vmask4 m1 = m1a == m1b;
|
|
vmask4 r = ~m1;
|
|
EXPECT_EQ(mask(r), 0x5u);
|
|
}
|
|
|
|
/** @brief Test vint4 table permute. */
|
|
TEST(vint4, vtable_8bt_32bi_32entry)
|
|
{
|
|
vint4 table0(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f);
|
|
vint4 table1(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f);
|
|
|
|
vint4 table0p, table1p;
|
|
vtable_prepare(table0, table1, table0p, table1p);
|
|
|
|
vint4 index(0, 7, 4, 31);
|
|
|
|
vint4 result = vtable_8bt_32bi(table0p, table1p, index);
|
|
|
|
EXPECT_EQ(result.lane<0>(), 3);
|
|
EXPECT_EQ(result.lane<1>(), 4);
|
|
EXPECT_EQ(result.lane<2>(), 7);
|
|
EXPECT_EQ(result.lane<3>(), 28);
|
|
}
|
|
|
|
/** @brief Test vint4 table permute. */
|
|
TEST(vint4, vtable_8bt_32bi_64entry)
|
|
{
|
|
vint4 table0(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f);
|
|
vint4 table1(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f);
|
|
vint4 table2(0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f);
|
|
vint4 table3(0x30313233, 0x34353637, 0x38393a3b, 0x3c3d3e3f);
|
|
|
|
vint4 table0p, table1p, table2p, table3p;
|
|
vtable_prepare(table0, table1, table2, table3, table0p, table1p, table2p, table3p);
|
|
|
|
vint4 index(0, 7, 38, 63);
|
|
|
|
vint4 result = vtable_8bt_32bi(table0p, table1p, table2p, table3p, index);
|
|
|
|
EXPECT_EQ(result.lane<0>(), 3);
|
|
EXPECT_EQ(result.lane<1>(), 4);
|
|
EXPECT_EQ(result.lane<2>(), 37);
|
|
EXPECT_EQ(result.lane<3>(), 60);
|
|
}
|
|
|
|
/** @brief Test vint4 rgba byte interleave. */
|
|
TEST(vint4, interleave_rgba8)
|
|
{
|
|
vint4 r(0x01, 0x11, 0x21, 0x31);
|
|
vint4 g(0x02, 0x12, 0x22, 0x32);
|
|
vint4 b(0x03, 0x13, 0x23, 0x33);
|
|
vint4 a(0x04, 0x14, 0x24, 0x34);
|
|
|
|
vint4 result = interleave_rgba8(r, g, b, a);
|
|
|
|
EXPECT_EQ(result.lane<0>(), 0x04030201);
|
|
EXPECT_EQ(result.lane<1>(), 0x14131211);
|
|
EXPECT_EQ(result.lane<2>(), 0x24232221);
|
|
EXPECT_EQ(result.lane<3>(), 0x34333231);
|
|
}
|
|
|
|
# if ASTCENC_SIMD_WIDTH == 8
|
|
|
|
// VFLOAT8 tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
/** @brief Test unaligned vfloat8 data load. */
|
|
TEST(vfloat8, UnalignedLoad)
|
|
{
|
|
vfloat8 a(&(f32_data[1]));
|
|
EXPECT_EQ(a.lane<0>(), 1.0f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f);
|
|
EXPECT_EQ(a.lane<4>(), 5.0f);
|
|
EXPECT_EQ(a.lane<5>(), 6.0f);
|
|
EXPECT_EQ(a.lane<6>(), 7.0f);
|
|
EXPECT_EQ(a.lane<7>(), 8.0f);
|
|
}
|
|
|
|
/** @brief Test scalar duplicated vfloat8 load. */
|
|
TEST(vfloat8, ScalarDupLoad)
|
|
{
|
|
vfloat8 a(1.1f);
|
|
EXPECT_EQ(a.lane<0>(), 1.1f);
|
|
EXPECT_EQ(a.lane<1>(), 1.1f);
|
|
EXPECT_EQ(a.lane<2>(), 1.1f);
|
|
EXPECT_EQ(a.lane<3>(), 1.1f);
|
|
EXPECT_EQ(a.lane<4>(), 1.1f);
|
|
EXPECT_EQ(a.lane<5>(), 1.1f);
|
|
EXPECT_EQ(a.lane<6>(), 1.1f);
|
|
EXPECT_EQ(a.lane<7>(), 1.1f);
|
|
}
|
|
|
|
/** @brief Test scalar vfloat8 load. */
|
|
TEST(vfloat8, ScalarLoad)
|
|
{
|
|
vfloat8 a(1.1f, 2.2f, 3.3f, 4.4f, 5.5f, 6.6f, 7.7f, 8.8f);
|
|
EXPECT_EQ(a.lane<0>(), 1.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.4f);
|
|
EXPECT_EQ(a.lane<4>(), 5.5f);
|
|
EXPECT_EQ(a.lane<5>(), 6.6f);
|
|
EXPECT_EQ(a.lane<6>(), 7.7f);
|
|
EXPECT_EQ(a.lane<7>(), 8.8f);
|
|
}
|
|
|
|
/** @brief Test copy vfloat8 load. */
|
|
TEST(vfloat8, CopyLoad)
|
|
{
|
|
vfloat8 s(1.1f, 2.2f, 3.3f, 4.4f, 5.5f, 6.6f, 7.7f, 8.8f);
|
|
vfloat8 a(s.m);
|
|
EXPECT_EQ(a.lane<0>(), 1.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.4f);
|
|
EXPECT_EQ(a.lane<4>(), 5.5f);
|
|
EXPECT_EQ(a.lane<5>(), 6.6f);
|
|
EXPECT_EQ(a.lane<6>(), 7.7f);
|
|
EXPECT_EQ(a.lane<7>(), 8.8f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 zero. */
|
|
TEST(vfloat8, Zero)
|
|
{
|
|
vfloat8 a = vfloat8::zero();
|
|
EXPECT_EQ(a.lane<0>(), 0.0f);
|
|
EXPECT_EQ(a.lane<1>(), 0.0f);
|
|
EXPECT_EQ(a.lane<2>(), 0.0f);
|
|
EXPECT_EQ(a.lane<3>(), 0.0f);
|
|
EXPECT_EQ(a.lane<4>(), 0.0f);
|
|
EXPECT_EQ(a.lane<5>(), 0.0f);
|
|
EXPECT_EQ(a.lane<6>(), 0.0f);
|
|
EXPECT_EQ(a.lane<7>(), 0.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 load1. */
|
|
TEST(vfloat8, Load1)
|
|
{
|
|
float s = 3.14f;
|
|
vfloat8 a = vfloat8::load1(&s);
|
|
EXPECT_EQ(a.lane<0>(), 3.14f);
|
|
EXPECT_EQ(a.lane<1>(), 3.14f);
|
|
EXPECT_EQ(a.lane<2>(), 3.14f);
|
|
EXPECT_EQ(a.lane<3>(), 3.14f);
|
|
EXPECT_EQ(a.lane<4>(), 3.14f);
|
|
EXPECT_EQ(a.lane<5>(), 3.14f);
|
|
EXPECT_EQ(a.lane<6>(), 3.14f);
|
|
EXPECT_EQ(a.lane<7>(), 3.14f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 loada. */
|
|
TEST(vfloat8, Loada)
|
|
{
|
|
vfloat8 a = vfloat8::loada(&(f32_data[0]));
|
|
EXPECT_EQ(a.lane<0>(), 0.0f);
|
|
EXPECT_EQ(a.lane<1>(), 1.0f);
|
|
EXPECT_EQ(a.lane<2>(), 2.0f);
|
|
EXPECT_EQ(a.lane<3>(), 3.0f);
|
|
EXPECT_EQ(a.lane<4>(), 4.0f);
|
|
EXPECT_EQ(a.lane<5>(), 5.0f);
|
|
EXPECT_EQ(a.lane<6>(), 6.0f);
|
|
EXPECT_EQ(a.lane<7>(), 7.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 lane_id. */
|
|
TEST(vfloat8, LaneID)
|
|
{
|
|
vfloat8 a = vfloat8::lane_id();
|
|
EXPECT_EQ(a.lane<0>(), 0.0f);
|
|
EXPECT_EQ(a.lane<1>(), 1.0f);
|
|
EXPECT_EQ(a.lane<2>(), 2.0f);
|
|
EXPECT_EQ(a.lane<3>(), 3.0f);
|
|
EXPECT_EQ(a.lane<4>(), 4.0f);
|
|
EXPECT_EQ(a.lane<5>(), 5.0f);
|
|
EXPECT_EQ(a.lane<6>(), 6.0f);
|
|
EXPECT_EQ(a.lane<7>(), 7.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 add. */
|
|
TEST(vfloat8, vadd)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b(0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
a = a + b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f + 0.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f + 0.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f + 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f + 0.4f);
|
|
EXPECT_EQ(a.lane<4>(), 5.0f + 0.5f);
|
|
EXPECT_EQ(a.lane<5>(), 6.0f + 0.6f);
|
|
EXPECT_EQ(a.lane<6>(), 7.0f + 0.7f);
|
|
EXPECT_EQ(a.lane<7>(), 8.0f + 0.8f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 sub. */
|
|
TEST(vfloat8, vsub)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b(0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
a = a - b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f - 0.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f - 0.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f - 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f - 0.4f);
|
|
EXPECT_EQ(a.lane<4>(), 5.0f - 0.5f);
|
|
EXPECT_EQ(a.lane<5>(), 6.0f - 0.6f);
|
|
EXPECT_EQ(a.lane<6>(), 7.0f - 0.7f);
|
|
EXPECT_EQ(a.lane<7>(), 8.0f - 0.8f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 mul. */
|
|
TEST(vfloat8, vmul)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b(0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
a = a * b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f * 0.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f * 0.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f * 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f * 0.4f);
|
|
EXPECT_EQ(a.lane<4>(), 5.0f * 0.5f);
|
|
EXPECT_EQ(a.lane<5>(), 6.0f * 0.6f);
|
|
EXPECT_EQ(a.lane<6>(), 7.0f * 0.7f);
|
|
EXPECT_EQ(a.lane<7>(), 8.0f * 0.8f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 mul. */
|
|
TEST(vfloat8, vsmul)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
float b = 3.14f;
|
|
a = a * b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<4>(), 5.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<5>(), 6.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<6>(), 7.0f * 3.14f);
|
|
EXPECT_EQ(a.lane<7>(), 8.0f * 3.14f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 mul. */
|
|
TEST(vfloat8, svmul)
|
|
{
|
|
float a = 3.14f;
|
|
vfloat8 b(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
b = a * b;
|
|
EXPECT_EQ(b.lane<0>(), 3.14f * 1.0f);
|
|
EXPECT_EQ(b.lane<1>(), 3.14f * 2.0f);
|
|
EXPECT_EQ(b.lane<2>(), 3.14f * 3.0f);
|
|
EXPECT_EQ(b.lane<3>(), 3.14f * 4.0f);
|
|
EXPECT_EQ(b.lane<4>(), 3.14f * 5.0f);
|
|
EXPECT_EQ(b.lane<5>(), 3.14f * 6.0f);
|
|
EXPECT_EQ(b.lane<6>(), 3.14f * 7.0f);
|
|
EXPECT_EQ(b.lane<7>(), 3.14f * 8.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 div. */
|
|
TEST(vfloat8, vdiv)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b(0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
a = a / b;
|
|
EXPECT_EQ(a.lane<0>(), 1.0f / 0.1f);
|
|
EXPECT_EQ(a.lane<1>(), 2.0f / 0.2f);
|
|
EXPECT_EQ(a.lane<2>(), 3.0f / 0.3f);
|
|
EXPECT_EQ(a.lane<3>(), 4.0f / 0.4f);
|
|
EXPECT_EQ(a.lane<4>(), 5.0f / 0.5f);
|
|
EXPECT_EQ(a.lane<5>(), 6.0f / 0.6f);
|
|
EXPECT_EQ(a.lane<6>(), 7.0f / 0.7f);
|
|
EXPECT_EQ(a.lane<7>(), 8.0f / 0.8f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 div. */
|
|
TEST(vfloat8, vsdiv)
|
|
{
|
|
vfloat8 a(0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
float b = 3.14f;
|
|
vfloat8 r = a / b;
|
|
|
|
EXPECT_EQ(r.lane<0>(), 0.1f / 3.14f);
|
|
EXPECT_EQ(r.lane<1>(), 0.2f / 3.14f);
|
|
EXPECT_EQ(r.lane<2>(), 0.3f / 3.14f);
|
|
EXPECT_EQ(r.lane<3>(), 0.4f / 3.14f);
|
|
EXPECT_EQ(r.lane<4>(), 0.5f / 3.14f);
|
|
EXPECT_EQ(r.lane<5>(), 0.6f / 3.14f);
|
|
EXPECT_EQ(r.lane<6>(), 0.7f / 3.14f);
|
|
EXPECT_EQ(r.lane<7>(), 0.8f / 3.14f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 div. */
|
|
TEST(vfloat8, svdiv)
|
|
{
|
|
float a = 3.14f;
|
|
vfloat8 b(0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
vfloat8 r = a / b;
|
|
|
|
EXPECT_EQ(r.lane<0>(), 3.14f / 0.1f);
|
|
EXPECT_EQ(r.lane<1>(), 3.14f / 0.2f);
|
|
EXPECT_EQ(r.lane<2>(), 3.14f / 0.3f);
|
|
EXPECT_EQ(r.lane<3>(), 3.14f / 0.4f);
|
|
EXPECT_EQ(r.lane<4>(), 3.14f / 0.5f);
|
|
EXPECT_EQ(r.lane<5>(), 3.14f / 0.6f);
|
|
EXPECT_EQ(r.lane<6>(), 3.14f / 0.7f);
|
|
EXPECT_EQ(r.lane<7>(), 3.14f / 0.8f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 ceq. */
|
|
TEST(vfloat8, ceq)
|
|
{
|
|
vfloat8 a1(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b1(0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
vmask8 r1 = a1 == b1;
|
|
EXPECT_EQ(0u, mask(r1));
|
|
EXPECT_EQ(false, any(r1));
|
|
EXPECT_EQ(false, all(r1));
|
|
|
|
vfloat8 a2(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b2(1.0f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
vmask8 r2 = a2 == b2;
|
|
EXPECT_EQ(0x1u, mask(r2));
|
|
EXPECT_EQ(true, any(r2));
|
|
EXPECT_EQ(false, all(r2));
|
|
|
|
vfloat8 a3(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b3(1.0f, 0.2f, 3.0f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
vmask8 r3 = a3 == b3;
|
|
EXPECT_EQ(0x5u, mask(r3));
|
|
EXPECT_EQ(true, any(r3));
|
|
EXPECT_EQ(false, all(r3));
|
|
|
|
vfloat8 a4(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vmask8 r4 = a4 == a4;
|
|
EXPECT_EQ(0xFFu, mask(r4));
|
|
EXPECT_EQ(true, any(r4));
|
|
EXPECT_EQ(true, all(r4));
|
|
}
|
|
|
|
/** @brief Test vfloat8 cne. */
|
|
TEST(vfloat8, cne)
|
|
{
|
|
vfloat8 a1(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b1(0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
vmask8 r1 = a1 != b1;
|
|
EXPECT_EQ(0xFFu, mask(r1));
|
|
EXPECT_EQ(true, any(r1));
|
|
EXPECT_EQ(true, all(r1));
|
|
|
|
vfloat8 a2(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b2(1.0f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
vmask8 r2 = a2 != b2;
|
|
EXPECT_EQ(0xFEu, mask(r2));
|
|
EXPECT_EQ(true, any(r2));
|
|
EXPECT_EQ(false, all(r2));
|
|
|
|
vfloat8 a3(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vfloat8 b3(1.0f, 0.2f, 3.0f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f);
|
|
vmask8 r3 = a3 != b3;
|
|
EXPECT_EQ(0xFAu, mask(r3));
|
|
EXPECT_EQ(true, any(r3));
|
|
EXPECT_EQ(false, all(r3));
|
|
|
|
vfloat8 a4(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f);
|
|
vmask8 r4 = a4 != a4;
|
|
EXPECT_EQ(0u, mask(r4));
|
|
EXPECT_EQ(false, any(r4));
|
|
EXPECT_EQ(false, all(r4));
|
|
}
|
|
|
|
/** @brief Test vfloat8 clt. */
|
|
TEST(vfloat8, clt)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat8 b(0.9f, 2.1f, 3.0f, 4.1f, 0.9f, 2.1f, 3.0f, 4.1f);
|
|
vmask8 r = a < b;
|
|
EXPECT_EQ(0xAAu, mask(r));
|
|
}
|
|
|
|
/** @brief Test vfloat8 cle. */
|
|
TEST(vfloat8, cle)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat8 b(0.9f, 2.1f, 3.0f, 4.1f, 0.9f, 2.1f, 3.0f, 4.1f);
|
|
vmask8 r = a <= b;
|
|
EXPECT_EQ(0xEEu, mask(r));
|
|
}
|
|
|
|
/** @brief Test vfloat8 cgt. */
|
|
TEST(vfloat8, cgt)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat8 b(0.9f, 2.1f, 3.0f, 4.1f, 0.9f, 2.1f, 3.0f, 4.1f);
|
|
vmask8 r = a > b;
|
|
EXPECT_EQ(0x11u, mask(r));
|
|
}
|
|
|
|
/** @brief Test vfloat8 cge. */
|
|
TEST(vfloat8, cge)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat8 b(0.9f, 2.1f, 3.0f, 4.1f, 0.9f, 2.1f, 3.0f, 4.1f);
|
|
vmask8 r = a >= b;
|
|
EXPECT_EQ(0x55u, mask(r));
|
|
}
|
|
|
|
/** @brief Test vfloat8 min. */
|
|
TEST(vfloat8, min)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat8 b(0.9f, 2.1f, 3.0f, 4.1f, 0.9f, 2.1f, 3.0f, 4.1f);
|
|
vfloat8 r = min(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 0.9f);
|
|
EXPECT_EQ(r.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 4.0f);
|
|
EXPECT_EQ(r.lane<4>(), 0.9f);
|
|
EXPECT_EQ(r.lane<5>(), 2.0f);
|
|
EXPECT_EQ(r.lane<6>(), 3.0f);
|
|
EXPECT_EQ(r.lane<7>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 max. */
|
|
TEST(vfloat8, max)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat8 b(0.9f, 2.1f, 3.0f, 4.1f, 0.9f, 2.1f, 3.0f, 4.1f);
|
|
vfloat8 r = max(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 2.1f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 4.1f);
|
|
EXPECT_EQ(r.lane<4>(), 1.0f);
|
|
EXPECT_EQ(r.lane<5>(), 2.1f);
|
|
EXPECT_EQ(r.lane<6>(), 3.0f);
|
|
EXPECT_EQ(r.lane<7>(), 4.1f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 clamp. */
|
|
TEST(vfloat8, clamp)
|
|
{
|
|
vfloat8 a1(1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat8 r1 = clamp(2.1f, 3.0f, a1);
|
|
EXPECT_EQ(r1.lane<0>(), 2.1f);
|
|
EXPECT_EQ(r1.lane<1>(), 2.1f);
|
|
EXPECT_EQ(r1.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<4>(), 2.1f);
|
|
EXPECT_EQ(r1.lane<5>(), 2.1f);
|
|
EXPECT_EQ(r1.lane<6>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<7>(), 3.0f);
|
|
|
|
vfloat8 a2(1.0f, 2.0f, qnan, 4.0f, 1.0f, 2.0f, qnan, 4.0f);
|
|
vfloat8 r2 = clamp(2.1f, 3.0f, a2);
|
|
EXPECT_EQ(r2.lane<0>(), 2.1f);
|
|
EXPECT_EQ(r2.lane<1>(), 2.1f);
|
|
EXPECT_EQ(r2.lane<2>(), 2.1f);
|
|
EXPECT_EQ(r2.lane<3>(), 3.0f);
|
|
EXPECT_EQ(r2.lane<4>(), 2.1f);
|
|
EXPECT_EQ(r2.lane<5>(), 2.1f);
|
|
EXPECT_EQ(r2.lane<6>(), 2.1f);
|
|
EXPECT_EQ(r2.lane<7>(), 3.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 clampz. */
|
|
TEST(vfloat8, clampz)
|
|
{
|
|
vfloat8 a1(-1.0f, 0.0f, 0.1f, 4.0f, -1.0f, 0.0f, 0.1f, 4.0f);
|
|
vfloat8 r1 = clampz(3.0f, a1);
|
|
EXPECT_EQ(r1.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 0.1f);
|
|
EXPECT_EQ(r1.lane<3>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<4>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<5>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<6>(), 0.1f);
|
|
EXPECT_EQ(r1.lane<7>(), 3.0f);
|
|
|
|
vfloat8 a2(-1.0f, 0.0f, qnan, 4.0f, -1.0f, 0.0f, qnan, 4.0f);
|
|
vfloat8 r2 = clampz(3.0f, a2);
|
|
EXPECT_EQ(r2.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<2>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<3>(), 3.0f);
|
|
EXPECT_EQ(r2.lane<4>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<5>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<6>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<7>(), 3.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 clampz. */
|
|
TEST(vfloat8, clampzo)
|
|
{
|
|
vfloat8 a1(-1.0f, 0.0f, 0.1f, 4.0f, -1.0f, 0.0f, 0.1f, 4.0f);
|
|
vfloat8 r1 = clampzo(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 0.1f);
|
|
EXPECT_EQ(r1.lane<3>(), 1.0f);
|
|
EXPECT_EQ(r1.lane<4>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<5>(), 0.0f);
|
|
EXPECT_EQ(r1.lane<6>(), 0.1f);
|
|
EXPECT_EQ(r1.lane<7>(), 1.0f);
|
|
|
|
vfloat8 a2(-1.0f, 0.0f, qnan, 4.0f, -1.0f, 0.0f, qnan, 4.0f);
|
|
vfloat8 r2 = clampzo(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<2>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<3>(), 1.0f);
|
|
EXPECT_EQ(r2.lane<4>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<5>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<6>(), 0.0f);
|
|
EXPECT_EQ(r2.lane<7>(), 1.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 abs. */
|
|
TEST(vfloat8, abs)
|
|
{
|
|
vfloat8 a(-1.0f, 0.0f, 0.1f, 4.0f, -1.0f, 0.0f, 0.1f, 4.0f);
|
|
vfloat8 r = abs(a);
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 0.0f);
|
|
EXPECT_EQ(r.lane<2>(), 0.1f);
|
|
EXPECT_EQ(r.lane<3>(), 4.0f);
|
|
EXPECT_EQ(r.lane<4>(), 1.0f);
|
|
EXPECT_EQ(r.lane<5>(), 0.0f);
|
|
EXPECT_EQ(r.lane<6>(), 0.1f);
|
|
EXPECT_EQ(r.lane<7>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 round. */
|
|
TEST(vfloat8, round)
|
|
{
|
|
vfloat8 a(1.1f, 1.5f, 1.6f, 4.0f, 1.1f, 1.5f, 1.6f, 4.0f);
|
|
vfloat8 r = round(a);
|
|
EXPECT_EQ(r.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r.lane<2>(), 2.0f);
|
|
EXPECT_EQ(r.lane<3>(), 4.0f);
|
|
EXPECT_EQ(r.lane<4>(), 1.0f);
|
|
EXPECT_EQ(r.lane<5>(), 2.0f);
|
|
EXPECT_EQ(r.lane<6>(), 2.0f);
|
|
EXPECT_EQ(r.lane<7>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 hmin. */
|
|
TEST(vfloat8, hmin)
|
|
{
|
|
vfloat8 a1(1.1f, 1.5f, 1.6f, 4.0f, 1.1f, 1.5f, 1.6f, 4.0f);
|
|
vfloat8 r1 = hmin(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<1>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<2>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<3>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<4>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<5>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<6>(), 1.1f);
|
|
EXPECT_EQ(r1.lane<7>(), 1.1f);
|
|
|
|
vfloat8 a2(1.1f, 1.5f, 1.6f, 0.2f, 1.1f, 1.5f, 1.6f, 0.2f);
|
|
vfloat8 r2 = hmin(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<1>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<2>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<3>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<4>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<5>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<6>(), 0.2f);
|
|
EXPECT_EQ(r2.lane<7>(), 0.2f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 hmin_s. */
|
|
TEST(vfloat8, hmin_s)
|
|
{
|
|
vfloat8 a1(1.1f, 1.5f, 1.6f, 4.0f, 1.1f, 1.5f, 1.6f, 4.0f);
|
|
float r1 = hmin_s(a1);
|
|
EXPECT_EQ(r1, 1.1f);
|
|
|
|
vfloat8 a2(1.1f, 1.5f, 1.6f, 0.2f, 1.1f, 1.5f, 1.6f, 0.2f);
|
|
float r2 = hmin_s(a2);
|
|
EXPECT_EQ(r2, 0.2f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 hmax. */
|
|
TEST(vfloat8, hmax)
|
|
{
|
|
vfloat8 a1(1.1f, 1.5f, 1.6f, 4.0f, 1.1f, 1.5f, 1.6f, 4.0f);
|
|
vfloat8 r1 = hmax(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<4>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<5>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<6>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<7>(), 4.0f);
|
|
|
|
vfloat8 a2(1.1f, 1.5f, 1.6f, 0.2f, 1.1f, 1.5f, 1.6f, 0.2f);
|
|
vfloat8 r2 = hmax(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<1>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<2>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<3>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<4>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<5>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<6>(), 1.6f);
|
|
EXPECT_EQ(r2.lane<7>(), 1.6f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 hmax_s. */
|
|
TEST(vfloat8, hmax_s)
|
|
{
|
|
vfloat8 a1(1.1f, 1.5f, 1.6f, 4.0f, 1.1f, 1.5f, 1.6f, 4.0f);
|
|
float r1 = hmax_s(a1);
|
|
EXPECT_EQ(r1, 4.0f);
|
|
|
|
vfloat8 a2(1.1f, 1.5f, 1.6f, 0.2f, 1.1f, 1.5f, 1.6f, 0.2f);
|
|
float r2 = hmax_s(a2);
|
|
EXPECT_EQ(r2, 1.6f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 hadd_s. */
|
|
TEST(vfloat8, hadd_s)
|
|
{
|
|
vfloat8 a1(1.1f, 1.5f, 1.6f, 4.0f, 1.1f, 1.5f, 1.6f, 4.0f);
|
|
float sum = 1.1f + 1.5f + 1.6f + 4.0f + 1.1f + 1.5f + 1.6f + 4.0f;
|
|
float r = hadd_s(a1);
|
|
EXPECT_NEAR(r, sum, 0.005f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 sqrt. */
|
|
TEST(vfloat8, sqrt)
|
|
{
|
|
vfloat8 a(1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f);
|
|
vfloat8 r = sqrt(a);
|
|
EXPECT_EQ(r.lane<0>(), std::sqrt(1.0f));
|
|
EXPECT_EQ(r.lane<1>(), std::sqrt(2.0f));
|
|
EXPECT_EQ(r.lane<2>(), std::sqrt(3.0f));
|
|
EXPECT_EQ(r.lane<3>(), std::sqrt(4.0f));
|
|
EXPECT_EQ(r.lane<4>(), std::sqrt(1.0f));
|
|
EXPECT_EQ(r.lane<5>(), std::sqrt(2.0f));
|
|
EXPECT_EQ(r.lane<6>(), std::sqrt(3.0f));
|
|
EXPECT_EQ(r.lane<7>(), std::sqrt(4.0f));
|
|
}
|
|
|
|
/** @brief Test vfloat8 select. */
|
|
TEST(vfloat8, select)
|
|
{
|
|
vfloat8 m1(1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
|
|
vfloat8 m2(1.0f, 2.0f, 1.0f, 2.0f, 1.0f, 2.0f, 1.0f, 2.0f);
|
|
vmask8 cond = m1 == m2;
|
|
|
|
vfloat8 a(1.0f, 3.0f, 3.0f, 1.0f, 1.0f, 3.0f, 3.0f, 1.0);
|
|
vfloat8 b(4.0f, 2.0f, 2.0f, 4.0f, 4.0f, 2.0f, 2.0f, 4.0);
|
|
|
|
// Select in one direction
|
|
vfloat8 r1 = select(a, b, cond);
|
|
EXPECT_EQ(r1.lane<0>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 2.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 1.0f);
|
|
EXPECT_EQ(r1.lane<4>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<5>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<6>(), 2.0f);
|
|
EXPECT_EQ(r1.lane<7>(), 1.0f);
|
|
|
|
// Select in the other
|
|
vfloat8 r2 = select(b, a, cond);
|
|
EXPECT_EQ(r2.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r2.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r2.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r2.lane<3>(), 4.0f);
|
|
EXPECT_EQ(r2.lane<4>(), 1.0f);
|
|
EXPECT_EQ(r2.lane<5>(), 2.0f);
|
|
EXPECT_EQ(r2.lane<6>(), 3.0f);
|
|
EXPECT_EQ(r2.lane<7>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 select MSB only. */
|
|
TEST(vfloat8, select_msb)
|
|
{
|
|
int msb_set = static_cast<int>(0x80000000);
|
|
vint8 msb(msb_set, 0, msb_set, 0, msb_set, 0, msb_set, 0);
|
|
vmask8 cond(msb.m);
|
|
|
|
vfloat8 a(1.0f, 3.0f, 3.0f, 1.0f, 1.0f, 3.0f, 3.0f, 1.0f);
|
|
vfloat8 b(4.0f, 2.0f, 2.0f, 4.0f, 4.0f, 2.0f, 2.0f, 4.0f);
|
|
|
|
// Select in one direction
|
|
vfloat8 r1 = select(a, b, cond);
|
|
EXPECT_EQ(r1.lane<0>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<1>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<2>(), 2.0f);
|
|
EXPECT_EQ(r1.lane<3>(), 1.0f);
|
|
EXPECT_EQ(r1.lane<4>(), 4.0f);
|
|
EXPECT_EQ(r1.lane<5>(), 3.0f);
|
|
EXPECT_EQ(r1.lane<6>(), 2.0f);
|
|
EXPECT_EQ(r1.lane<7>(), 1.0f);
|
|
|
|
// Select in the other
|
|
vfloat8 r2 = select(b, a, cond);
|
|
EXPECT_EQ(r2.lane<0>(), 1.0f);
|
|
EXPECT_EQ(r2.lane<1>(), 2.0f);
|
|
EXPECT_EQ(r2.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r2.lane<3>(), 4.0f);
|
|
EXPECT_EQ(r2.lane<4>(), 1.0f);
|
|
EXPECT_EQ(r2.lane<5>(), 2.0f);
|
|
EXPECT_EQ(r2.lane<6>(), 3.0f);
|
|
EXPECT_EQ(r2.lane<7>(), 4.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 gatherf. */
|
|
TEST(vfloat8, gatherf)
|
|
{
|
|
vint8 indices(0, 4, 3, 2, 7, 4, 3, 2);
|
|
vfloat8 r = gatherf(f32_data, indices);
|
|
EXPECT_EQ(r.lane<0>(), 0.0f);
|
|
EXPECT_EQ(r.lane<1>(), 4.0f);
|
|
EXPECT_EQ(r.lane<2>(), 3.0f);
|
|
EXPECT_EQ(r.lane<3>(), 2.0f);
|
|
EXPECT_EQ(r.lane<4>(), 7.0f);
|
|
EXPECT_EQ(r.lane<5>(), 4.0f);
|
|
EXPECT_EQ(r.lane<6>(), 3.0f);
|
|
EXPECT_EQ(r.lane<7>(), 2.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 store. */
|
|
TEST(vfloat8, store)
|
|
{
|
|
alignas(32) float out[9];
|
|
vfloat8 a(f32_data);
|
|
store(a, &(out[1]));
|
|
EXPECT_EQ(out[1], 0.0f);
|
|
EXPECT_EQ(out[2], 1.0f);
|
|
EXPECT_EQ(out[3], 2.0f);
|
|
EXPECT_EQ(out[4], 3.0f);
|
|
EXPECT_EQ(out[5], 4.0f);
|
|
EXPECT_EQ(out[6], 5.0f);
|
|
EXPECT_EQ(out[7], 6.0f);
|
|
EXPECT_EQ(out[8], 7.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 storea. */
|
|
TEST(vfloat8, storea)
|
|
{
|
|
alignas(32) float out[9];
|
|
vfloat8 a(f32_data);
|
|
store(a, out);
|
|
EXPECT_EQ(out[0], 0.0f);
|
|
EXPECT_EQ(out[1], 1.0f);
|
|
EXPECT_EQ(out[2], 2.0f);
|
|
EXPECT_EQ(out[3], 3.0f);
|
|
EXPECT_EQ(out[4], 4.0f);
|
|
EXPECT_EQ(out[5], 5.0f);
|
|
EXPECT_EQ(out[6], 6.0f);
|
|
EXPECT_EQ(out[7], 7.0f);
|
|
}
|
|
|
|
/** @brief Test vfloat8 float_to_int. */
|
|
TEST(vfloat8, float_to_int)
|
|
{
|
|
vfloat8 a(1.1f, 1.5f, 1.6f, 4.0f, 1.1f, 1.5f, 1.6f, 4.0f);
|
|
vint8 r = float_to_int(a);
|
|
EXPECT_EQ(r.lane<0>(), 1);
|
|
EXPECT_EQ(r.lane<1>(), 1);
|
|
EXPECT_EQ(r.lane<2>(), 1);
|
|
EXPECT_EQ(r.lane<3>(), 4);
|
|
EXPECT_EQ(r.lane<4>(), 1);
|
|
EXPECT_EQ(r.lane<5>(), 1);
|
|
EXPECT_EQ(r.lane<6>(), 1);
|
|
EXPECT_EQ(r.lane<7>(), 4);
|
|
}
|
|
|
|
// vint8 tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
/** @brief Test unaligned vint8 data load. */
|
|
TEST(vint8, UnalignedLoad)
|
|
{
|
|
vint8 a(&(s32_data[1]));
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 3);
|
|
EXPECT_EQ(a.lane<3>(), 4);
|
|
EXPECT_EQ(a.lane<4>(), 5);
|
|
EXPECT_EQ(a.lane<5>(), 6);
|
|
EXPECT_EQ(a.lane<6>(), 7);
|
|
EXPECT_EQ(a.lane<7>(), 8);
|
|
}
|
|
|
|
/** @brief Test unaligned vint8 data load. */
|
|
TEST(vint8, UnalignedLoad8)
|
|
{
|
|
vint8 a(&(u8_data[1]));
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 3);
|
|
EXPECT_EQ(a.lane<3>(), 4);
|
|
EXPECT_EQ(a.lane<4>(), 5);
|
|
EXPECT_EQ(a.lane<5>(), 6);
|
|
EXPECT_EQ(a.lane<6>(), 7);
|
|
EXPECT_EQ(a.lane<7>(), 8);
|
|
}
|
|
|
|
/** @brief Test scalar duplicated vint8 load. */
|
|
TEST(vint8, ScalarDupLoad)
|
|
{
|
|
vint8 a(42);
|
|
EXPECT_EQ(a.lane<0>(), 42);
|
|
EXPECT_EQ(a.lane<1>(), 42);
|
|
EXPECT_EQ(a.lane<2>(), 42);
|
|
EXPECT_EQ(a.lane<3>(), 42);
|
|
EXPECT_EQ(a.lane<4>(), 42);
|
|
EXPECT_EQ(a.lane<5>(), 42);
|
|
EXPECT_EQ(a.lane<6>(), 42);
|
|
EXPECT_EQ(a.lane<7>(), 42);
|
|
}
|
|
|
|
/** @brief Test scalar vint8 load. */
|
|
TEST(vint8, ScalarLoad)
|
|
{
|
|
vint8 a(11, 22, 33, 44, 55, 66, 77, 88);
|
|
EXPECT_EQ(a.lane<0>(), 11);
|
|
EXPECT_EQ(a.lane<1>(), 22);
|
|
EXPECT_EQ(a.lane<2>(), 33);
|
|
EXPECT_EQ(a.lane<3>(), 44);
|
|
EXPECT_EQ(a.lane<4>(), 55);
|
|
EXPECT_EQ(a.lane<5>(), 66);
|
|
EXPECT_EQ(a.lane<6>(), 77);
|
|
EXPECT_EQ(a.lane<7>(), 88);
|
|
}
|
|
|
|
/** @brief Test copy vint8 load. */
|
|
TEST(vint8, CopyLoad)
|
|
{
|
|
vint8 s(11, 22, 33, 44, 55, 66, 77, 88);
|
|
vint8 a(s.m);
|
|
EXPECT_EQ(a.lane<0>(), 11);
|
|
EXPECT_EQ(a.lane<1>(), 22);
|
|
EXPECT_EQ(a.lane<2>(), 33);
|
|
EXPECT_EQ(a.lane<3>(), 44);
|
|
EXPECT_EQ(a.lane<4>(), 55);
|
|
EXPECT_EQ(a.lane<5>(), 66);
|
|
EXPECT_EQ(a.lane<6>(), 77);
|
|
EXPECT_EQ(a.lane<7>(), 88);
|
|
}
|
|
|
|
/** @brief Test vint8 zero. */
|
|
TEST(vint8, Zero)
|
|
{
|
|
vint8 a = vint8::zero();
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 0);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), 0);
|
|
EXPECT_EQ(a.lane<4>(), 0);
|
|
EXPECT_EQ(a.lane<5>(), 0);
|
|
EXPECT_EQ(a.lane<6>(), 0);
|
|
EXPECT_EQ(a.lane<7>(), 0);
|
|
}
|
|
|
|
/** @brief Test vint8 load1. */
|
|
TEST(vint8, Load1)
|
|
{
|
|
int s = 42;
|
|
vint8 a = vint8::load1(&s);
|
|
EXPECT_EQ(a.lane<0>(), 42);
|
|
EXPECT_EQ(a.lane<1>(), 42);
|
|
EXPECT_EQ(a.lane<2>(), 42);
|
|
EXPECT_EQ(a.lane<3>(), 42);
|
|
EXPECT_EQ(a.lane<4>(), 42);
|
|
EXPECT_EQ(a.lane<5>(), 42);
|
|
EXPECT_EQ(a.lane<6>(), 42);
|
|
EXPECT_EQ(a.lane<7>(), 42);
|
|
}
|
|
|
|
/** @brief Test vint8 loada. */
|
|
TEST(vint8, Loada)
|
|
{
|
|
vint8 a = vint8::loada(&(s32_data[0]));
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 2);
|
|
EXPECT_EQ(a.lane<3>(), 3);
|
|
EXPECT_EQ(a.lane<4>(), 4);
|
|
EXPECT_EQ(a.lane<5>(), 5);
|
|
EXPECT_EQ(a.lane<6>(), 6);
|
|
EXPECT_EQ(a.lane<7>(), 7);
|
|
}
|
|
|
|
/** @brief Test vint8 lane_id. */
|
|
TEST(vint8, LaneID)
|
|
{
|
|
vint8 a = vint8::lane_id();
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 2);
|
|
EXPECT_EQ(a.lane<3>(), 3);
|
|
EXPECT_EQ(a.lane<4>(), 4);
|
|
EXPECT_EQ(a.lane<5>(), 5);
|
|
EXPECT_EQ(a.lane<6>(), 6);
|
|
EXPECT_EQ(a.lane<7>(), 7);
|
|
}
|
|
|
|
/** @brief Test vint8 add. */
|
|
TEST(vint8, vadd)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b(2, 3, 4, 5, 2, 3, 4, 5);
|
|
a = a + b;
|
|
EXPECT_EQ(a.lane<0>(), 1 + 2);
|
|
EXPECT_EQ(a.lane<1>(), 2 + 3);
|
|
EXPECT_EQ(a.lane<2>(), 3 + 4);
|
|
EXPECT_EQ(a.lane<3>(), 4 + 5);
|
|
EXPECT_EQ(a.lane<4>(), 1 + 2);
|
|
EXPECT_EQ(a.lane<5>(), 2 + 3);
|
|
EXPECT_EQ(a.lane<6>(), 3 + 4);
|
|
EXPECT_EQ(a.lane<7>(), 4 + 5);
|
|
}
|
|
|
|
|
|
/** @brief Test vint8 self-add. */
|
|
TEST(vint8, vselfadd1)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b(2, 3, 4, 5, 2, 3, 4, 5);
|
|
a += b;
|
|
|
|
EXPECT_EQ(a.lane<0>(), 1 + 2);
|
|
EXPECT_EQ(a.lane<1>(), 2 + 3);
|
|
EXPECT_EQ(a.lane<2>(), 3 + 4);
|
|
EXPECT_EQ(a.lane<3>(), 4 + 5);
|
|
EXPECT_EQ(a.lane<4>(), 1 + 2);
|
|
EXPECT_EQ(a.lane<5>(), 2 + 3);
|
|
EXPECT_EQ(a.lane<6>(), 3 + 4);
|
|
EXPECT_EQ(a.lane<7>(), 4 + 5);
|
|
}
|
|
|
|
/** @brief Test vint8 sub. */
|
|
TEST(vint8, vsub)
|
|
{
|
|
vint8 a(1, 2, 4, 4, 1, 2, 4, 4);
|
|
vint8 b(2, 3, 3, 5, 2, 3, 3, 5);
|
|
a = a - b;
|
|
EXPECT_EQ(a.lane<0>(), 1 - 2);
|
|
EXPECT_EQ(a.lane<1>(), 2 - 3);
|
|
EXPECT_EQ(a.lane<2>(), 4 - 3);
|
|
EXPECT_EQ(a.lane<3>(), 4 - 5);
|
|
EXPECT_EQ(a.lane<4>(), 1 - 2);
|
|
EXPECT_EQ(a.lane<5>(), 2 - 3);
|
|
EXPECT_EQ(a.lane<6>(), 4 - 3);
|
|
EXPECT_EQ(a.lane<7>(), 4 - 5);
|
|
}
|
|
|
|
/** @brief Test vint8 mul. */
|
|
TEST(vint8, vmul)
|
|
{
|
|
vint8 a(1, 2, 4, 4, 1, 2, 4, 4);
|
|
vint8 b(2, 3, 3, 5, 2, 3, 3, 5);
|
|
a = a * b;
|
|
EXPECT_EQ(a.lane<0>(), 1 * 2);
|
|
EXPECT_EQ(a.lane<1>(), 2 * 3);
|
|
EXPECT_EQ(a.lane<2>(), 4 * 3);
|
|
EXPECT_EQ(a.lane<3>(), 4 * 5);
|
|
EXPECT_EQ(a.lane<4>(), 1 * 2);
|
|
EXPECT_EQ(a.lane<5>(), 2 * 3);
|
|
EXPECT_EQ(a.lane<6>(), 4 * 3);
|
|
EXPECT_EQ(a.lane<7>(), 4 * 5);
|
|
}
|
|
|
|
/** @brief Test vint8 bitwise invert. */
|
|
TEST(vint8, bit_invert)
|
|
{
|
|
vint8 a(-1, 0, 1, 2, -1, 0, 1, 2);
|
|
a = ~a;
|
|
EXPECT_EQ(a.lane<0>(), ~-1);
|
|
EXPECT_EQ(a.lane<1>(), ~0);
|
|
EXPECT_EQ(a.lane<2>(), ~1);
|
|
EXPECT_EQ(a.lane<3>(), ~2);
|
|
EXPECT_EQ(a.lane<4>(), ~-1);
|
|
EXPECT_EQ(a.lane<5>(), ~0);
|
|
EXPECT_EQ(a.lane<6>(), ~1);
|
|
EXPECT_EQ(a.lane<7>(), ~2);
|
|
}
|
|
|
|
/** @brief Test vint8 bitwise or. */
|
|
TEST(vint8, bit_vor)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b(2, 3, 4, 5, 2, 3, 4, 5);
|
|
a = a | b;
|
|
EXPECT_EQ(a.lane<0>(), 3);
|
|
EXPECT_EQ(a.lane<1>(), 3);
|
|
EXPECT_EQ(a.lane<2>(), 7);
|
|
EXPECT_EQ(a.lane<3>(), 5);
|
|
EXPECT_EQ(a.lane<4>(), 3);
|
|
EXPECT_EQ(a.lane<5>(), 3);
|
|
EXPECT_EQ(a.lane<6>(), 7);
|
|
EXPECT_EQ(a.lane<7>(), 5);
|
|
}
|
|
|
|
/** @brief Test vint8 bitwise and. */
|
|
TEST(vint8, bit_vand)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b(2, 3, 4, 5, 2, 3, 4, 5);
|
|
a = a & b;
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), 4);
|
|
EXPECT_EQ(a.lane<4>(), 0);
|
|
EXPECT_EQ(a.lane<5>(), 2);
|
|
EXPECT_EQ(a.lane<6>(), 0);
|
|
EXPECT_EQ(a.lane<7>(), 4);
|
|
}
|
|
|
|
/** @brief Test vint8 bitwise xor. */
|
|
TEST(vint8, bit_vxor)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b(2, 3, 4, 5, 2, 3, 4, 5);
|
|
a = a ^ b;
|
|
EXPECT_EQ(a.lane<0>(), 3);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 7);
|
|
EXPECT_EQ(a.lane<3>(), 1);
|
|
EXPECT_EQ(a.lane<4>(), 3);
|
|
EXPECT_EQ(a.lane<5>(), 1);
|
|
EXPECT_EQ(a.lane<6>(), 7);
|
|
EXPECT_EQ(a.lane<7>(), 1);
|
|
}
|
|
|
|
/** @brief Test vint8 ceq. */
|
|
TEST(vint8, ceq)
|
|
{
|
|
vint8 a1(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b1(0, 1, 2, 3, 0, 1, 2, 3);
|
|
vmask8 r1 = a1 == b1;
|
|
EXPECT_EQ(0u, mask(r1));
|
|
EXPECT_EQ(false, any(r1));
|
|
EXPECT_EQ(false, all(r1));
|
|
|
|
vint8 a2(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b2(1, 0, 0, 0, 1, 0, 0, 0);
|
|
vmask8 r2 = a2 == b2;
|
|
EXPECT_EQ(0x11u, mask(r2));
|
|
EXPECT_EQ(true, any(r2));
|
|
EXPECT_EQ(false, all(r2));
|
|
|
|
vint8 a3(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b3(1, 0, 3, 0, 1, 0, 3, 0);
|
|
vmask8 r3 = a3 == b3;
|
|
EXPECT_EQ(0x55u, mask(r3));
|
|
EXPECT_EQ(true, any(r3));
|
|
EXPECT_EQ(false, all(r3));
|
|
|
|
vint8 a4(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vmask8 r4 = a4 == a4;
|
|
EXPECT_EQ(0xFFu, mask(r4));
|
|
EXPECT_EQ(true, any(r4));
|
|
EXPECT_EQ(true, all(r4));
|
|
}
|
|
|
|
/** @brief Test vint8 cne. */
|
|
TEST(vint8, cne)
|
|
{
|
|
vint8 a1(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b1(0, 1, 2, 3, 0, 1, 2, 3);
|
|
vmask8 r1 = a1 != b1;
|
|
EXPECT_EQ(0xFFu, mask(r1));
|
|
EXPECT_EQ(true, any(r1));
|
|
EXPECT_EQ(true, all(r1));
|
|
|
|
vint8 a2(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b2(1, 0, 0, 0, 1, 0, 0, 0);
|
|
vmask8 r2 = a2 != b2;
|
|
EXPECT_EQ(0xEEu, mask(r2));
|
|
EXPECT_EQ(true, any(r2));
|
|
EXPECT_EQ(false, all(r2));
|
|
|
|
vint8 a3(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b3(1, 0, 3, 0, 1, 0, 3, 0);
|
|
vmask8 r3 = a3 != b3;
|
|
EXPECT_EQ(0xAAu, mask(r3));
|
|
EXPECT_EQ(true, any(r3));
|
|
EXPECT_EQ(false, all(r3));
|
|
|
|
vint8 a4(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vmask8 r4 = a4 != a4;
|
|
EXPECT_EQ(0u, mask(r4));
|
|
EXPECT_EQ(false, any(r4));
|
|
EXPECT_EQ(false, all(r4));
|
|
}
|
|
|
|
/** @brief Test vint8 clt. */
|
|
TEST(vint8, clt)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b(0, 3, 3, 5, 0, 3, 3, 5);
|
|
vmask8 r = a < b;
|
|
EXPECT_EQ(0xAAu, mask(r));
|
|
}
|
|
|
|
/** @brief Test vint8 cgt. */
|
|
TEST(vint8, cgt)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b(0, 3, 3, 5, 0, 3, 3, 5);
|
|
vmask8 r = a > b;
|
|
EXPECT_EQ(0x11u, mask(r));
|
|
}
|
|
|
|
/** @brief Test vint8 min. */
|
|
TEST(vint8, min)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b(0, 3, 3, 5, 0, 3, 3, 5);
|
|
vint8 r = min(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 0);
|
|
EXPECT_EQ(r.lane<1>(), 2);
|
|
EXPECT_EQ(r.lane<2>(), 3);
|
|
EXPECT_EQ(r.lane<3>(), 4);
|
|
EXPECT_EQ(r.lane<4>(), 0);
|
|
EXPECT_EQ(r.lane<5>(), 2);
|
|
EXPECT_EQ(r.lane<6>(), 3);
|
|
EXPECT_EQ(r.lane<7>(), 4);
|
|
}
|
|
|
|
/** @brief Test vint8 max. */
|
|
TEST(vint8, max)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 1, 2, 3, 4);
|
|
vint8 b(0, 3, 3, 5, 0, 3, 3, 5);
|
|
vint8 r = max(a, b);
|
|
EXPECT_EQ(r.lane<0>(), 1);
|
|
EXPECT_EQ(r.lane<1>(), 3);
|
|
EXPECT_EQ(r.lane<2>(), 3);
|
|
EXPECT_EQ(r.lane<3>(), 5);
|
|
EXPECT_EQ(r.lane<4>(), 1);
|
|
EXPECT_EQ(r.lane<5>(), 3);
|
|
EXPECT_EQ(r.lane<6>(), 3);
|
|
EXPECT_EQ(r.lane<7>(), 5);
|
|
}
|
|
|
|
/** @brief Test vint8 lsl. */
|
|
TEST(vint8, lsl)
|
|
{
|
|
vint8 a(1, 2, 4, -4, 1, 2, 4, -4);
|
|
a = lsl<0>(a);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 4);
|
|
EXPECT_EQ(a.lane<3>(), static_cast<int>(0xFFFFFFFC));
|
|
EXPECT_EQ(a.lane<4>(), 1);
|
|
EXPECT_EQ(a.lane<5>(), 2);
|
|
EXPECT_EQ(a.lane<6>(), 4);
|
|
EXPECT_EQ(a.lane<7>(), static_cast<int>(0xFFFFFFFC));
|
|
|
|
|
|
a = lsl<1>(a);
|
|
EXPECT_EQ(a.lane<0>(), 2);
|
|
EXPECT_EQ(a.lane<1>(), 4);
|
|
EXPECT_EQ(a.lane<2>(), 8);
|
|
EXPECT_EQ(a.lane<3>(), static_cast<int>(0xFFFFFFF8));
|
|
EXPECT_EQ(a.lane<4>(), 2);
|
|
EXPECT_EQ(a.lane<5>(), 4);
|
|
EXPECT_EQ(a.lane<6>(), 8);
|
|
EXPECT_EQ(a.lane<7>(), static_cast<int>(0xFFFFFFF8));
|
|
|
|
a = lsl<2>(a);
|
|
EXPECT_EQ(a.lane<0>(), 8);
|
|
EXPECT_EQ(a.lane<1>(), 16);
|
|
EXPECT_EQ(a.lane<2>(), 32);
|
|
EXPECT_EQ(a.lane<3>(), static_cast<int>(0xFFFFFFE0));
|
|
EXPECT_EQ(a.lane<4>(), 8);
|
|
EXPECT_EQ(a.lane<5>(), 16);
|
|
EXPECT_EQ(a.lane<6>(), 32);
|
|
EXPECT_EQ(a.lane<7>(), static_cast<int>(0xFFFFFFE0));
|
|
}
|
|
|
|
/** @brief Test vint8 lsr. */
|
|
TEST(vint8, lsr)
|
|
{
|
|
vint8 a(1, 2, 4, -4, 1, 2, 4, -4);
|
|
a = lsr<0>(a);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 4);
|
|
EXPECT_EQ(a.lane<3>(), static_cast<int>(0xFFFFFFFC));
|
|
EXPECT_EQ(a.lane<4>(), 1);
|
|
EXPECT_EQ(a.lane<5>(), 2);
|
|
EXPECT_EQ(a.lane<6>(), 4);
|
|
EXPECT_EQ(a.lane<7>(), static_cast<int>(0xFFFFFFFC));
|
|
|
|
|
|
a = lsr<1>(a);
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 2);
|
|
EXPECT_EQ(a.lane<3>(), 0x7FFFFFFE);
|
|
EXPECT_EQ(a.lane<4>(), 0);
|
|
EXPECT_EQ(a.lane<5>(), 1);
|
|
EXPECT_EQ(a.lane<6>(), 2);
|
|
EXPECT_EQ(a.lane<7>(), 0x7FFFFFFE);
|
|
|
|
a = lsr<2>(a);
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 0);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), 0x1FFFFFFF);
|
|
EXPECT_EQ(a.lane<4>(), 0);
|
|
EXPECT_EQ(a.lane<5>(), 0);
|
|
EXPECT_EQ(a.lane<6>(), 0);
|
|
EXPECT_EQ(a.lane<7>(), 0x1FFFFFFF);
|
|
}
|
|
|
|
/** @brief Test vint8 asr. */
|
|
TEST(vint8, asr)
|
|
{
|
|
vint8 a(1, 2, 4, -4, 1, 2, 4, -4);
|
|
a = asr<0>(a);
|
|
EXPECT_EQ(a.lane<0>(), 1);
|
|
EXPECT_EQ(a.lane<1>(), 2);
|
|
EXPECT_EQ(a.lane<2>(), 4);
|
|
EXPECT_EQ(a.lane<3>(), -4);
|
|
EXPECT_EQ(a.lane<4>(), 1);
|
|
EXPECT_EQ(a.lane<5>(), 2);
|
|
EXPECT_EQ(a.lane<6>(), 4);
|
|
EXPECT_EQ(a.lane<7>(), -4);
|
|
|
|
a = asr<1>(a);
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 1);
|
|
EXPECT_EQ(a.lane<2>(), 2);
|
|
EXPECT_EQ(a.lane<3>(), -2);
|
|
EXPECT_EQ(a.lane<4>(), 0);
|
|
EXPECT_EQ(a.lane<5>(), 1);
|
|
EXPECT_EQ(a.lane<6>(), 2);
|
|
EXPECT_EQ(a.lane<7>(), -2);
|
|
|
|
// Note - quirk of asr is that you will get "stuck" at -1
|
|
a = asr<2>(a);
|
|
EXPECT_EQ(a.lane<0>(), 0);
|
|
EXPECT_EQ(a.lane<1>(), 0);
|
|
EXPECT_EQ(a.lane<2>(), 0);
|
|
EXPECT_EQ(a.lane<3>(), -1);
|
|
EXPECT_EQ(a.lane<4>(), 0);
|
|
EXPECT_EQ(a.lane<5>(), 0);
|
|
EXPECT_EQ(a.lane<6>(), 0);
|
|
EXPECT_EQ(a.lane<7>(), -1);
|
|
}
|
|
|
|
/** @brief Test vint8 hmin. */
|
|
TEST(vint8, hmin)
|
|
{
|
|
vint8 a1(1, 2, 1, 2, 1, 2, 1, 2);
|
|
vint8 r1 = hmin(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 1);
|
|
EXPECT_EQ(r1.lane<1>(), 1);
|
|
EXPECT_EQ(r1.lane<2>(), 1);
|
|
EXPECT_EQ(r1.lane<3>(), 1);
|
|
EXPECT_EQ(r1.lane<4>(), 1);
|
|
EXPECT_EQ(r1.lane<5>(), 1);
|
|
EXPECT_EQ(r1.lane<6>(), 1);
|
|
EXPECT_EQ(r1.lane<7>(), 1);
|
|
|
|
vint8 a2(1, 2, -1, 5, 1, 2, -1, 5);
|
|
vint8 r2 = hmin(a2);
|
|
EXPECT_EQ(r2.lane<0>(), -1);
|
|
EXPECT_EQ(r2.lane<1>(), -1);
|
|
EXPECT_EQ(r2.lane<2>(), -1);
|
|
EXPECT_EQ(r2.lane<3>(), -1);
|
|
EXPECT_EQ(r2.lane<4>(), -1);
|
|
EXPECT_EQ(r2.lane<5>(), -1);
|
|
EXPECT_EQ(r2.lane<6>(), -1);
|
|
EXPECT_EQ(r2.lane<7>(), -1);
|
|
}
|
|
|
|
/** @brief Test vint8 hmax. */
|
|
TEST(vint8, hmax)
|
|
{
|
|
vint8 a1(1, 2, 1, 2, 1, 3, 1, 2);
|
|
vint8 r1 = hmax(a1);
|
|
EXPECT_EQ(r1.lane<0>(), 3);
|
|
EXPECT_EQ(r1.lane<1>(), 3);
|
|
EXPECT_EQ(r1.lane<2>(), 3);
|
|
EXPECT_EQ(r1.lane<3>(), 3);
|
|
EXPECT_EQ(r1.lane<4>(), 3);
|
|
EXPECT_EQ(r1.lane<5>(), 3);
|
|
EXPECT_EQ(r1.lane<6>(), 3);
|
|
EXPECT_EQ(r1.lane<7>(), 3);
|
|
|
|
vint8 a2(1, 2, -1, 5, 1, 2, -1, 5);
|
|
vint8 r2 = hmax(a2);
|
|
EXPECT_EQ(r2.lane<0>(), 5);
|
|
EXPECT_EQ(r2.lane<1>(), 5);
|
|
EXPECT_EQ(r2.lane<2>(), 5);
|
|
EXPECT_EQ(r2.lane<3>(), 5);
|
|
EXPECT_EQ(r2.lane<4>(), 5);
|
|
EXPECT_EQ(r2.lane<5>(), 5);
|
|
EXPECT_EQ(r2.lane<6>(), 5);
|
|
EXPECT_EQ(r2.lane<7>(), 5);
|
|
}
|
|
|
|
/** @brief Test vint8 storea. */
|
|
TEST(vint8, storea)
|
|
{
|
|
alignas(32) int out[8];
|
|
vint8 a(s32_data);
|
|
storea(a, out);
|
|
EXPECT_EQ(out[0], 0);
|
|
EXPECT_EQ(out[1], 1);
|
|
EXPECT_EQ(out[2], 2);
|
|
EXPECT_EQ(out[3], 3);
|
|
EXPECT_EQ(out[4], 4);
|
|
EXPECT_EQ(out[5], 5);
|
|
EXPECT_EQ(out[6], 6);
|
|
EXPECT_EQ(out[7], 7);
|
|
}
|
|
|
|
/** @brief Test vint8 store. */
|
|
TEST(vint8, store)
|
|
{
|
|
alignas(32) int out[9];
|
|
vint8 a(s32_data);
|
|
store(a, out + 1);
|
|
EXPECT_EQ(out[1], 0);
|
|
EXPECT_EQ(out[2], 1);
|
|
EXPECT_EQ(out[3], 2);
|
|
EXPECT_EQ(out[4], 3);
|
|
EXPECT_EQ(out[5], 4);
|
|
EXPECT_EQ(out[6], 5);
|
|
EXPECT_EQ(out[7], 6);
|
|
EXPECT_EQ(out[8], 7);
|
|
}
|
|
|
|
/** @brief Test vint8 store_nbytes. */
|
|
TEST(vint8, store_nbytes)
|
|
{
|
|
alignas(32) int out[2];
|
|
vint8 a(42, 314, 75, 90, 42, 314, 75, 90);
|
|
store_nbytes(a, reinterpret_cast<uint8_t*>(&out));
|
|
EXPECT_EQ(out[0], 42);
|
|
EXPECT_EQ(out[1], 314);
|
|
}
|
|
|
|
/** @brief Test vint8 store_lanes_masked. */
|
|
TEST(vint8, store_lanes_masked)
|
|
{
|
|
int resulta[8] { 0 };
|
|
|
|
// Store nothing
|
|
vmask8 mask1 = vint8(0) == vint8(1);
|
|
vint8 data1 = vint8(1);
|
|
|
|
store_lanes_masked(resulta, data1, mask1);
|
|
vint8 result1v(resulta);
|
|
vint8 expect1v = vint8::zero();
|
|
EXPECT_TRUE(all(result1v == expect1v));
|
|
|
|
// Store half
|
|
vmask8 mask2 = vint8(1, 1, 1, 1, 0, 0, 0, 0) == vint8(1);
|
|
vint8 data2 = vint8(2);
|
|
|
|
store_lanes_masked(resulta, data2, mask2);
|
|
vint8 result2v(resulta);
|
|
vint8 expect2v = vint8(2, 2, 2, 2, 0, 0, 0, 0);
|
|
EXPECT_TRUE(all(result2v == expect2v));
|
|
|
|
// Store all
|
|
vmask8 mask3 = vint8(1) == vint8(1);
|
|
vint8 data3 = vint8(3);
|
|
|
|
store_lanes_masked(resulta, data3, mask3);
|
|
vint8 result3v(resulta);
|
|
vint8 expect3v = vint8(3);
|
|
EXPECT_TRUE(all(result3v == expect3v));
|
|
}
|
|
|
|
/** @brief Test vint8 store_lanes_masked to unaligned address. */
|
|
TEST(vint8, store_lanes_masked_unaligned)
|
|
{
|
|
int8_t resulta[33] { 0 };
|
|
|
|
// Store nothing
|
|
vmask8 mask1 = vint8(0) == vint8(1);
|
|
vint8 data1 = vint8(1);
|
|
|
|
store_lanes_masked(reinterpret_cast<int*>(resulta + 1), data1, mask1);
|
|
vint8 result1v(reinterpret_cast<int*>(resulta + 1));
|
|
vint8 expect1v = vint8::zero();
|
|
EXPECT_TRUE(all(result1v == expect1v));
|
|
|
|
// Store half
|
|
vmask8 mask2 = vint8(1, 1, 1, 1, 0, 0, 0, 0) == vint8(1);
|
|
vint8 data2 = vint8(2);
|
|
|
|
store_lanes_masked(reinterpret_cast<int*>(resulta + 1), data2, mask2);
|
|
vint8 result2v(reinterpret_cast<int*>(resulta + 1));
|
|
vint8 expect2v = vint8(2, 2, 2, 2, 0, 0, 0, 0);
|
|
EXPECT_TRUE(all(result2v == expect2v));
|
|
|
|
// Store all
|
|
vmask8 mask3 = vint8(1) == vint8(1);
|
|
vint8 data3 = vint8(3);
|
|
|
|
store_lanes_masked(reinterpret_cast<int*>(resulta + 1), data3, mask3);
|
|
vint8 result3v(reinterpret_cast<int*>(resulta + 1));
|
|
vint8 expect3v = vint8(3);
|
|
EXPECT_TRUE(all(result3v == expect3v));
|
|
}
|
|
|
|
/** @brief Test vint8 gatheri. */
|
|
TEST(vint8, gatheri)
|
|
{
|
|
vint8 indices(0, 4, 3, 2, 7, 4, 3, 2);
|
|
vint8 r = gatheri(s32_data, indices);
|
|
EXPECT_EQ(r.lane<0>(), 0);
|
|
EXPECT_EQ(r.lane<1>(), 4);
|
|
EXPECT_EQ(r.lane<2>(), 3);
|
|
EXPECT_EQ(r.lane<3>(), 2);
|
|
EXPECT_EQ(r.lane<4>(), 7);
|
|
EXPECT_EQ(r.lane<5>(), 4);
|
|
EXPECT_EQ(r.lane<6>(), 3);
|
|
EXPECT_EQ(r.lane<7>(), 2);
|
|
}
|
|
|
|
/** @brief Test vint8 pack_low_bytes. */
|
|
TEST(vint8, pack_low_bytes)
|
|
{
|
|
vint8 a(1, 2, 3, 4, 2, 3, 4, 5);
|
|
vint8 r = pack_low_bytes(a);
|
|
EXPECT_EQ(r.lane<0>(), (4 << 24) | (3 << 16) | (2 << 8) | (1 << 0));
|
|
EXPECT_EQ(r.lane<1>(), (5 << 24) | (4 << 16) | (3 << 8) | (2 << 0));
|
|
}
|
|
|
|
/** @brief Test vint8 select. */
|
|
TEST(vint8, select)
|
|
{
|
|
vint8 m1(1, 1, 1, 1, 1, 1, 1, 1);
|
|
vint8 m2(1, 2, 1, 2, 1, 2, 1, 2);
|
|
vmask8 cond = m1 == m2;
|
|
|
|
vint8 a(1, 3, 3, 1, 1, 3, 3, 1);
|
|
vint8 b(4, 2, 2, 4, 4, 2, 2, 4);
|
|
|
|
vint8 r1 = select(a, b, cond);
|
|
EXPECT_EQ(r1.lane<0>(), 4);
|
|
EXPECT_EQ(r1.lane<1>(), 3);
|
|
EXPECT_EQ(r1.lane<2>(), 2);
|
|
EXPECT_EQ(r1.lane<3>(), 1);
|
|
EXPECT_EQ(r1.lane<4>(), 4);
|
|
EXPECT_EQ(r1.lane<5>(), 3);
|
|
EXPECT_EQ(r1.lane<6>(), 2);
|
|
EXPECT_EQ(r1.lane<7>(), 1);
|
|
|
|
vint8 r2 = select(b, a, cond);
|
|
EXPECT_EQ(r2.lane<0>(), 1);
|
|
EXPECT_EQ(r2.lane<1>(), 2);
|
|
EXPECT_EQ(r2.lane<2>(), 3);
|
|
EXPECT_EQ(r2.lane<3>(), 4);
|
|
EXPECT_EQ(r2.lane<4>(), 1);
|
|
EXPECT_EQ(r2.lane<5>(), 2);
|
|
EXPECT_EQ(r2.lane<6>(), 3);
|
|
EXPECT_EQ(r2.lane<7>(), 4);
|
|
}
|
|
|
|
// vmask8 tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
/** @brief Test vmask8 scalar literal constructor. */
|
|
TEST(vmask8, scalar_literal_construct)
|
|
{
|
|
vfloat8 ma(0.0f);
|
|
vfloat8 mb(1.0f);
|
|
|
|
vmask8 m1(true);
|
|
vfloat8 r1 = select(ma, mb, m1);
|
|
vmask8 rm1 = r1 == mb;
|
|
EXPECT_EQ(all(rm1), true);
|
|
|
|
vmask8 m2(false);
|
|
vfloat8 r2 = select(ma, mb, m2);
|
|
vmask8 rm2 = r2 == mb;
|
|
EXPECT_EQ(any(rm2), false);
|
|
}
|
|
|
|
/** @brief Test vmask8 or. */
|
|
TEST(vmask8, or)
|
|
{
|
|
vfloat8 m1a(0, 1, 0, 1, 0, 1, 0, 1);
|
|
vfloat8 m1b(1, 1, 1, 1, 1, 1, 1, 1);
|
|
vmask8 m1 = m1a == m1b;
|
|
|
|
vfloat8 m2a(1, 1, 0, 0, 1, 1, 0, 0);
|
|
vfloat8 m2b(1, 1, 1, 1, 1, 1, 1, 1);
|
|
vmask8 m2 = m2a == m2b;
|
|
|
|
vmask8 r = m1 | m2;
|
|
EXPECT_EQ(mask(r), 0xBBu);
|
|
}
|
|
|
|
/** @brief Test vmask8 and. */
|
|
TEST(vmask8, and)
|
|
{
|
|
vfloat8 m1a(0, 1, 0, 1, 0, 1, 0, 1);
|
|
vfloat8 m1b(1, 1, 1, 1, 1, 1, 1, 1);
|
|
vmask8 m1 = m1a == m1b;
|
|
|
|
vfloat8 m2a(1, 1, 0, 0, 1, 1, 0, 0);
|
|
vfloat8 m2b(1, 1, 1, 1, 1, 1, 1, 1);
|
|
vmask8 m2 = m2a == m2b;
|
|
|
|
vmask8 r = m1 & m2;
|
|
EXPECT_EQ(mask(r), 0x22u);
|
|
}
|
|
|
|
/** @brief Test vmask8 xor. */
|
|
TEST(vmask8, xor)
|
|
{
|
|
vfloat8 m1a(0, 1, 0, 1, 0, 1, 0, 1);
|
|
vfloat8 m1b(1, 1, 1, 1, 1, 1, 1, 1);
|
|
vmask8 m1 = m1a == m1b;
|
|
|
|
vfloat8 m2a(1, 1, 0, 0, 1, 1, 0, 0);
|
|
vfloat8 m2b(1, 1, 1, 1, 1, 1, 1, 1);
|
|
vmask8 m2 = m2a == m2b;
|
|
|
|
vmask8 r = m1 ^ m2;
|
|
EXPECT_EQ(mask(r), 0x99u);
|
|
}
|
|
|
|
/** @brief Test vmask8 not. */
|
|
TEST(vmask8, not)
|
|
{
|
|
vfloat8 m1a(0, 1, 0, 1, 0, 1, 0, 1);
|
|
vfloat8 m1b(1, 1, 1, 1, 1, 1, 1, 1);
|
|
vmask8 m1 = m1a == m1b;
|
|
vmask8 r = ~m1;
|
|
EXPECT_EQ(mask(r), 0x55u);
|
|
}
|
|
|
|
/** @brief Test vint8 table permute. */
|
|
TEST(vint8, vtable_8bt_32bi_32entry)
|
|
{
|
|
vint4 table0(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f);
|
|
vint4 table1(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f);
|
|
|
|
vint8 table0p, table1p;
|
|
vtable_prepare(table0, table1, table0p, table1p);
|
|
|
|
vint8 index(0, 7, 4, 15, 16, 20, 23, 31);
|
|
|
|
vint8 result = vtable_8bt_32bi(table0p, table1p, index);
|
|
|
|
EXPECT_EQ(result.lane<0>(), 3);
|
|
EXPECT_EQ(result.lane<1>(), 4);
|
|
EXPECT_EQ(result.lane<2>(), 7);
|
|
EXPECT_EQ(result.lane<3>(), 12);
|
|
EXPECT_EQ(result.lane<4>(), 19);
|
|
EXPECT_EQ(result.lane<5>(), 23);
|
|
EXPECT_EQ(result.lane<6>(), 20);
|
|
EXPECT_EQ(result.lane<7>(), 28);
|
|
}
|
|
|
|
/** @brief Test vint4 table permute. */
|
|
TEST(vint8, vtable_8bt_32bi_64entry)
|
|
{
|
|
vint4 table0(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f);
|
|
vint4 table1(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f);
|
|
vint4 table2(0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f);
|
|
vint4 table3(0x30313233, 0x34353637, 0x38393a3b, 0x3c3d3e3f);
|
|
|
|
vint8 table0p, table1p, table2p, table3p;
|
|
vtable_prepare(table0, table1, table2, table3, table0p, table1p, table2p, table3p);
|
|
|
|
vint8 index(0, 7, 4, 15, 16, 20, 38, 63);
|
|
|
|
vint8 result = vtable_8bt_32bi(table0p, table1p, table2p, table3p, index);
|
|
|
|
EXPECT_EQ(result.lane<0>(), 3);
|
|
EXPECT_EQ(result.lane<1>(), 4);
|
|
EXPECT_EQ(result.lane<2>(), 7);
|
|
EXPECT_EQ(result.lane<3>(), 12);
|
|
EXPECT_EQ(result.lane<4>(), 19);
|
|
EXPECT_EQ(result.lane<5>(), 23);
|
|
EXPECT_EQ(result.lane<6>(), 37);
|
|
EXPECT_EQ(result.lane<7>(), 60);
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|