COMPMID-676: Rework TensorInfo building

Change-Id: Ic98f64ffe30739437a1fe31ef98d83ee900741e3
Reviewed-on: http://mpd-gerrit.cambridge.arm.com/95512
Reviewed-by: Michalis Spyrou <michalis.spyrou@arm.com>
Tested-by: Kaizen <jeremy.johnson+kaizengerrit@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>

12 files changed, 212 insertions, 48 deletions

diff --git a/arm_compute/core/Dimensions.h b/arm_compute/core/Dimensions.h
index 70b6e1a301..3d9a3fa7ff 100644
--- a/arm_compute/core/Dimensions.h
+++ b/arm_compute/core/Dimensions.h
@@ -179,5 +179,16 @@ protected:
     std::array<T, num_max_dimensions> _id;
     size_t _num_dimensions{ 0 };
 };
+
+template <typename T>
+inline bool operator==(const Dimensions<T> &lhs, const Dimensions<T> &rhs)
+{
+    return ((lhs.num_dimensions() == rhs.num_dimensions()) && std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()));
+}
+template <typename T>
+inline bool operator!=(const Dimensions<T> &lhs, const Dimensions<T> &rhs)
+{
+    return !(lhs == rhs);
+}
 }
 #endif /*__ARM_COMPUTE_DIMENSIONS_H__*/
diff --git a/arm_compute/core/Helpers.h b/arm_compute/core/Helpers.h
index edb05e99a1..13d1f6c99f 100644
--- a/arm_compute/core/Helpers.h
+++ b/arm_compute/core/Helpers.h
@@ -476,6 +476,15 @@ bool auto_init_if_empty(ITensorInfo       &info,
                         int              fixed_point_position,
                         QuantizationInfo quantization_info = QuantizationInfo());
 
+/** Auto initialize the tensor info using another tensor info.
+ *
+ * @param info_sink   Tensor info used to check and assign
+ * @param info_source Tensor info used to assign
+ *
+ * @return True if the tensor info has been initialized
+ */
+bool auto_init_if_empty(ITensorInfo &info_sink, ITensorInfo &info_source);
+
 /* Set the shape to the specified value if the current assignment is empty.
  *
  * @param[in,out] info  Tensor info used to check and assign.
diff --git a/arm_compute/core/Helpers.inl b/arm_compute/core/Helpers.inl
index 656956d00a..1e565344b7 100644
--- a/arm_compute/core/Helpers.inl
+++ b/arm_compute/core/Helpers.inl
@@ -217,6 +217,21 @@ inline bool auto_init_if_empty(ITensorInfo       &info,
     return false;
 }
 
+inline bool auto_init_if_empty(ITensorInfo &info_sink, ITensorInfo &info_source)
+{
+    if(info_sink.tensor_shape().total_size() == 0)
+    {
+        info_sink.set_data_type(info_source.data_type());
+        info_sink.set_num_channels(info_source.num_channels());
+        info_sink.set_tensor_shape(info_source.tensor_shape());
+        info_sink.set_fixed_point_position(info_source.fixed_point_position());
+        info_sink.set_quantization_info(info_source.quantization_info());
+        return true;
+    }
+
+    return false;
+}
+
 inline bool set_shape_if_empty(ITensorInfo &info, const TensorShape &shape)
 {
     if(info.tensor_shape().total_size() == 0)
diff --git a/arm_compute/core/ITensorInfo.h b/arm_compute/core/ITensorInfo.h
index 09351522dd..5e8d4e8136 100644
--- a/arm_compute/core/ITensorInfo.h
+++ b/arm_compute/core/ITensorInfo.h
@@ -29,13 +29,14 @@
 #include "arm_compute/core/TensorShape.h"
 #include "arm_compute/core/Types.h"
 #include "arm_compute/core/Utils.h"
+#include "arm_compute/core/utils/misc/ICloneable.h"
 
 #include <cstddef>
 
 namespace arm_compute
 {
 /** Store the tensor's metadata */
-class ITensorInfo
+class ITensorInfo : public misc::ICloneable<ITensorInfo>
 {
 public:
     /** Default virtual destructor */
@@ -45,15 +46,19 @@ public:
      * @warning This resets the format to UNKNOWN.
      *
      * @param[in] data_type The new data type.
+     *
+     * @return Reference to this ITensorInfo object
      */
-    virtual void set_data_type(DataType data_type) = 0;
+    virtual ITensorInfo &set_data_type(DataType data_type) = 0;
     /** Set the number of channels to the specified value.
      *
      * @warning This resets the format to UNKNOWN.
      *
      * @param[in] num_channels New number of channels.
+     *
+     * @return Reference to this ITensorInfo object
      */
-    virtual void set_num_channels(int num_channels) = 0;
+    virtual ITensorInfo &set_num_channels(int num_channels) = 0;
     /** Set the format of an already initialized tensor.
      *
      * @note If the data type has already been configured (i.e. not UNKNOWN) it
@@ -61,23 +66,36 @@ public:
      * be based on the format.
      *
      * @param[in] format Single-plane format of the tensor.
+     *
+     * @return Reference to this ITensorInfo object
      */
-    virtual void set_format(Format format) = 0;
+    virtual ITensorInfo &set_format(Format format) = 0;
     /** Set the shape of an already initialized tensor.
      *
      * @warning Changing the shape requires to recompute the strides and is
      * therefore only possible if the tensor hasn't been allocated yet.
      *
      * @param[in] shape New tensor shape.
+     *
+     * @return Reference to this ITensorInfo object
      */
-    virtual void set_tensor_shape(TensorShape shape) = 0;
+    virtual ITensorInfo &set_tensor_shape(TensorShape shape) = 0;
     /** Set the fixed point position to the specified value
      *
      * @warning The fixed point position must be set once the data type has been configured
      *
      * @param[in] fixed_point_position The new fixed point position
+     *
+     * @return Reference to this ITensorInfo object
      */
-    virtual void set_fixed_point_position(int fixed_point_position) = 0;
+    virtual ITensorInfo &set_fixed_point_position(int fixed_point_position) = 0;
+    /** Set the quantization settings (scale and offset) of the tensor.
+    *
+    * @param[in] quantization_info QuantizationInfo containing the scale and offset
+    *
+    * @return Reference to this ITensorInfo object
+    */
+    virtual ITensorInfo &set_quantization_info(QuantizationInfo quantization_info) = 0;
     /** Update the offset to the first element and the strides to automatically computed values.
      *
      * @note The padding used by this method is really conservative so that the tensor can be used for most functions.
@@ -196,12 +214,6 @@ public:
     * @return A QuantizationInfo containing the scale and offset.
     */
     virtual QuantizationInfo quantization_info() const = 0;
-
-    /** Set the quantization settings (scale and offset) of the tensor.
-    *
-    * @param[in] quantization_info QuantizationInfo containing the scale and offset.
-    */
-    virtual void set_quantization_info(QuantizationInfo quantization_info) = 0;
 };
 }
 #endif /*__ARM_COMPUTE_TENSORINFO_H__ */
diff --git a/arm_compute/core/SubTensorInfo.h b/arm_compute/core/SubTensorInfo.h
index 3a88ebae5a..5fec11a2e8 100644
--- a/arm_compute/core/SubTensorInfo.h
+++ b/arm_compute/core/SubTensorInfo.h
@@ -34,6 +34,7 @@
 #include "arm_compute/core/Validate.h"
 
 #include <cstddef>
+#include <memory>
 
 namespace arm_compute
 {
@@ -50,7 +51,7 @@ public:
      *                         X and Y dimensions must match the parent's ones.
      * @param[in] coords       Coordinates of starting element inside parent tensor.
      */
-    SubTensorInfo(ITensorInfo *parent, const TensorShape &tensor_shape, const Coordinates &coords);
+    SubTensorInfo(ITensorInfo *parent, TensorShape tensor_shape, Coordinates coords);
     /** Default destructor */
     ~SubTensorInfo() = default;
     /** Allow instances of this class to be copy constructed */
@@ -71,27 +72,38 @@ public:
     }
 
     // Inherited methods overridden:
-    void set_data_type(DataType data_type) override
+    std::unique_ptr<ITensorInfo> clone() const override;
+    ITensorInfo &set_data_type(DataType data_type) override
     {
         ARM_COMPUTE_ERROR_ON(_parent == nullptr);
         _parent->set_data_type(data_type);
+        return *this;
     };
-    void set_num_channels(int num_channels) override
+    ITensorInfo &set_num_channels(int num_channels) override
     {
         ARM_COMPUTE_ERROR_ON(_parent == nullptr);
         _parent->set_num_channels(num_channels);
+        return *this;
     };
-    void set_format(Format format) override
+    ITensorInfo &set_format(Format format) override
     {
         ARM_COMPUTE_ERROR_ON(_parent == nullptr);
         _parent->set_format(format);
+        return *this;
     };
-    void set_fixed_point_position(int fixed_point_position) override
+    ITensorInfo &set_fixed_point_position(int fixed_point_position) override
     {
         ARM_COMPUTE_ERROR_ON(_parent == nullptr);
         _parent->set_fixed_point_position(fixed_point_position);
+        return *this;
     };
-    void set_tensor_shape(TensorShape shape) override;
+    ITensorInfo &set_tensor_shape(TensorShape shape) override;
+    ITensorInfo &set_quantization_info(QuantizationInfo quantization_info) override
+    {
+        ARM_COMPUTE_ERROR_ON(_parent == nullptr);
+        _parent->set_quantization_info(quantization_info);
+        return *this;
+    }
     bool auto_padding() override
     {
         ARM_COMPUTE_ERROR_ON(_parent == nullptr);
@@ -191,11 +203,6 @@ public:
         ARM_COMPUTE_ERROR_ON(_parent == nullptr);
         return _parent->quantization_info();
     }
-    void set_quantization_info(QuantizationInfo quantization_info) override
-    {
-        ARM_COMPUTE_ERROR_ON(_parent == nullptr);
-        _parent->set_quantization_info(quantization_info);
-    }
 
 private:
     ITensorInfo *_parent;
diff --git a/arm_compute/core/TensorInfo.h b/arm_compute/core/TensorInfo.h
index 5d1ee7c578..2383f2db21 100644
--- a/arm_compute/core/TensorInfo.h
+++ b/arm_compute/core/TensorInfo.h
@@ -34,6 +34,7 @@
 #include "arm_compute/core/Utils.h"
 
 #include <cstddef>
+#include <memory>
 
 namespace arm_compute
 {
@@ -212,11 +213,13 @@ public:
     size_t init_auto_padding(const HOGInfo &hog_info, unsigned int width, unsigned int height);
 
     // Inherited methods overridden:
-    void set_data_type(DataType data_type) override;
-    void set_num_channels(int num_channels) override;
-    void set_format(Format format) override;
-    void set_tensor_shape(TensorShape shape) override;
-    void set_fixed_point_position(int fixed_point_position) override;
+    std::unique_ptr<ITensorInfo> clone() const override;
+    ITensorInfo &set_data_type(DataType data_type) override;
+    ITensorInfo &set_num_channels(int num_channels) override;
+    ITensorInfo &set_format(Format format) override;
+    ITensorInfo &set_tensor_shape(TensorShape shape) override;
+    ITensorInfo &set_fixed_point_position(int fixed_point_position) override;
+    ITensorInfo &set_quantization_info(QuantizationInfo quantization_info) override;
     bool auto_padding() override;
     bool extend_padding(const PaddingSize &padding) override;
     size_t dimension(size_t index) const override
@@ -292,10 +295,6 @@ public:
     {
         return _quantization_info;
     }
-    void set_quantization_info(QuantizationInfo quantization_info) override
-    {
-        _quantization_info = quantization_info;
-    }
 
 private:
     /** Calculates strides, offset and total size resulting from the specified padding around the XY plane.
diff --git a/arm_compute/core/utils/misc/ICloneable.h b/arm_compute/core/utils/misc/ICloneable.h
new file mode 100644
index 0000000000..5852f14f7a
--- /dev/null
+++ b/arm_compute/core/utils/misc/ICloneable.h
@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+#ifndef __ARM_COMPUTE_MISC_ICLONEABLE_H__
+#define __ARM_COMPUTE_MISC_ICLONEABLE_H__
+
+#include <memory>
+
+namespace arm_compute
+{
+namespace misc
+{
+/** Clonable Interface */
+template <class T>
+class ICloneable
+{
+public:
+    /** Default virtual desctructor */
+    virtual ~ICloneable() = default;
+    /** Provide a clone of the current object of class T
+     *
+     * @return Clone object of class T
+     */
+    virtual std::unique_ptr<T> clone() const = 0;
+};
+} // namespace misc
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_MISC_ICLONEABLE_H__ */
diff --git a/src/core/CL/kernels/CLSoftmaxLayerKernel.cpp b/src/core/CL/kernels/CLSoftmaxLayerKernel.cpp
index af4fd88593..5331f40838 100644
--- a/src/core/CL/kernels/CLSoftmaxLayerKernel.cpp
+++ b/src/core/CL/kernels/CLSoftmaxLayerKernel.cpp
@@ -386,11 +386,7 @@ void CLLogits1DNormKernel::configure(const ICLTensor *input, const ICLTensor *su
 
     // Output auto initialization if not yet initialized
     auto_init_if_empty(*output->info(),
-                       input->info()->tensor_shape(),
-                       1,
-                       output_data_type,
-                       input->info()->fixed_point_position(),
-                       allowed_quantization_info);
+                       input->info()->clone()->set_data_type(output_data_type).set_quantization_info(allowed_quantization_info));
 
     ARM_COMPUTE_ERROR_ON_MISMATCHING_SHAPES(input, output);
     if(!is_quantized_asymmetric)
diff --git a/src/core/SubTensorInfo.cpp b/src/core/SubTensorInfo.cpp
index 878283bd8e..4c558bfae9 100644
--- a/src/core/SubTensorInfo.cpp
+++ b/src/core/SubTensorInfo.cpp
@@ -26,6 +26,7 @@
 #include "arm_compute/core/Error.h"
 #include "arm_compute/core/Helpers.h"
 #include "arm_compute/core/Validate.h"
+#include "support/ToolchainSupport.h"
 
 using namespace arm_compute;
 
@@ -34,7 +35,7 @@ SubTensorInfo::SubTensorInfo()
 {
 }
 
-SubTensorInfo::SubTensorInfo(ITensorInfo *parent, const TensorShape &tensor_shape, const Coordinates &coords)
+SubTensorInfo::SubTensorInfo(ITensorInfo *parent, TensorShape tensor_shape, Coordinates coords)
     : _parent(parent), _tensor_shape(tensor_shape), _coords(coords), _valid_region{ Coordinates(), _tensor_shape }
 {
     ARM_COMPUTE_ERROR_ON(parent == nullptr);
@@ -50,7 +51,12 @@ SubTensorInfo::SubTensorInfo(ITensorInfo *parent, const TensorShape &tensor_shap
     _valid_region = ValidRegion{ coordinates, _tensor_shape };
 }
 
-void SubTensorInfo::set_tensor_shape(TensorShape shape)
+std::unique_ptr<ITensorInfo> SubTensorInfo::clone() const
+{
+    return support::cpp14::make_unique<SubTensorInfo>(*this);
+}
+
+ITensorInfo &SubTensorInfo::set_tensor_shape(TensorShape shape)
 {
     ARM_COMPUTE_ERROR_ON(_parent == nullptr);
     // Check if subtensor is valid if parent is configured
@@ -59,6 +65,7 @@ void SubTensorInfo::set_tensor_shape(TensorShape shape)
         ARM_COMPUTE_ERROR_ON_INVALID_SUBTENSOR(_parent->tensor_shape(), _coords, shape);
     }
     _tensor_shape = shape;
+    return *this;
 }
 
 bool SubTensorInfo::extend_padding(const PaddingSize &padding)
diff --git a/src/core/TensorInfo.cpp b/src/core/TensorInfo.cpp
index f3cd776497..a49b7b7e02 100644
--- a/src/core/TensorInfo.cpp
+++ b/src/core/TensorInfo.cpp
@@ -28,6 +28,7 @@
 #include "arm_compute/core/Helpers.h"
 #include "arm_compute/core/TensorInfo.h"
 #include "arm_compute/core/Validate.h"
+#include "support/ToolchainSupport.h"
 
 using namespace arm_compute;
 
@@ -314,19 +315,26 @@ bool TensorInfo::extend_padding(const PaddingSize &padding)
     return updated;
 }
 
-void TensorInfo::set_data_type(DataType data_type)
+std::unique_ptr<ITensorInfo> TensorInfo::clone() const
+{
+    return support::cpp14::make_unique<TensorInfo>(*this);
+}
+
+ITensorInfo &TensorInfo::set_data_type(DataType data_type)
 {
     _data_type = data_type;
     _format    = Format::UNKNOWN;
+    return *this;
 }
 
-void TensorInfo::set_num_channels(int num_channels)
+ITensorInfo &TensorInfo::set_num_channels(int num_channels)
 {
     _num_channels = num_channels;
     _format       = Format::UNKNOWN;
+    return *this;
 }
 
-void TensorInfo::set_format(Format format)
+ITensorInfo &TensorInfo::set_format(Format format)
 {
     _format = format;
 
@@ -340,9 +348,10 @@ void TensorInfo::set_format(Format format)
         ARM_COMPUTE_ERROR_ON(num_channels_from_format(format) != _num_channels);
         ARM_COMPUTE_ERROR_ON(data_type_from_format(format) != _data_type);
     }
+    return *this;
 }
 
-void TensorInfo::set_tensor_shape(TensorShape shape)
+ITensorInfo &TensorInfo::set_tensor_shape(TensorShape shape)
 {
     _tensor_shape                  = shape;
     _offset_first_element_in_bytes = 0;
@@ -361,13 +370,21 @@ void TensorInfo::set_tensor_shape(TensorShape shape)
     Coordinates coordinates;
     coordinates.set_num_dimensions(_tensor_shape.num_dimensions());
     _valid_region = ValidRegion{ coordinates, _tensor_shape };
+    return *this;
 }
 
-void TensorInfo::set_fixed_point_position(int fixed_point_position)
+ITensorInfo &TensorInfo::set_fixed_point_position(int fixed_point_position)
 {
     ARM_COMPUTE_ERROR_ON(_data_type == DataType::QS8 && (fixed_point_position < 1 || fixed_point_position > 6));
     ARM_COMPUTE_ERROR_ON(_data_type == DataType::QS16 && (fixed_point_position < 1 || fixed_point_position > 14));
     _fixed_point_position = fixed_point_position;
+    return *this;
+}
+
+ITensorInfo &TensorInfo::set_quantization_info(QuantizationInfo quantization_info)
+{
+    _quantization_info = quantization_info;
+    return *this;
 }
 
 size_t TensorInfo::offset_element_in_bytes(const Coordinates &pos) const
diff --git a/tests/SConscript b/tests/SConscript
index 311eeedde1..567ac4328e 100644
--- a/tests/SConscript
+++ b/tests/SConscript
@@ -80,9 +80,6 @@ common_objects = [test_env.StaticObject(f) for f in common_files]
 files_benchmark = Glob('benchmark/*.cpp')
 files_validation = Glob('validation/*.cpp')
 
-# Add unit tests
-files_validation += Glob('validation/UNIT/*.cpp')
-
 # Always compile reference for validation
 files_validation += Glob('validation/CPP/*.cpp')
 
diff --git a/tests/validation/UNIT/TensorInfo.cpp b/tests/validation/UNIT/TensorInfo.cpp
index 2a6c3365ea..dd7ae6d18c 100644
--- a/tests/validation/UNIT/TensorInfo.cpp
+++ b/tests/validation/UNIT/TensorInfo.cpp
@@ -36,10 +36,11 @@ namespace test
 namespace validation
 {
 TEST_SUITE(UNIT)
-TEST_SUITE(TensorInfoValidation)
+TEST_SUITE(TensorInfo)
 
 // *INDENT-OFF*
 // clang-format off
+/** Validates TensorInfo Autopadding */
 DATA_TEST_CASE(AutoPadding, framework::DatasetMode::ALL, zip(zip(zip(
                framework::dataset::make("TensorShape", {
                TensorShape{},
@@ -82,6 +83,51 @@ DATA_TEST_CASE(AutoPadding, framework::DatasetMode::ALL, zip(zip(zip(
 // clang-format on
 // *INDENT-ON*
 
+/** Validates that TensorInfo is clonable */
+TEST_CASE(Clone, framework::DatasetMode::ALL)
+{
+    // Create tensor info
+    TensorInfo info(TensorShape(23U, 17U, 3U), // tensor shape
+                    1,                         // number of channels
+                    DataType::F32);            // data type
+
+    // Get clone of current tensor info
+    std::unique_ptr<ITensorInfo> info_clone = info.clone();
+    ARM_COMPUTE_EXPECT(info_clone != nullptr, framework::LogLevel::ERRORS);
+    ARM_COMPUTE_EXPECT(info_clone->total_size() == info.total_size(), framework::LogLevel::ERRORS);
+    ARM_COMPUTE_EXPECT(info_clone->num_channels() == info.num_channels(), framework::LogLevel::ERRORS);
+    ARM_COMPUTE_EXPECT(info_clone->data_type() == info.data_type(), framework::LogLevel::ERRORS);
+}
+
+/** Validates that TensorInfo can chain multiple set commands */
+TEST_CASE(TensorInfoBuild, framework::DatasetMode::ALL)
+{
+    // Create tensor info
+    TensorInfo info(TensorShape(23U, 17U, 3U), // tensor shape
+                    1,                         // number of channels
+                    DataType::F32);            // data type
+
+    // Update data type and number of channels
+    info.set_data_type(DataType::S32).set_num_channels(3);
+    ARM_COMPUTE_EXPECT(info.data_type() == DataType::S32, framework::LogLevel::ERRORS);
+    ARM_COMPUTE_EXPECT(info.num_channels() == 3, framework::LogLevel::ERRORS);
+
+    // Update data type channels and set fixed point position
+    info.set_data_type(DataType::QS8).set_num_channels(1).set_fixed_point_position(3);
+    ARM_COMPUTE_EXPECT(info.data_type() == DataType::QS8, framework::LogLevel::ERRORS);
+    ARM_COMPUTE_EXPECT(info.num_channels() == 1, framework::LogLevel::ERRORS);
+    ARM_COMPUTE_EXPECT(info.fixed_point_position() == 3, framework::LogLevel::ERRORS);
+
+    // Update data type and set quantization info
+    info.set_data_type(DataType::QASYMM8).set_quantization_info(QuantizationInfo(0.5f, 15));
+    ARM_COMPUTE_EXPECT(info.data_type() == DataType::QASYMM8, framework::LogLevel::ERRORS);
+    ARM_COMPUTE_EXPECT(info.quantization_info() == QuantizationInfo(0.5f, 15), framework::LogLevel::ERRORS);
+
+    // Update tensor shape
+    info.set_tensor_shape(TensorShape(13U, 15U));
+    ARM_COMPUTE_EXPECT(info.tensor_shape() == TensorShape(13U, 15U), framework::LogLevel::ERRORS);
+}
+
 TEST_SUITE_END() // TensorInfoValidation
 TEST_SUITE_END()
 } // namespace validation