COMPMID-424 NEON MinMaxLocation test.

Change-Id: I3dda0961061b52c680b5af0443ad93a00425dd4c
Reviewed-on: http://mpd-gerrit.cambridge.arm.com/77433
Reviewed-by: Michele DiGiorgio <michele.digiorgio@arm.com>
Tested-by: Kaizen <jeremy.johnson+kaizengerrit@arm.com>
Reviewed-by: Steven Niu <steven.niu@arm.com>

10 files changed, 350 insertions, 2 deletions

diff --git a/tests/validation/NEON/CMakeLists.txt b/tests/validation/NEON/CMakeLists.txt
index 4e15b8e3ee..ba35249cb6 100644
--- a/tests/validation/NEON/CMakeLists.txt
+++ b/tests/validation/NEON/CMakeLists.txt
@@ -22,6 +22,7 @@
 cmake_minimum_required (VERSION 3.1)
 
 set(arm_compute_test_validation_NEON_SOURCE_FILES
+    ${CMAKE_SOURCE_DIR}/NEON/Helper.h
     ${CMAKE_SOURCE_DIR}/NEON/NEAccessor.h
     ${CMAKE_CURRENT_SOURCE_DIR}/AbsoluteDifference.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Accumulate.cpp
@@ -45,17 +46,17 @@ set(arm_compute_test_validation_NEON_SOURCE_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/Fixedpoint/Reciprocal_QS8.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/FullyConnectedLayer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Gaussian3x3.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/Gaussian5x5.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/GEMM.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/IntegralImage.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/MeanStdDev.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/NormalizationLayer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/PixelWiseMultiplication.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/MeanStdDev.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Pooling/PoolingLayer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Sobel3x3.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Sobel5x5.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/SoftmaxLayer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Threshold.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/MinMaxLocation.cpp
 )
 
 add_library(arm_compute_test_validation_NEON OBJECT
diff --git a/tests/validation/NEON/MinMaxLocation.cpp b/tests/validation/NEON/MinMaxLocation.cpp
new file mode 100644
index 0000000000..bbb4589d30
--- /dev/null
+++ b/tests/validation/NEON/MinMaxLocation.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2017 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 "Globals.h"
+#include "NEON/Helper.h"
+#include "NEON/NEAccessor.h"
+#include "PaddingCalculator.h"
+#include "TensorLibrary.h"
+#include "TypePrinter.h"
+#include "Utils.h"
+#include "validation/Datasets.h"
+#include "validation/Reference.h"
+#include "validation/Validation.h"
+
+#include "arm_compute/core/Helpers.h"
+#include "arm_compute/core/Types.h"
+#include "arm_compute/runtime/NEON/functions/NEMinMaxLocation.h"
+#include "arm_compute/runtime/Tensor.h"
+#include "arm_compute/runtime/TensorAllocator.h"
+
+#include "boost_wrapper.h"
+
+#include <random>
+#include <string>
+
+using namespace arm_compute;
+using namespace arm_compute::test;
+using namespace arm_compute::test::neon;
+using namespace arm_compute::test::validation;
+
+namespace
+{
+/** Compute Neon MinMaxLocation function.
+     *
+     * @param[in]  shape     Shape of the input and output tensors.
+     * @param[in]  dt_in     Data type of first input tensor.
+     * @param[out] min       Minimum value of tensor
+     * @param[out] max       Maximum value of tensor
+     * @param[out] min_loc   Array with locations of minimum values
+     * @param[out] max_loc   Array with locations of maximum values
+     * @param[out] min_count Number of minimum values found
+     * @param[out] max_count Number of maximum values found
+     *
+     * @return Computed output tensor.
+     */
+
+void compute_min_max_location(const TensorShape &shape, DataType dt_in, int32_t &min, int32_t &max,
+                              Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
+{
+    // Create tensor
+    Tensor src = create_tensor<Tensor>(shape, dt_in);
+    src.info()->set_format((dt_in == DataType::U8) ? Format::U8 : Format::S16);
+
+    // Create and configure min_max_location configure function
+    NEMinMaxLocation min_max_loc;
+    min_max_loc.configure(&src, &min, &max, &min_loc, &max_loc, &min_count, &max_count);
+
+    // Allocate tensors
+    src.allocator()->allocate();
+
+    BOOST_TEST(!src.info()->is_resizable());
+
+    // Fill tensors
+    library->fill_tensor_uniform(NEAccessor(src), 0);
+
+    // Compute function
+    min_max_loc.run();
+}
+
+void validate_configuration(const Tensor &src, TensorShape shape)
+{
+    BOOST_TEST(src.info()->is_resizable());
+
+    // Create output storage
+    int32_t            min;
+    int32_t            max;
+    Coordinates2DArray min_loc;
+    Coordinates2DArray max_loc;
+    uint32_t           min_count;
+    uint32_t           max_count;
+
+    // Create and configure function
+    NEMinMaxLocation min_max_loc;
+    min_max_loc.configure(&src, &min, &max, &min_loc, &max_loc, &min_count, &max_count);
+
+    // Validate valid region
+    const ValidRegion valid_region = shape_to_valid_region(shape);
+    validate(src.info()->valid_region(), valid_region);
+
+    // Validate padding
+    const PaddingSize padding = PaddingCalculator(shape.x(), 1).required_padding();
+    validate(src.info()->padding(), padding);
+}
+} // namespace
+
+#ifndef DOXYGEN_SKIP_THIS
+BOOST_AUTO_TEST_SUITE(NEON)
+BOOST_AUTO_TEST_SUITE(MinMaxLocation)
+
+BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
+BOOST_DATA_TEST_CASE(Configuration, (Small2DShapes() + Large2DShapes()) * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
+                     shape, dt)
+{
+    // Create tensor
+    Tensor src = create_tensor<Tensor>(shape, dt);
+    src.info()->set_format(dt == DataType::U8 ? Format::U8 : Format::S16);
+
+    validate_configuration(src, shape);
+}
+
+BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
+BOOST_DATA_TEST_CASE(RunSmall, Small2DShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
+                     shape, dt)
+{
+    // Create output storage
+    int32_t            min;
+    int32_t            max;
+    Coordinates2DArray min_loc(shape.total_size());
+    Coordinates2DArray max_loc(shape.total_size());
+    uint32_t           min_count;
+    uint32_t           max_count;
+
+    int32_t            ref_min;
+    int32_t            ref_max;
+    Coordinates2DArray ref_min_loc(shape.total_size());
+    Coordinates2DArray ref_max_loc(shape.total_size());
+    uint32_t           ref_min_count;
+    uint32_t           ref_max_count;
+
+    // Compute function
+    compute_min_max_location(shape, dt, min, max, min_loc, max_loc, min_count, max_count);
+
+    // Compute reference
+    Reference::compute_reference_min_max_location(shape, dt, ref_min, ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
+
+    // Validate output
+    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
+}
+
+BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
+BOOST_DATA_TEST_CASE(RunLarge, Large2DShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
+                     shape, dt)
+{
+    // Create output storage
+    int32_t            min;
+    int32_t            max;
+    Coordinates2DArray min_loc(shape.total_size());
+    Coordinates2DArray max_loc(shape.total_size());
+    uint32_t           min_count;
+    uint32_t           max_count;
+
+    int32_t            ref_min;
+    int32_t            ref_max;
+    Coordinates2DArray ref_min_loc(shape.total_size());
+    Coordinates2DArray ref_max_loc(shape.total_size());
+    uint32_t           ref_min_count;
+    uint32_t           ref_max_count;
+
+    // Compute function
+    compute_min_max_location(shape, dt, min, max, min_loc, max_loc, min_count, max_count);
+
+    // Compute reference
+    Reference::compute_reference_min_max_location(shape, dt, ref_min, ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
+
+    // Validate output
+    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+#endif /* DOXYGEN_SKIP_THIS */
\ No newline at end of file
diff --git a/tests/validation/Reference.cpp b/tests/validation/Reference.cpp
index 4b4919fd28..3b429c1ee6 100644
--- a/tests/validation/Reference.cpp
+++ b/tests/validation/Reference.cpp
@@ -71,6 +71,18 @@ std::pair<RawTensor, RawTensor> Reference::compute_reference_sobel_5x5(const Ten
 
     return std::make_pair(ref_dst_x, ref_dst_y);
 }
+void Reference::compute_reference_min_max_location(const TensorShape &shape, DataType dt_in, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc,
+                                                   uint32_t &min_count, uint32_t &max_count)
+{
+    // Create reference
+    RawTensor ref_src = library->get(shape, dt_in);
+
+    // Fill reference
+    library->fill_tensor_uniform(ref_src, 0);
+
+    // Compute reference
+    ReferenceCPP::min_max_location(ref_src, min, max, min_loc, max_loc, min_count, max_count);
+}
 std::pair<float, float> Reference::compute_reference_mean_and_standard_deviation(const TensorShape &shape)
 {
     // Create reference
diff --git a/tests/validation/Reference.h b/tests/validation/Reference.h
index a3ae3b6d02..259afd19cd 100644
--- a/tests/validation/Reference.h
+++ b/tests/validation/Reference.h
@@ -26,6 +26,7 @@
 
 #include "RawTensor.h"
 #include "Types.h"
+#include "arm_compute/runtime/Array.h"
 
 #include <map>
 #include <vector>
@@ -58,6 +59,21 @@ public:
      * @return Computed raw tensors along x and y axis.
      */
     static std::pair<RawTensor, RawTensor> compute_reference_sobel_5x5(const TensorShape &shape, BorderMode border_mode, uint8_t constant_border_value);
+    /** Compute min max location.
+     *
+     * @param[in]  shape     Shape of the input tensors.
+     * @param[in]  dt_in     Data type of input tensor.
+     * @param[out] min       Minimum value of tensor
+     * @param[out] max       Maximum value of tensor
+     * @param[out] min_loc   Array with locations of minimum values
+     * @param[out] max_loc   Array with locations of maximum values
+     * @param[out] min_count Number of minimum values found
+     * @param[out] max_count Number of maximum values found
+     *
+     * @return Computed minimum, maximum values and their locations.
+     */
+    static void compute_reference_min_max_location(const TensorShape &shape, DataType dt_in, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count,
+                                                   uint32_t &max_count);
     /** Compute reference mean and standard deviation.
      *
      * @param[in] shape Shape of the input tensors.
diff --git a/tests/validation/ReferenceCPP.cpp b/tests/validation/ReferenceCPP.cpp
index 0db0352863..a1dc4ceeac 100644
--- a/tests/validation/ReferenceCPP.cpp
+++ b/tests/validation/ReferenceCPP.cpp
@@ -70,6 +70,13 @@ void ReferenceCPP::sobel_5x5(RawTensor &src, RawTensor &dst_x, RawTensor &dst_y,
     tensor_operations::sobel_5x5(s, dx, dy, border_mode, constant_border_value);
 }
 
+// Minimum maximum location
+void ReferenceCPP::min_max_location(const RawTensor &src, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
+{
+    const TensorVariant s = TensorFactory::get_tensor(src);
+    boost::apply_visitor(tensor_visitors::min_max_location_visitor(min, max, min_loc, max_loc, min_count, max_count), s);
+}
+
 // Absolute difference
 void ReferenceCPP::absolute_difference(const RawTensor &src1, const RawTensor &src2, RawTensor &dst)
 {
diff --git a/tests/validation/ReferenceCPP.h b/tests/validation/ReferenceCPP.h
index 8a5d853806..bc9ea476ad 100644
--- a/tests/validation/ReferenceCPP.h
+++ b/tests/validation/ReferenceCPP.h
@@ -64,6 +64,17 @@ public:
      *
      */
     static void sobel_5x5(RawTensor &src, RawTensor &dst_x, RawTensor &dst_y, BorderMode border_mode, uint8_t constant_border_value);
+    /** Function to compute the min max values and their location in a tensor.
+     *
+     * @param[in]  src       Input tensor.
+     * @param[out] min       Minimum value of the tensor.
+     * @param[out] max       Maximum value of the tensor
+     * @param[out] min_loc   Array with locations of minimum values
+     * @param[out] max_loc   Array with locations of maximum values
+     * @param[out] min_count Number of minimum values found
+     * @param[out] max_count Number of maximum values found
+     */
+    static void min_max_location(const RawTensor &src, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count);
     /** Function to compute the mean and standard deviation of a tensor.
      *
      * @param[in]  src     Input tensor.
diff --git a/tests/validation/TensorOperations.h b/tests/validation/TensorOperations.h
index 882c9e07e1..9e201e2f04 100644
--- a/tests/validation/TensorOperations.h
+++ b/tests/validation/TensorOperations.h
@@ -311,6 +311,56 @@ void sobel_5x5(Tensor<T1> &in, Tensor<T2> &out_x, Tensor<T2> &out_y, BorderMode
     }
 }
 
+// Min max location
+template <typename T1>
+void min_max_location(const Tensor<T1> &in, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
+{
+    // Set min and max to first pixel
+    min       = in[0];
+    max       = in[0];
+    min_count = 0;
+    max_count = 0;
+
+    const size_t width = in.shape().x();
+
+    // Look for min and max values
+    for(int i = 1; i < in.num_elements(); ++i)
+    {
+        if(static_cast<int32_t>(in[i]) < min)
+        {
+            min = in[i];
+        }
+        if(static_cast<int32_t>(in[i]) > max)
+        {
+            max = in[i];
+        }
+    }
+
+    for(int i = 0; i < in.num_elements(); ++i)
+    {
+        if(static_cast<int32_t>(in[i]) == min)
+        {
+            Coordinates2D min_coord;
+            min_coord.x = static_cast<int32_t>(i % width);
+            min_coord.y = static_cast<int32_t>(i / width);
+
+            min_loc.push_back(min_coord);
+
+            min_count++;
+        }
+        if(static_cast<int32_t>(in[i]) == max)
+        {
+            Coordinates2D max_coord;
+            max_coord.x = static_cast<int32_t>(i % width);
+            max_coord.y = static_cast<int32_t>(i / width);
+
+            max_loc.push_back(max_coord);
+
+            max_count++;
+        }
+    }
+}
+
 // Mean Standard Deviation
 template <typename T1>
 void mean_and_standard_deviation(const Tensor<T1> &in, float &mean, float &std_dev)
diff --git a/tests/validation/TensorVisitors.h b/tests/validation/TensorVisitors.h
index c58b9a69c0..168e212a65 100644
--- a/tests/validation/TensorVisitors.h
+++ b/tests/validation/TensorVisitors.h
@@ -45,6 +45,28 @@ namespace validation
 {
 namespace tensor_visitors
 {
+// Min max location visitor
+struct min_max_location_visitor : public boost::static_visitor<>
+{
+public:
+    explicit min_max_location_visitor(int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
+        : _min(min), _max(max), _min_loc(min_loc), _max_loc(max_loc), _min_count(min_count), _max_count(max_count)
+    {
+    }
+    template <typename T1>
+    void operator()(const Tensor<T1> &in) const
+    {
+        tensor_operations::min_max_location(in, _min, _max, _min_loc, _max_loc, _min_count, _max_count);
+    }
+
+private:
+    int32_t            &_min;
+    int32_t            &_max;
+    Coordinates2DArray &_min_loc;
+    Coordinates2DArray &_max_loc;
+    uint32_t           &_min_count;
+    uint32_t           &_max_count;
+};
 // Absolute Difference visitor
 struct absolute_difference_visitor : public boost::static_visitor<>
 {
diff --git a/tests/validation/Validation.cpp b/tests/validation/Validation.cpp
index f65f22935f..e949e3c4f5 100644
--- a/tests/validation/Validation.cpp
+++ b/tests/validation/Validation.cpp
@@ -410,6 +410,34 @@ void validate(float target, float ref, float tolerance_abs_error, float toleranc
     BOOST_TEST(equal);
 }
 
+void validate_min_max_loc(int32_t min, int32_t ref_min, int32_t max, int32_t ref_max,
+                          Coordinates2DArray &min_loc, Coordinates2DArray &ref_min_loc, Coordinates2DArray &max_loc, Coordinates2DArray &ref_max_loc,
+                          uint32_t min_count, uint32_t ref_min_count, uint32_t max_count, uint32_t ref_max_count)
+{
+    BOOST_TEST(min == ref_min);
+    BOOST_TEST(max == ref_max);
+
+    BOOST_TEST(min_count == min_loc.num_values());
+    BOOST_TEST(max_count == max_loc.num_values());
+    BOOST_TEST(ref_min_count == ref_min_loc.num_values());
+    BOOST_TEST(ref_max_count == ref_max_loc.num_values());
+
+    BOOST_TEST(min_count == ref_min_count);
+    BOOST_TEST(max_count == ref_max_count);
+
+    for(uint32_t i = 0; i < min_count; i++)
+    {
+        BOOST_TEST(min_loc.at(i).x == ref_min_loc.at(i).x);
+        BOOST_TEST(min_loc.at(i).y == ref_min_loc.at(i).y);
+    }
+
+    for(uint32_t i = 0; i < max_count; i++)
+    {
+        BOOST_TEST(max_loc.at(i).x == ref_max_loc.at(i).x);
+        BOOST_TEST(max_loc.at(i).y == ref_max_loc.at(i).y);
+    }
+}
+
 } // namespace validation
 } // namespace test
 } // namespace arm_compute
diff --git a/tests/validation/Validation.h b/tests/validation/Validation.h
index e833ae4322..e254c9f164 100644
--- a/tests/validation/Validation.h
+++ b/tests/validation/Validation.h
@@ -25,6 +25,7 @@
 #define __ARM_COMPUTE_TEST_REFERENCE_VALIDATION_H__
 
 #include "arm_compute/core/Types.h"
+#include "arm_compute/runtime/Array.h"
 
 #include "boost_wrapper.h"
 
@@ -128,6 +129,14 @@ void validate(std::vector<unsigned int> classified_labels, std::vector<unsigned
  */
 void validate(float target, float ref, float tolerance_abs_error = std::numeric_limits<float>::epsilon(), float tolerance_relative_error = 0.0001f);
 
+/** Validate min max location.
+ *
+ * - All values should match
+ */
+void validate_min_max_loc(int32_t min, int32_t ref_min, int32_t max, int32_t ref_max,
+                          Coordinates2DArray &min_loc, Coordinates2DArray &ref_min_loc, Coordinates2DArray &max_loc, Coordinates2DArray &ref_max_loc,
+                          uint32_t min_count, uint32_t ref_min_count, uint32_t max_count, uint32_t ref_max_count);
+
 } // namespace validation
 } // namespace test
 } // namespace arm_compute