COMPMID-415: Rename and move tests

The boost validation is now "standalone" in validation_old and builds as
arm_compute_validation_old. The new validation builds now as
arm_compute_validation.

Change-Id: Ib93ba848a25680ac60afb92b461d574a0757150d
Reviewed-on: http://mpd-gerrit.cambridge.arm.com/86187
Tested-by: Kaizen <jeremy.johnson+kaizengerrit@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>

1 files changed, 64 insertions, 195 deletions

diff --git a/tests/validation/Helpers.h b/tests/validation/Helpers.h
index 19a0c4105c..30959161bb 100644
--- a/tests/validation/Helpers.h
+++ b/tests/validation/Helpers.h
@@ -25,18 +25,12 @@
 #define __ARM_COMPUTE_TEST_VALIDATION_HELPERS_H__
 
 #include "arm_compute/core/Types.h"
-#include "tests/Globals.h"
-#include "tests/ILutAccessor.h"
-#include "tests/Types.h"
-#include "tests/validation/ValidationUserConfiguration.h"
+#include "arm_compute/core/Utils.h"
 #include "tests/validation/half.h"
 
-#include <array>
-#include <cstring>
 #include <random>
 #include <type_traits>
 #include <utility>
-#include <vector>
 
 namespace arm_compute
 {
@@ -44,158 +38,95 @@ namespace test
 {
 namespace validation
 {
-/** Helper function to fill one or more tensors with the uniform distribution with int values.
- *
- * @param[in]     dist          Distribution to be used to get the values for the tensor.
- * @param[in]     seeds         List of seeds to be used to fill each tensor.
- * @param[in,out] tensor        Tensor to be initialized with the values of the distribution.
- * @param[in,out] other_tensors (Optional) One or more tensors to be filled.
- *
- */
-template <typename D, typename T, typename... Ts>
-void fill_tensors(D &&dist, std::initializer_list<int> seeds, T &&tensor, Ts &&... other_tensors)
+template <typename T>
+struct is_floating_point : public std::is_floating_point<T>
 {
-    const std::array < T, 1 + sizeof...(Ts) > tensors{ { std::forward<T>(tensor), std::forward<Ts>(other_tensors)... } };
-    std::vector<int> vs(seeds);
-    ARM_COMPUTE_ERROR_ON(vs.size() != tensors.size());
-    int k = 0;
-    for(auto tp : tensors)
-    {
-        library->fill(*tp, std::forward<D>(dist), vs[k++]);
-    }
-}
+};
+
+template <>
+struct is_floating_point<half_float::half> : public std::true_type
+{
+};
 
 /** Helper function to get the testing range for each activation layer.
  *
  * @param[in] activation           Activation function to test.
- * @param[in] fixed_point_position (Optional) Number of bits for the fractional part. Defaults to 1.
+ * @param[in] data_type            Data type.
+ * @param[in] fixed_point_position Number of bits for the fractional part. Defaults to 1.
  *
  * @return A pair containing the lower upper testing bounds for a given function.
  */
 template <typename T>
-inline std::pair<T, T> get_activation_layer_test_bounds(ActivationLayerInfo::ActivationFunction activation, int fixed_point_position = 1)
+std::pair<T, T> get_activation_layer_test_bounds(ActivationLayerInfo::ActivationFunction activation, DataType data_type, int fixed_point_position = 0)
 {
-    bool is_float = std::is_same<T, float>::value;
-    is_float      = is_float || std::is_same<T, half_float::half>::value;
-
     std::pair<T, T> bounds;
 
-    // Set initial values
-    if(is_float)
-    {
-        bounds = std::make_pair(-255.f, 255.f);
-    }
-    else
+    switch(data_type)
     {
-        bounds = std::make_pair(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
-    }
+        case DataType::F16:
+        {
+            using namespace half_float::literal;
 
-    // Reduce testing ranges
-    switch(activation)
-    {
-        case ActivationLayerInfo::ActivationFunction::LOGISTIC:
-        case ActivationLayerInfo::ActivationFunction::SOFT_RELU:
-            // Reduce range as exponent overflows
-            if(is_float)
+            switch(activation)
             {
-                bounds.first  = -40.f;
-                bounds.second = 40.f;
-            }
-            else
-            {
-                bounds.first  = -(1 << (fixed_point_position));
-                bounds.second = 1 << (fixed_point_position);
+                case ActivationLayerInfo::ActivationFunction::SQUARE:
+                case ActivationLayerInfo::ActivationFunction::LOGISTIC:
+                case ActivationLayerInfo::ActivationFunction::SOFT_RELU:
+                    // Reduce range as exponent overflows
+                    bounds = std::make_pair(-10._h, 10._h);
+                    break;
+                case ActivationLayerInfo::ActivationFunction::SQRT:
+                    // Reduce range as sqrt should take a non-negative number
+                    bounds = std::make_pair(0._h, 255._h);
+                    break;
+                default:
+                    bounds = std::make_pair(-255._h, 255._h);
+                    break;
             }
             break;
-        case ActivationLayerInfo::ActivationFunction::TANH:
-            // Reduce range as exponent overflows
-            if(!is_float)
+        }
+        case DataType::F32:
+            switch(activation)
             {
-                bounds.first  = -(1 << (fixed_point_position));
-                bounds.second = 1 << (fixed_point_position);
+                case ActivationLayerInfo::ActivationFunction::LOGISTIC:
+                case ActivationLayerInfo::ActivationFunction::SOFT_RELU:
+                    // Reduce range as exponent overflows
+                    bounds = std::make_pair(-40.f, 40.f);
+                    break;
+                case ActivationLayerInfo::ActivationFunction::SQRT:
+                    // Reduce range as sqrt should take a non-negative number
+                    bounds = std::make_pair(0.f, 255.f);
+                    break;
+                default:
+                    bounds = std::make_pair(-255.f, 255.f);
+                    break;
             }
             break;
-        case ActivationLayerInfo::ActivationFunction::SQRT:
-            // Reduce range as sqrt should take a non-negative number
-            bounds.first = (is_float) ? 0 : 1;
-            break;
-        default:
-            break;
-    }
-    return bounds;
-}
-/** Helper function to get the testing range for batch normalization layer.
- *
- * @param[in] fixed_point_position (Optional) Number of bits for the fractional part. Defaults to 1.
- *
- * @return A pair containing the lower upper testing bounds.
- */
-template <typename T>
-std::pair<T, T> get_batchnormalization_layer_test_bounds(int fixed_point_position = 1)
-{
-    bool is_float = std::is_floating_point<T>::value;
-    std::pair<T, T> bounds;
-
-    // Set initial values
-    if(is_float)
-    {
-        bounds = std::make_pair(-1.f, 1.f);
-    }
-    else
-    {
-        bounds = std::make_pair(1, 1 << (fixed_point_position));
-    }
-
-    return bounds;
-}
-
-/** Fill mask with the corresponding given pattern.
- *
- * @param[in,out] mask    Mask to be filled according to pattern
- * @param[in]     cols    Columns (width) of mask
- * @param[in]     rows    Rows (height) of mask
- * @param[in]     pattern Pattern to fill the mask according to
- */
-inline void fill_mask_from_pattern(uint8_t *mask, int cols, int rows, MatrixPattern pattern)
-{
-    unsigned int                v = 0;
-    std::mt19937                gen(user_config.seed.get());
-    std::bernoulli_distribution dist(0.5);
-
-    for(int r = 0; r < rows; ++r)
-    {
-        for(int c = 0; c < cols; ++c, ++v)
-        {
-            uint8_t val = 0;
-
-            switch(pattern)
+        case DataType::QS8:
+        case DataType::QS16:
+            switch(activation)
             {
-                case MatrixPattern::BOX:
-                    val = 255;
-                    break;
-                case MatrixPattern::CROSS:
-                    val = ((r == (rows / 2)) || (c == (cols / 2))) ? 255 : 0;
-                    break;
-                case MatrixPattern::DISK:
-                    val = (((r - rows / 2.0f + 0.5f) * (r - rows / 2.0f + 0.5f)) / ((rows / 2.0f) * (rows / 2.0f)) + ((c - cols / 2.0f + 0.5f) * (c - cols / 2.0f + 0.5f)) / ((cols / 2.0f) *
-                            (cols / 2.0f))) <= 1.0f ? 255 : 0;
+                case ActivationLayerInfo::ActivationFunction::LOGISTIC:
+                case ActivationLayerInfo::ActivationFunction::SOFT_RELU:
+                case ActivationLayerInfo::ActivationFunction::TANH:
+                    // Reduce range as exponent overflows
+                    bounds = std::make_pair(-(1 << fixed_point_position), 1 << fixed_point_position);
                     break;
-                case MatrixPattern::OTHER:
-                    val = (dist(gen) ? 0 : 255);
+                case ActivationLayerInfo::ActivationFunction::SQRT:
+                    // Reduce range as sqrt should take a non-negative number
+                    // Can't be zero either as inv_sqrt is used in NEON.
+                    bounds = std::make_pair(1, std::numeric_limits<T>::max());
                     break;
                 default:
-                    return;
+                    bounds = std::make_pair(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
+                    break;
             }
-
-            mask[v] = val;
-        }
+            break;
+        default:
+            ARM_COMPUTE_ERROR("Unsupported data type");
     }
 
-    if(pattern == MatrixPattern::OTHER)
-    {
-        std::uniform_int_distribution<uint8_t> distribution_u8(0, ((cols * rows) - 1));
-        mask[distribution_u8(gen)] = 255;
-    }
+    return bounds;
 }
 
 /** Calculate output tensor shape give a vector of input tensor to concatenate
@@ -204,69 +135,7 @@ inline void fill_mask_from_pattern(uint8_t *mask, int cols, int rows, MatrixPatt
  *
  * @return The shape of output concatenated tensor.
  */
-inline TensorShape calculate_depth_concatenate_shape(std::vector<TensorShape> input_shapes)
-{
-    TensorShape out_shape = input_shapes.at(0);
-
-    unsigned int max_x = 0;
-    unsigned int max_y = 0;
-    unsigned int depth = 0;
-
-    for(auto const &shape : input_shapes)
-    {
-        max_x = std::max<unsigned int>(shape.x(), max_x);
-        max_y = std::max<unsigned int>(shape.y(), max_y);
-        depth += shape.z();
-    }
-
-    out_shape.set(0, max_x);
-    out_shape.set(1, max_y);
-    out_shape.set(2, depth);
-
-    return out_shape;
-}
-
-/** Fill matrix random.
- *
- * @param[in,out] matrix Matrix
- * @param[in]     cols   Columns (width) of matrix
- * @param[in]     rows   Rows (height) of matrix
- */
-template <std::size_t SIZE>
-inline void fill_warp_matrix(std::array<float, SIZE> &matrix, int cols, int rows)
-{
-    std::mt19937                          gen(user_config.seed.get());
-    std::uniform_real_distribution<float> dist(-1, 1);
-
-    for(int v = 0, r = 0; r < rows; ++r)
-    {
-        for(int c = 0; c < cols; ++c, ++v)
-        {
-            matrix[v] = dist(gen);
-        }
-    }
-    if(SIZE == 9)
-    {
-        matrix[(cols * rows) - 1] = 1;
-    }
-}
-
-/** Helper function to fill the Lut random by a ILutAccessor.
- *
- * @param[in,out] table Accessor at the Lut.
- *
- */
-template <typename T>
-void fill_lookuptable(T &&table)
-{
-    std::mt19937                                          generator(user_config.seed.get());
-    std::uniform_int_distribution<typename T::value_type> distribution(std::numeric_limits<typename T::value_type>::min(), std::numeric_limits<typename T::value_type>::max());
-
-    for(int i = std::numeric_limits<typename T::value_type>::min(); i <= std::numeric_limits<typename T::value_type>::max(); i++)
-    {
-        table[i] = distribution(generator);
-    }
-}
+TensorShape calculate_depth_concatenate_shape(const std::vector<TensorShape> &input_shapes);
 } // namespace validation
 } // namespace test
 } // namespace arm_compute