aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/validation/NEON/Logical.cpp91
-rw-r--r--tests/validation/fixtures/LogicalFixture.h181
-rw-r--r--tests/validation/reference/Logical.cpp136
-rw-r--r--tests/validation/reference/Logical.h54
4 files changed, 462 insertions, 0 deletions
diff --git a/tests/validation/NEON/Logical.cpp b/tests/validation/NEON/Logical.cpp
new file mode 100644
index 0000000000..f721e3cbc5
--- /dev/null
+++ b/tests/validation/NEON/Logical.cpp
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2020 Arm Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include "arm_compute/core/Types.h"
+#include "arm_compute/runtime/NEON/functions/NELogical.h"
+#include "arm_compute/runtime/Tensor.h"
+#include "tests/NEON/Accessor.h"
+#include "tests/datasets/ShapeDatasets.h"
+#include "tests/framework/Asserts.h"
+#include "tests/framework/Macros.h"
+#include "tests/validation/Validation.h"
+#include "tests/validation/fixtures/LogicalFixture.h"
+
+namespace arm_compute
+{
+namespace test
+{
+namespace validation
+{
+TEST_SUITE(NEON)
+
+TEST_SUITE(LogicalAnd)
+template <typename T>
+using NELogicalAndFixture = LogicalBinaryOperationValidationFixture<Tensor, Accessor, NELogicalAnd, reference::LogicalBinaryOperation::AND, T>;
+
+FIXTURE_DATA_TEST_CASE(RunSmall, NELogicalAndFixture<uint8_t>, framework::DatasetMode::ALL, zip(datasets::SmallShapes(), datasets::SmallShapes()))
+{
+ // Validate output
+ validate(Accessor(_target), _reference);
+}
+
+FIXTURE_DATA_TEST_CASE(RunSmallBroadcast, NELogicalAndFixture<uint8_t>, framework::DatasetMode::ALL, datasets::SmallShapesBroadcast())
+{
+ // Validate output
+ validate(Accessor(_target), _reference);
+}
+TEST_SUITE_END() // LogicalAnd
+
+TEST_SUITE(LogicalOr)
+template <typename T>
+using NELogicalOrFixture = LogicalBinaryOperationValidationFixture<Tensor, Accessor, NELogicalOr, reference::LogicalBinaryOperation::OR, T>;
+
+FIXTURE_DATA_TEST_CASE(RunSmall, NELogicalOrFixture<uint8_t>, framework::DatasetMode::ALL, zip(datasets::SmallShapes(), datasets::SmallShapes()))
+{
+ // Validate output
+ validate(Accessor(_target), _reference);
+}
+
+FIXTURE_DATA_TEST_CASE(RunSmallBroadcast, NELogicalOrFixture<uint8_t>, framework::DatasetMode::ALL, datasets::SmallShapesBroadcast())
+{
+ // Validate output
+ validate(Accessor(_target), _reference);
+}
+TEST_SUITE_END() // LogicalOr
+
+TEST_SUITE(LogicalNot)
+
+template <typename T>
+using NELogicalNotFixture = LogicalNotValidationFixture<Tensor, Accessor, NELogicalNot, T>;
+
+FIXTURE_DATA_TEST_CASE(RunSmall, NELogicalNotFixture<uint8_t>, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType",
+ DataType::U8)))
+{
+ // Validate output
+ validate(Accessor(_target), _reference);
+}
+TEST_SUITE_END() // LogicalNot
+TEST_SUITE_END() // NEON
+} // namespace validation
+} // namespace test
+} // namespace arm_compute \ No newline at end of file
diff --git a/tests/validation/fixtures/LogicalFixture.h b/tests/validation/fixtures/LogicalFixture.h
new file mode 100644
index 0000000000..a4817cf785
--- /dev/null
+++ b/tests/validation/fixtures/LogicalFixture.h
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2020 Arm Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef ARM_COMPUTE_TEST_LOGICAL_FIXTURE
+#define ARM_COMPUTE_TEST_LOGICAL_FIXTURE
+
+#include "arm_compute/core/TensorShape.h"
+#include "arm_compute/core/Types.h"
+#include "tests/AssetsLibrary.h"
+#include "tests/Globals.h"
+#include "tests/IAccessor.h"
+#include "tests/framework/Asserts.h"
+#include "tests/framework/Fixture.h"
+#include "tests/validation/reference/Logical.h"
+
+namespace arm_compute
+{
+namespace test
+{
+namespace validation
+{
+template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
+class LogicalOperationValidationFixtureBase : public framework::Fixture
+{
+protected:
+ template <typename U>
+ void fill(U &&tensor, int i)
+ {
+ constexpr uint8_t zero = 0;
+ constexpr uint8_t one = 0x1;
+ constexpr uint8_t mixed = 0xAA;
+ constexpr uint8_t mixed_bitwise_not = ~(0xAA);
+
+ library->fill_static_values(tensor, i == 0 ?
+ std::vector<uint8_t> { zero, one, zero, one, mixed, zero, mixed } :
+ std::vector<uint8_t> { zero, zero, one, one, zero, mixed, mixed_bitwise_not });
+ }
+
+ void allocate_tensor(std::initializer_list<TensorType *> tensors)
+ {
+ for(auto t : tensors)
+ {
+ ARM_COMPUTE_EXPECT(t->info()->is_resizable(), framework::LogLevel::ERRORS);
+ t->allocator()->allocate();
+ ARM_COMPUTE_EXPECT(!t->info()->is_resizable(), framework::LogLevel::ERRORS);
+ }
+ }
+
+ TensorType _target{};
+ SimpleTensor<T> _reference{};
+};
+
+template <typename TensorType, typename AccessorType, typename FunctionType, reference::LogicalBinaryOperation Op, typename T>
+class LogicalBinaryOperationValidationFixture : public LogicalOperationValidationFixtureBase<TensorType, AccessorType, FunctionType, T>
+{
+ using Parent = LogicalOperationValidationFixtureBase<TensorType, AccessorType, FunctionType, T>;
+
+public:
+ template <typename...>
+ void setup(TensorShape shape0, TensorShape shape1)
+ {
+ Parent::_target = compute_target(shape0, shape1);
+ Parent::_reference = compute_reference(shape0, shape1);
+ }
+
+private:
+ TensorType compute_target(const TensorShape &shape0, const TensorShape &shape1)
+ {
+ TensorType src0 = create_tensor<TensorType>(shape0, _data_type);
+ TensorType src1 = create_tensor<TensorType>(shape1, _data_type);
+ TensorType dst = create_tensor<TensorType>(TensorShape::broadcast_shape(shape0, shape1), _data_type);
+
+ FunctionType logical_binary_op;
+
+ logical_binary_op.configure(&src0, &src1, &dst);
+
+ Parent::allocate_tensor({ &src0, &src1, &dst });
+
+ Parent::fill(AccessorType(src0), 0);
+ Parent::fill(AccessorType(src1), 1);
+
+ logical_binary_op.run();
+
+ return dst;
+ }
+
+ SimpleTensor<T> compute_reference(const TensorShape &shape0, const TensorShape &shape1)
+ {
+ // Create reference
+ SimpleTensor<T> src0{ shape0, _data_type };
+ SimpleTensor<T> src1{ shape1, _data_type };
+
+ // Fill reference
+ Parent::fill(src0, 0);
+ Parent::fill(src1, 1);
+
+ switch(Op)
+ {
+ case reference::LogicalBinaryOperation::OR:
+ return reference::logical_or<T>(src0, src1);
+ case reference::LogicalBinaryOperation::AND:
+ return reference::logical_and<T>(src0, src1);
+ case reference::LogicalBinaryOperation::UNKNOWN:
+ /* fall-through */
+ default:
+ ARM_COMPUTE_ASSERT_FAIL("unknown logical binary operator is given");
+ }
+
+ return SimpleTensor<T> {};
+ }
+
+ static constexpr auto _data_type{ DataType::U8 };
+};
+
+template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
+class LogicalNotValidationFixture : public LogicalOperationValidationFixtureBase<TensorType, AccessorType, FunctionType, T>
+{
+ using Parent = LogicalOperationValidationFixtureBase<TensorType, AccessorType, FunctionType, T>;
+
+public:
+ template <typename...>
+ void setup(TensorShape shape, DataType data_type)
+ {
+ Parent::_target = compute_target(shape, data_type);
+ Parent::_reference = compute_reference(shape, data_type);
+ }
+
+private:
+ TensorType compute_target(const TensorShape &shape, DataType data_type)
+ {
+ TensorType src = create_tensor<TensorType>(shape, data_type);
+ TensorType dst = create_tensor<TensorType>(shape, data_type);
+
+ FunctionType logical_not;
+
+ logical_not.configure(&src, &dst);
+
+ Parent::allocate_tensor({ &src, &dst });
+
+ Parent::fill(AccessorType(src), 0);
+
+ logical_not.run();
+
+ return dst;
+ }
+
+ SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type)
+ {
+ // Create reference
+ SimpleTensor<T> src{ shape, data_type };
+
+ // Fill reference
+ Parent::fill(src, 0);
+
+ return reference::logical_not<T>(src);
+ }
+};
+} // namespace validation
+} // namespace test
+} // namespace arm_compute
+#endif /* ARM_COMPUTE_TEST_LOGICAL_FIXTURE */ \ No newline at end of file
diff --git a/tests/validation/reference/Logical.cpp b/tests/validation/reference/Logical.cpp
new file mode 100644
index 0000000000..394525c392
--- /dev/null
+++ b/tests/validation/reference/Logical.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2020 Arm Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include "tests/validation/reference/Logical.h"
+
+namespace arm_compute
+{
+namespace test
+{
+namespace validation
+{
+namespace reference
+{
+template <typename T>
+T logical_op(LogicalBinaryOperation op, T src1, T src2)
+{
+ switch(op)
+ {
+ case LogicalBinaryOperation::AND:
+ return src1 && src2;
+ case LogicalBinaryOperation::OR:
+ return src1 || src2;
+ case LogicalBinaryOperation::UNKNOWN:
+ default:
+ ARM_COMPUTE_ERROR_ON_MSG(true, "unknown logical binary operation is given");
+ }
+ return false;
+}
+
+template <size_t dim>
+struct BroadcastUnroll
+{
+ template <typename T>
+ static void unroll(LogicalBinaryOperation op,
+ const SimpleTensor<T> &src1, const SimpleTensor<T> &src2, SimpleTensor<T> &dst,
+ Coordinates &id_src1, Coordinates &id_src2, Coordinates &id_dst)
+ {
+ const bool src1_is_broadcast = (src1.shape()[dim - 1] != dst.shape()[dim - 1]);
+ const bool src2_is_broadcast = (src2.shape()[dim - 1] != dst.shape()[dim - 1]);
+
+ id_src1.set(dim - 1, 0);
+ id_src2.set(dim - 1, 0);
+ id_dst.set(dim - 1, 0);
+#if defined(_OPENMP)
+ #pragma omp parallel for
+#endif /* _OPENMP */
+ for(size_t i = 0; i < dst.shape()[dim - 1]; ++i)
+ {
+ BroadcastUnroll < dim - 1 >::unroll(op, src1, src2, dst, id_src1, id_src2, id_dst);
+
+ id_src1[dim - 1] += !src1_is_broadcast;
+ id_src2[dim - 1] += !src2_is_broadcast;
+ ++id_dst[dim - 1];
+ }
+ }
+};
+
+template <>
+struct BroadcastUnroll<0>
+{
+ template <typename T>
+ static void unroll(LogicalBinaryOperation op, const SimpleTensor<T> &src1, const SimpleTensor<T> &src2, SimpleTensor<T> &dst,
+ Coordinates &id_src1, Coordinates &id_src2, Coordinates &id_dst)
+ {
+ dst[coord2index(dst.shape(), id_dst)] = logical_op(op, src1[coord2index(src1.shape(), id_src1)], src2[coord2index(src2.shape(), id_src2)]);
+ }
+};
+
+template <typename T>
+SimpleTensor<T> logical_or(const SimpleTensor<T> &src1, const SimpleTensor<T> &src2)
+{
+ Coordinates id_src1{};
+ Coordinates id_src2{};
+ Coordinates id_dst{};
+ SimpleTensor<T> dst{ TensorShape::broadcast_shape(src1.shape(), src2.shape()), src1.data_type() };
+
+ BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(LogicalBinaryOperation::OR, src1, src2, dst, id_src1, id_src2, id_dst);
+
+ return dst;
+}
+
+template <typename T>
+SimpleTensor<T> logical_and(const SimpleTensor<T> &src1, const SimpleTensor<T> &src2)
+{
+ Coordinates id_src1{};
+ Coordinates id_src2{};
+ Coordinates id_dst{};
+ SimpleTensor<T> dst{ TensorShape::broadcast_shape(src1.shape(), src2.shape()), src1.data_type() };
+
+ BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(LogicalBinaryOperation::AND, src1, src2, dst, id_src1, id_src2, id_dst);
+
+ return dst;
+}
+
+template <typename T>
+SimpleTensor<T> logical_not(const SimpleTensor<T> &src)
+{
+ SimpleTensor<T> dst(src.shape(), src.data_type());
+#if defined(_OPENMP)
+ #pragma omp parallel for
+#endif /* _OPENMP */
+ for(int i = 0; i < src.num_elements(); ++i)
+ {
+ dst[i] = !src[i];
+ }
+
+ return dst;
+}
+
+template SimpleTensor<uint8_t> logical_or(const SimpleTensor<uint8_t> &src1, const SimpleTensor<uint8_t> &src2);
+template SimpleTensor<uint8_t> logical_and(const SimpleTensor<uint8_t> &src1, const SimpleTensor<uint8_t> &src2);
+template SimpleTensor<uint8_t> logical_not(const SimpleTensor<uint8_t> &src1);
+} // namespace reference
+} // namespace validation
+} // namespace test
+} // namespace arm_compute \ No newline at end of file
diff --git a/tests/validation/reference/Logical.h b/tests/validation/reference/Logical.h
new file mode 100644
index 0000000000..fb906b70b6
--- /dev/null
+++ b/tests/validation/reference/Logical.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020 Arm Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef ARM_COMPUTE_TEST_LOGICAL_H
+#define ARM_COMPUTE_TEST_LOGICAL_H
+
+#include "tests/SimpleTensor.h"
+
+namespace arm_compute
+{
+namespace test
+{
+namespace validation
+{
+namespace reference
+{
+enum class LogicalBinaryOperation
+{
+ UNKNOWN = 0,
+ AND = 1,
+ OR = 2
+};
+
+template <typename T>
+SimpleTensor<T> logical_or(const SimpleTensor<T> &src1, const SimpleTensor<T> &src2);
+template <typename T>
+SimpleTensor<T> logical_and(const SimpleTensor<T> &src1, const SimpleTensor<T> &src2);
+template <typename T>
+SimpleTensor<T> logical_not(const SimpleTensor<T> &src1);
+} // namespace reference
+} // namespace validation
+} // namespace test
+} // namespace arm_compute
+#endif /* ARM_COMPUTE_TEST_LOGICAL_H */ \ No newline at end of file
generated by cgit v1.2.1 (git 2.23.0) at 2024-05-09 23:25:33 +0000