Update googletest to 1.18.0 and SIMDe to 0.8.2.
Googletest 1.18 asks for CMake 3.13 or newer, so configuring the tests no longer warns that CMake compatibility below 3.10 is deprecated. Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
parent
e4e666f459
commit
3f10e05176
912 changed files with 224964 additions and 11502 deletions
305
thirdparty/simde/test/test.h
vendored
305
thirdparty/simde/test/test.h
vendored
|
|
@ -1,8 +1,10 @@
|
|||
#if !defined(SIMDE_TESTS_H)
|
||||
#define SIMDE_TESTS_H
|
||||
|
||||
#include "../simde/hedley.h"
|
||||
#include "../simde/simde-common.h"
|
||||
#include "../simde/simde-f16.h"
|
||||
#include "../simde/simde-bf16.h"
|
||||
|
||||
#include <time.h>
|
||||
#include <stdlib.h>
|
||||
|
|
@ -17,19 +19,33 @@ typedef enum SimdeTestVecPos {
|
|||
SIMDE_TEST_VEC_POS_LAST = -1
|
||||
} SimdeTestVecPos;
|
||||
|
||||
HEDLEY_DIAGNOSTIC_PUSH
|
||||
SIMDE_DIAGNOSTIC_DISABLE_VLA_
|
||||
HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
|
||||
|
||||
/* all tests benefit from these */
|
||||
SIMDE_DIAGNOSTIC_DISABLE_PADDED_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_VLA_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_DISABLED_MACRO_EXPANSION_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_BUGGY_CASTS_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_RESERVED_ID_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_C99_EXTENSIONS_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_USED_BUT_MARKED_UNUSED_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_NO_EMMS_INSTRUCTION_
|
||||
#if defined(HEDLEY_MSVC_VERSION)
|
||||
__pragma(warning(disable:4730)) // mixing _m64 and floating point expressions may result in incorrect code
|
||||
#endif
|
||||
|
||||
#if defined(HEDLEY_GCC_VERSION) && !(HEDLEY_GCC_VERSION_CHECK(6,0,0))
|
||||
HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
|
||||
#endif
|
||||
|
||||
HEDLEY_DIAGNOSTIC_PUSH
|
||||
HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
|
||||
SIMDE_DIAGNOSTIC_DISABLE_ZERO_AS_NULL_POINTER_CONSTANT_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_CAST_FUNCTION_TYPE_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_NON_CONSTANT_AGGREGATE_INITIALIZER_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_C99_EXTENSIONS_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_DECLARATION_AFTER_STATEMENT_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_NO_EMMS_INSTRUCTION_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_ANNEX_K_
|
||||
SIMDE_DIAGNOSTIC_DISABLE_DISABLED_MACRO_EXPANSION_
|
||||
|
||||
#if \
|
||||
HEDLEY_HAS_BUILTIN(__builtin_abort) || \
|
||||
|
|
@ -116,9 +132,9 @@ simde_test_codegen_snprintf_(char* str, size_t size, const char* format, ...) {
|
|||
static void
|
||||
simde_test_codegen_f16(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], simde_float16 value) {
|
||||
simde_float32 valuef = simde_float16_to_float32(value);
|
||||
if (simde_math_isnanf(valuef)) {
|
||||
if (simde_isnanhf(value)) {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, " SIMDE_NANHF");
|
||||
} else if (simde_math_isinf(valuef)) {
|
||||
} else if (simde_isinfhf(value)) {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, "%5cSIMDE_INFINITYHF", valuef < 0 ? '-' : ' ');
|
||||
} else {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, "SIMDE_FLOAT16_VALUE(%9.2f)", HEDLEY_STATIC_CAST(double, valuef));
|
||||
|
|
@ -147,6 +163,18 @@ simde_test_codegen_f64(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], si
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
simde_test_codegen_bf16(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], simde_bfloat16 value) {
|
||||
simde_float32 valuef = simde_bfloat16_to_float32(value);
|
||||
if (simde_isnanbf(value)) {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, " SIMDE_NANBF");
|
||||
} else if (simde_isinfbf(value)) {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, "%5cSIMDE_INFINITYBF", valuef < 0 ? '-' : ' ');
|
||||
} else {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, "SIMDE_BFLOAT16_VALUE(%9.2f)", HEDLEY_STATIC_CAST(double, valuef));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
simde_test_codegen_i8(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], int8_t value) {
|
||||
if (value == INT8_MIN) {
|
||||
|
|
@ -227,6 +255,36 @@ simde_test_codegen_u64(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], ui
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
simde_test_codegen_p8(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], simde_poly8 value) {
|
||||
uint8_t value_ = HEDLEY_STATIC_CAST(uint8_t, value);
|
||||
if (value_ == UINT8_MAX) {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, " SIMDE_POLY8_C(UINT8_MAX)");
|
||||
} else {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, "SIMDE_POLY8_C(%3" PRIu8 ")", value_);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
simde_test_codegen_p16(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], simde_poly16 value) {
|
||||
uint16_t value_ = HEDLEY_STATIC_CAST(uint16_t, value);
|
||||
if (value_ == UINT16_MAX) {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, "%15s", "SIMDE_POLY16_C(UINT16_MAX)");
|
||||
} else {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, "SIMDE_POLY16_C(%5" PRIu16 ")", value_);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
simde_test_codegen_p64(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], simde_poly64 value) {
|
||||
uint64_t value_ = HEDLEY_STATIC_CAST(uint64_t, value);
|
||||
if (value_ == UINT64_MAX) {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, "%30s", "SIMDE_POLY64_C(UINT64_MAX)");
|
||||
} else {
|
||||
simde_test_codegen_snprintf_(buf, buf_len, "SIMDE_POLY64_C(%20" PRIu64 ")", value_);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
simde_test_codegen_write_indent(int indent) {
|
||||
for (int i = 0 ; i < indent ; i++) {
|
||||
|
|
@ -293,6 +351,17 @@ simde_test_codegen_random_f64(simde_float64 min, simde_float64 max) {
|
|||
return simde_math_round(v * SIMDE_FLOAT64_C(100.0)) / SIMDE_FLOAT64_C(100.0);
|
||||
}
|
||||
|
||||
static simde_bfloat16
|
||||
simde_test_codegen_random_bf16(simde_bfloat16 min, simde_bfloat16 max) {
|
||||
return
|
||||
simde_bfloat16_from_float32(
|
||||
simde_test_codegen_random_f32(
|
||||
simde_bfloat16_to_float32(min),
|
||||
simde_bfloat16_to_float32(max)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
typedef enum SimdeTestVecFloatMask {
|
||||
SIMDE_TEST_VEC_FLOAT_DEFAULT = 0,
|
||||
SIMDE_TEST_VEC_FLOAT_PAIR = 1,
|
||||
|
|
@ -426,6 +495,19 @@ simde_test_codegen_random_vf64_full(
|
|||
vec_type);
|
||||
}
|
||||
|
||||
static void
|
||||
simde_test_codegen_random_vbf16_full(
|
||||
size_t test_sets, size_t vectors_per_set, size_t elements_per_vector,
|
||||
simde_bfloat16 values[HEDLEY_ARRAY_PARAM(test_sets * vectors_per_set * elements_per_vector)],
|
||||
simde_bfloat16 min, simde_bfloat16 max,
|
||||
SimdeTestVecFloatType vec_type) {
|
||||
simde_test_codegen_random_vfX_full_(test_sets, vectors_per_set, elements_per_vector,
|
||||
sizeof(simde_bfloat16), values,
|
||||
HEDLEY_STATIC_CAST(simde_float64, simde_bfloat16_to_float32(min)),
|
||||
HEDLEY_STATIC_CAST(simde_float64, simde_bfloat16_to_float32(max)),
|
||||
vec_type);
|
||||
}
|
||||
|
||||
static void
|
||||
simde_test_codegen_random_vf16(size_t elem_count, simde_float16 values[HEDLEY_ARRAY_PARAM(elem_count)], simde_float16 min, simde_float16 max) {
|
||||
for (size_t i = 0 ; i < elem_count ; i++) {
|
||||
|
|
@ -447,6 +529,13 @@ simde_test_codegen_random_vf64(size_t elem_count, simde_float64 values[HEDLEY_AR
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
simde_test_codegen_random_vbf16(size_t elem_count, simde_bfloat16 values[HEDLEY_ARRAY_PARAM(elem_count)], simde_bfloat16 min, simde_bfloat16 max) {
|
||||
for (size_t i = 0 ; i < elem_count ; i++) {
|
||||
values[i] = simde_test_codegen_random_bf16(min, max);
|
||||
}
|
||||
}
|
||||
|
||||
#define SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(T, symbol_identifier) \
|
||||
static T simde_test_codegen_random_##symbol_identifier(void) { \
|
||||
T r; \
|
||||
|
|
@ -462,6 +551,9 @@ SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(uint8_t, u8)
|
|||
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(uint16_t, u16)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(uint32_t, u32)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(uint64_t, u64)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(simde_poly8, p8)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(simde_poly16, p16)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(simde_poly64, p64)
|
||||
|
||||
#define SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(T, symbol_identifier, elements_per_line) \
|
||||
static void \
|
||||
|
|
@ -526,6 +618,7 @@ SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(uint64_t, u64)
|
|||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(simde_float16, f16, 4)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(simde_float32, f32, 4)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(simde_float64, f64, 4)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(simde_bfloat16, bf16, 4)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(int8_t, i8, 8)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(int16_t, i16, 8)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(int32_t, i32, 8)
|
||||
|
|
@ -534,6 +627,9 @@ SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(uint8_t, u8, 8)
|
|||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(uint16_t, u16, 8)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(uint32_t, u32, 8)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(uint64_t, u64, 4)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(simde_poly8, p8, 8)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(simde_poly16, p16, 8)
|
||||
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(simde_poly64, p64, 4)
|
||||
|
||||
#define simde_test_codegen_write_1vi8(indent, elem_count, values) simde_test_codegen_write_vi8_full( (indent), (elem_count), #values, (values), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1vi16(indent, elem_count, values) simde_test_codegen_write_vi16_full((indent), (elem_count), #values, (values), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
|
|
@ -546,6 +642,10 @@ SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(uint64_t, u64, 4)
|
|||
#define simde_test_codegen_write_1vf16(indent, elem_count, values) simde_test_codegen_write_vf16_full((indent), (elem_count), #values, (values), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1vf32(indent, elem_count, values) simde_test_codegen_write_vf32_full((indent), (elem_count), #values, (values), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1vf64(indent, elem_count, values) simde_test_codegen_write_vf64_full((indent), (elem_count), #values, (values), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1vp8(indent, elem_count, values) simde_test_codegen_write_vp8_full( (indent), (elem_count), #values, (values), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1vp16(indent, elem_count, values) simde_test_codegen_write_vp16_full((indent), (elem_count), #values, (values), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1vp64(indent, elem_count, values) simde_test_codegen_write_vp64_full((indent), (elem_count), #values, (values), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1vbf16(indent, elem_count, values) simde_test_codegen_write_vbf16_full((indent), (elem_count), #values, (values), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
|
||||
#define SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(T, symbol_identifier) \
|
||||
static void \
|
||||
|
|
@ -605,6 +705,10 @@ SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(uint64_t, u64)
|
|||
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_float16, f16)
|
||||
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_float32, f32)
|
||||
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_float64, f64)
|
||||
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_poly8, p8)
|
||||
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_poly16, p16)
|
||||
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_poly64, p64)
|
||||
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_bfloat16, bf16)
|
||||
|
||||
#define simde_test_codegen_write_1i8(indent, value) simde_test_codegen_write_i8_full((indent), #value, (value), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1i16(indent, value) simde_test_codegen_write_i16_full((indent), #value, (value), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
|
|
@ -617,6 +721,10 @@ SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_float64, f64)
|
|||
#define simde_test_codegen_write_1f16(indent, value) simde_test_codegen_write_f16_full((indent), #value, (value), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1f32(indent, value) simde_test_codegen_write_f32_full((indent), #value, (value), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1f64(indent, value) simde_test_codegen_write_f64_full((indent), #value, (value), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1p8(indent, value) simde_test_codegen_write_p8_full((indent), #value, (value), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1p16(indent, value) simde_test_codegen_write_p16_full((indent), #value, (value), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1p64(indent, value) simde_test_codegen_write_p64_full((indent), #value, (value), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
#define simde_test_codegen_write_1bf16(indent, value) simde_test_codegen_write_bf16_full((indent), #value, (value), SIMDE_TEST_VEC_POS_SINGLE)
|
||||
|
||||
HEDLEY_DIAGNOSTIC_PUSH
|
||||
SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL_
|
||||
|
|
@ -628,7 +736,7 @@ simde_test_equal_f32(simde_float32 a, simde_float32 b, simde_float32 slop) {
|
|||
} else if (simde_math_isinf(a)) {
|
||||
return !((a < b) || (a > b));
|
||||
} else if (slop == SIMDE_FLOAT32_C(0.0)) {
|
||||
return a == b;
|
||||
return !simde_memcmp(&a, &b, sizeof(simde_float32));
|
||||
} else {
|
||||
simde_float32 lo = a - slop;
|
||||
if (HEDLEY_UNLIKELY(lo == a))
|
||||
|
|
@ -658,7 +766,7 @@ simde_test_equal_f64(simde_float64 a, simde_float64 b, simde_float64 slop) {
|
|||
} else if (simde_math_isinf(a)) {
|
||||
return !((a < b) || (a > b));
|
||||
} else if (slop == SIMDE_FLOAT64_C(0.0)) {
|
||||
return a == b;
|
||||
return !simde_memcmp(&a, &b, sizeof(simde_float64));
|
||||
} else {
|
||||
simde_float64 lo = a - slop;
|
||||
if (HEDLEY_UNLIKELY(lo == a))
|
||||
|
|
@ -672,6 +780,15 @@ simde_test_equal_f64(simde_float64 a, simde_float64 b, simde_float64 slop) {
|
|||
}
|
||||
}
|
||||
|
||||
static int
|
||||
simde_test_equal_bf16(simde_bfloat16 a, simde_bfloat16 b, simde_bfloat16 slop) {
|
||||
simde_float32
|
||||
af = simde_bfloat16_to_float32(a),
|
||||
bf = simde_bfloat16_to_float32(b),
|
||||
slopf = simde_bfloat16_to_float32(slop);
|
||||
return simde_test_equal_f32(af, bf, slopf);
|
||||
}
|
||||
|
||||
HEDLEY_DIAGNOSTIC_POP
|
||||
|
||||
static simde_float16
|
||||
|
|
@ -689,6 +806,11 @@ simde_test_f64_precision_to_slop(int precision) {
|
|||
return HEDLEY_UNLIKELY(precision == INT_MAX) ? SIMDE_FLOAT64_C(0.0) : simde_math_pow(SIMDE_FLOAT64_C(10.0), -HEDLEY_STATIC_CAST(double, precision));
|
||||
}
|
||||
|
||||
static simde_bfloat16
|
||||
simde_test_bf16_precision_to_slop(int precision) {
|
||||
return HEDLEY_UNLIKELY(precision == INT_MAX) ? SIMDE_BFLOAT16_VALUE(0.0) : simde_bfloat16_from_float32(simde_math_powf(SIMDE_FLOAT32_C(10.0), -HEDLEY_STATIC_CAST(float, precision)));
|
||||
}
|
||||
|
||||
static int
|
||||
simde_assert_equal_vf16_(
|
||||
size_t vec_len, simde_float16 const a[HEDLEY_ARRAY_PARAM(vec_len)], simde_float16 const b[HEDLEY_ARRAY_PARAM(vec_len)], simde_float16 slop,
|
||||
|
|
@ -697,17 +819,17 @@ simde_assert_equal_vf16_(
|
|||
for (size_t i = 0 ; i < vec_len ; i++) {
|
||||
simde_float32 a_ = simde_float16_to_float32(a[i]);
|
||||
simde_float32 b_ = simde_float16_to_float32(b[i]);
|
||||
|
||||
|
||||
if (HEDLEY_UNLIKELY(!simde_test_equal_f32(a_, b_, slop_))) {
|
||||
simde_test_debug_printf_("%s:%d: assertion failed: %s[%zu] ~= %s[%zu] (%f ~= %f)\n",
|
||||
filename, line, astr, i, bstr, i, HEDLEY_STATIC_CAST(double, a_),
|
||||
filename, line, astr, i, bstr, i, HEDLEY_STATIC_CAST(double, a_),
|
||||
HEDLEY_STATIC_CAST(double, b_));
|
||||
SIMDE_TEST_ASSERT_RETURN(1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_vf16(vec_len, a, b, precision) simde_assert_equal_vf16_(vec_len, a, b, simde_test_f16_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
|
||||
#define simde_assert_equal_vf16(vec_len, a, b, precision) do { if (simde_assert_equal_vf16_(vec_len, a, b, simde_test_f16_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_f16_(simde_float16 a, simde_float16 b, simde_float16 slop,
|
||||
|
|
@ -723,7 +845,7 @@ simde_assert_equal_f16_(simde_float16 a, simde_float16 b, simde_float16 slop,
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_f16(a, b, precision) simde_assert_equal_f16_(a, b, simde_test_f16_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
|
||||
#define simde_assert_equal_f16(a, b, precision) do { if (simde_assert_equal_f16_(a, b, simde_test_f16_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_vf32_(
|
||||
|
|
@ -738,7 +860,7 @@ simde_assert_equal_vf32_(
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_vf32(vec_len, a, b, precision) simde_assert_equal_vf32_(vec_len, a, b, simde_test_f32_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
|
||||
#define simde_assert_equal_vf32(vec_len, a, b, precision) do { if (simde_assert_equal_vf32_(vec_len, a, b, simde_test_f32_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_f32_(simde_float32 a, simde_float32 b, simde_float32 slop,
|
||||
|
|
@ -750,7 +872,7 @@ simde_assert_equal_f32_(simde_float32 a, simde_float32 b, simde_float32 slop,
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_f32(a, b, precision) simde_assert_equal_f32_(a, b, simde_test_f32_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
|
||||
#define simde_assert_equal_f32(a, b, precision) do { if (simde_assert_equal_f32_(a, b, simde_test_f32_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_vf64_(
|
||||
|
|
@ -765,7 +887,7 @@ simde_assert_equal_vf64_(
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_vf64(vec_len, a, b, precision) simde_assert_equal_vf64_(vec_len, a, b, simde_test_f64_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
|
||||
#define simde_assert_equal_vf64(vec_len, a, b, precision) do { if (simde_assert_equal_vf64_(vec_len, a, b, simde_test_f64_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_f64_(simde_float64 a, simde_float64 b, simde_float64 slop,
|
||||
|
|
@ -777,7 +899,139 @@ simde_assert_equal_f64_(simde_float64 a, simde_float64 b, simde_float64 slop,
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_f64(a, b, precision) simde_assert_equal_f64_(a, b, simde_test_f64_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
|
||||
#define simde_assert_equal_f64(a, b, precision) do { if (simde_assert_equal_f64_(a, b, simde_test_f64_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_vbf16_(
|
||||
size_t vec_len, simde_bfloat16 const a[HEDLEY_ARRAY_PARAM(vec_len)], simde_bfloat16 const b[HEDLEY_ARRAY_PARAM(vec_len)], simde_bfloat16 slop,
|
||||
const char* filename, int line, const char* astr, const char* bstr) {
|
||||
simde_float32 slop_ = simde_bfloat16_to_float32(slop);
|
||||
for (size_t i = 0 ; i < vec_len ; i++) {
|
||||
simde_float32 a_ = simde_bfloat16_to_float32(a[i]);
|
||||
simde_float32 b_ = simde_bfloat16_to_float32(b[i]);
|
||||
|
||||
if (HEDLEY_UNLIKELY(!simde_test_equal_f32(a_, b_, slop_))) {
|
||||
simde_test_debug_printf_("%s:%d: assertion failed: %s[%zu] ~= %s[%zu] (%f ~= %f)\n",
|
||||
filename, line, astr, i, bstr, i, HEDLEY_STATIC_CAST(double, a_),
|
||||
HEDLEY_STATIC_CAST(double, b_));
|
||||
SIMDE_TEST_ASSERT_RETURN(1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_vbf16(vec_len, a, b, precision) do { if (simde_assert_equal_vbf16_(vec_len, a, b, simde_test_bf16_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_bf16_(simde_bfloat16 a, simde_bfloat16 b, simde_bfloat16 slop,
|
||||
const char* filename, int line, const char* astr, const char* bstr) {
|
||||
simde_float32 a_ = simde_bfloat16_to_float32(a);
|
||||
simde_float32 b_ = simde_bfloat16_to_float32(b);
|
||||
simde_float32 slop_ = simde_bfloat16_to_float32(slop);
|
||||
if (HEDLEY_UNLIKELY(!simde_test_equal_f32(a_, b_, slop_))) {
|
||||
simde_test_debug_printf_("%s:%d: assertion failed: %s ~= %s (%f ~= %f)\n",
|
||||
filename, line, astr, bstr, HEDLEY_STATIC_CAST(double, a_),
|
||||
HEDLEY_STATIC_CAST(double, b_));
|
||||
SIMDE_TEST_ASSERT_RETURN(1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_bf16(a, b, precision) do { if (simde_assert_equal_bf16_(a, b, simde_test_bf16_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_vp8_(
|
||||
size_t vec_len, simde_poly8 const a[HEDLEY_ARRAY_PARAM(vec_len)], simde_poly8 const b[HEDLEY_ARRAY_PARAM(vec_len)],
|
||||
const char* filename, int line, const char* astr, const char* bstr) {
|
||||
for (size_t i = 0 ; i < vec_len ; i++) {
|
||||
uint8_t a_ = HEDLEY_STATIC_CAST(uint8_t, a[i]);
|
||||
uint8_t b_ = HEDLEY_STATIC_CAST(uint8_t, b[i]);
|
||||
|
||||
if (HEDLEY_UNLIKELY(a_ != b_)) {
|
||||
simde_test_debug_printf_("%s:%d: assertion failed: %s[%zu] ~= %s[%zu] (%" PRIu8 " ~= %" PRIu8 ")\n",
|
||||
filename, line, astr, i, bstr, i, a_, b_);
|
||||
SIMDE_TEST_ASSERT_RETURN(1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_vp8(vec_len, a, b) do { if (simde_assert_equal_vp8_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_p8_(simde_poly8 a, simde_poly8 b,
|
||||
const char* filename, int line, const char* astr, const char* bstr) {
|
||||
uint8_t a_ = HEDLEY_STATIC_CAST(uint8_t, a);
|
||||
uint8_t b_ = HEDLEY_STATIC_CAST(uint8_t, b);
|
||||
if (HEDLEY_UNLIKELY(a_ != b_)) {
|
||||
simde_test_debug_printf_("%s:%d: assertion failed: %s ~= %s (%" PRIu8 " ~= %" PRIu8 ")\n",
|
||||
filename, line, astr, bstr, a_, b_);
|
||||
SIMDE_TEST_ASSERT_RETURN(1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_p8(a, b) do { if (simde_assert_equal_p8_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_vp16_(
|
||||
size_t vec_len, simde_poly16 const a[HEDLEY_ARRAY_PARAM(vec_len)], simde_poly16 const b[HEDLEY_ARRAY_PARAM(vec_len)],
|
||||
const char* filename, int line, const char* astr, const char* bstr) {
|
||||
for (size_t i = 0 ; i < vec_len ; i++) {
|
||||
uint16_t a_ = HEDLEY_STATIC_CAST(uint16_t, a[i]);
|
||||
uint16_t b_ = HEDLEY_STATIC_CAST(uint16_t, b[i]);
|
||||
|
||||
if (HEDLEY_UNLIKELY(a_ != b_)) {
|
||||
simde_test_debug_printf_("%s:%d: assertion failed: %s[%zu] ~= %s[%zu] (%" PRIu16 " ~= %" PRIu16 ")\n",
|
||||
filename, line, astr, i, bstr, i, a_, b_);
|
||||
SIMDE_TEST_ASSERT_RETURN(1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_vp16(vec_len, a, b) do { if (simde_assert_equal_vp16_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_p16_(simde_poly16 a, simde_poly16 b,
|
||||
const char* filename, int line, const char* astr, const char* bstr) {
|
||||
uint16_t a_ = HEDLEY_STATIC_CAST(uint16_t, a);
|
||||
uint16_t b_ = HEDLEY_STATIC_CAST(uint16_t, b);
|
||||
if (HEDLEY_UNLIKELY(a_ != b_)) {
|
||||
simde_test_debug_printf_("%s:%d: assertion failed: %s ~= %s (%" PRIu16 " ~= %" PRIu16 ")\n",
|
||||
filename, line, astr, bstr, a_, b_);
|
||||
SIMDE_TEST_ASSERT_RETURN(1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_p16(a, b) do { if (simde_assert_equal_p16_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_vp64_(
|
||||
size_t vec_len, simde_poly64 const a[HEDLEY_ARRAY_PARAM(vec_len)], simde_poly64 const b[HEDLEY_ARRAY_PARAM(vec_len)],
|
||||
const char* filename, int line, const char* astr, const char* bstr) {
|
||||
for (size_t i = 0 ; i < vec_len ; i++) {
|
||||
uint64_t a_ = HEDLEY_STATIC_CAST(uint64_t, a[i]);
|
||||
uint64_t b_ = HEDLEY_STATIC_CAST(uint64_t, b[i]);
|
||||
|
||||
if (HEDLEY_UNLIKELY(a_ != b_)) {
|
||||
simde_test_debug_printf_("%s:%d: assertion failed: %s[%zu] ~= %s[%zu] (%" PRIu64 " ~= %" PRIu64 ")\n",
|
||||
filename, line, astr, i, bstr, i, a_, b_);
|
||||
SIMDE_TEST_ASSERT_RETURN(1);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_vp64(vec_len, a, b) do { if (simde_assert_equal_vp64_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
static int
|
||||
simde_assert_equal_p64_(simde_poly64 a, simde_poly64 b,
|
||||
const char* filename, int line, const char* astr, const char* bstr) {
|
||||
uint64_t a_ = HEDLEY_STATIC_CAST(uint64_t, a);
|
||||
uint64_t b_ = HEDLEY_STATIC_CAST(uint64_t, b);
|
||||
if (HEDLEY_UNLIKELY(a_ != b_)) {
|
||||
simde_test_debug_printf_("%s:%d: assertion failed: %s ~= %s (%" PRIu64 " ~= %" PRIu64 ")\n",
|
||||
filename, line, astr, bstr, a_, b_);
|
||||
SIMDE_TEST_ASSERT_RETURN(1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#define simde_assert_equal_p64(a, b) do { if (simde_assert_equal_p64_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
#define SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(T, symbol_identifier, fmt) \
|
||||
static int \
|
||||
|
|
@ -857,6 +1111,9 @@ SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(uint64_t, u64, PRIu64)
|
|||
#define simde_assert_equal_vu16(vec_len, a, b) do { if (simde_assert_equal_vu16_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_vu32(vec_len, a, b) do { if (simde_assert_equal_vu32_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_vu64(vec_len, a, b) do { if (simde_assert_equal_vu64_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_vp8(vec_len, a, b) do { if (simde_assert_equal_vp8_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_vp16(vec_len, a, b) do { if (simde_assert_equal_vp16_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_vp64(vec_len, a, b) do { if (simde_assert_equal_vp64_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
#define simde_assert_equal_i8(a, b) do { if (simde_assert_equal_i8_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_i16(a, b) do { if (simde_assert_equal_i16_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
|
@ -867,6 +1124,9 @@ SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(uint64_t, u64, PRIu64)
|
|||
#define simde_assert_equal_u32(a, b) do { if (simde_assert_equal_u32_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_u64(a, b) do { if (simde_assert_equal_u64_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_i(a, b) do { if (simde_assert_equal_i_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_p8(a, b) do { if (simde_assert_equal_p8_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_p16(a, b) do { if (simde_assert_equal_p16_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_equal_p64(a, b) do { if (simde_assert_equal_p64_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
#define simde_assert_close_vi8(vec_len, a, b, slop) do { if (simde_assert_close_vi8_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_vi16(vec_len, a, b, slop) do { if (simde_assert_close_vi16_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
|
@ -876,6 +1136,9 @@ SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(uint64_t, u64, PRIu64)
|
|||
#define simde_assert_close_vu16(vec_len, a, b, slop) do { if (simde_assert_close_vu16_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_vu32(vec_len, a, b, slop) do { if (simde_assert_close_vu32_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_vu64(vec_len, a, b, slop) do { if (simde_assert_close_vu64_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_vp8(vec_len, a, b, slop) do { if (simde_assert_close_vp8_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_vp16(vec_len, a, b, slop) do { if (simde_assert_close_vp16_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_vp64(vec_len, a, b, slop) do { if (simde_assert_close_vp64_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
#define simde_assert_close_i8(a, b, slop) do { if (simde_assert_close_i8_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_i16(a, b, slop) do { if (simde_assert_close_i16_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
|
@ -886,6 +1149,9 @@ SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(uint64_t, u64, PRIu64)
|
|||
#define simde_assert_close_u32(a, b, slop) do { if (simde_assert_close_u32_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_u64(a, b, slop) do { if (simde_assert_close_u64_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_i(a, b, slop) do { if (simde_assert_close_i_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_p8(a, b, slop) do { if (simde_assert_close_p8_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_p16(a, b, slop) do { if (simde_assert_close_p16_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
#define simde_assert_close_p64(a, b, slop) do { if (simde_assert_close_p64_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
|
||||
|
||||
/* Since each test is compiled in 4 different versions (C/C++ and
|
||||
* native/emul), we need to be able to generate different symbols
|
||||
|
|
@ -956,4 +1222,7 @@ SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(uint64_t, u64, PRIu64)
|
|||
HEDLEY_C_DECL MunitSuite* HEDLEY_CONCAT(name, _emul_cpp)(void);
|
||||
#endif
|
||||
|
||||
HEDLEY_DIAGNOSTIC_POP
|
||||
|
||||
|
||||
#endif /* !defined(SIMDE_TESTS_H) */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue