IVGCVSW-7879 Change REVERSE_V2 from LayerWithParameters with 1 input, to Layer with 2 inputs

  * Changing ReverseV2 to use two inputs
  * This is required by the backends
  * The ReverseV2Descriptor was removed
  * Tests updated
  * Added a Run<> templatefor inputs with different data types

Signed-off-by: Tracy Narine <tracy.narine@arm.com>
Change-Id: I22f947de829b4b3da6bda3a74f4ffdef4052cc25

5 files changed, 44 insertions, 25 deletions

diff --git a/src/armnn/BackendHelper.cpp b/src/armnn/BackendHelper.cpp
index 404d278efc..18184fbfb2 100644
--- a/src/armnn/BackendHelper.cpp
+++ b/src/armnn/BackendHelper.cpp
@@ -1211,16 +1211,16 @@ bool LayerSupportHandle::IsResizeSupported(const TensorInfo& input,
                                             reasonIfUnsupported);
 }
 
-bool LayerSupportHandle::IsReverseV2Supported(const armnn::TensorInfo &input,
+bool LayerSupportHandle::IsReverseV2Supported(const armnn::TensorInfo &input0,
+                                              const armnn::TensorInfo &input1,
                                               const armnn::TensorInfo &output,
-                                              const armnn::ReverseV2Descriptor &descriptor,
                                               Optional<std::string &> reasonIfUnsupported)
 {
-    TensorInfos infos{input, output};
+    TensorInfos infos{input0, input1, output};
 
     return m_LayerSupport->IsLayerSupported(LayerType::ReverseV2,
                                             infos,
-                                            descriptor,
+                                            BaseDescriptor(),
                                             EmptyOptional(),
                                             EmptyOptional(),
                                             reasonIfUnsupported);
diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp
index ae5bde17ca..010fa0076b 100644
--- a/src/armnn/Network.cpp
+++ b/src/armnn/Network.cpp
@@ -639,10 +639,9 @@ IConnectableLayer* INetwork::AddBatchMatMulLayer(const BatchMatMulDescriptor &de
     return pNetworkImpl->AddBatchMatMulLayer(descriptor, name);
 }
 
-IConnectableLayer* INetwork::AddReverseV2Layer(const ReverseV2Descriptor &descriptor,
-                                               const char *name)
+IConnectableLayer* INetwork::AddReverseV2Layer(const char *name)
 {
-    return pNetworkImpl->AddReverseV2Layer(descriptor, name);
+    return pNetworkImpl->AddReverseV2Layer(name);
 }
 
 void INetwork::ExecuteStrategy(IStrategy& strategy) const
@@ -2930,9 +2929,9 @@ IConnectableLayer* NetworkImpl::AddBatchMatMulLayer(const BatchMatMulDescriptor&
     return m_Graph->AddLayer<BatchMatMulLayer>(desc, name);
 }
 
-IConnectableLayer* NetworkImpl::AddReverseV2Layer(const ReverseV2Descriptor &desc, const char *name)
+IConnectableLayer* NetworkImpl::AddReverseV2Layer(const char *name)
 {
-    return m_Graph->AddLayer<ReverseV2Layer>(desc, name);
+    return m_Graph->AddLayer<ReverseV2Layer>(name);
 }
 
 IConnectableLayer* NetworkImpl::AddPrecompiledLayer(const PreCompiledDescriptor& preCompiledDescriptor,
diff --git a/src/armnn/Network.hpp b/src/armnn/Network.hpp
index fc3ae42aa9..ae287f32d1 100644
--- a/src/armnn/Network.hpp
+++ b/src/armnn/Network.hpp
@@ -188,8 +188,7 @@ public:
     IConnectableLayer* AddReshapeLayer(const ReshapeDescriptor& reshapeDescriptor,
                                        const char* name = nullptr);
 
-    IConnectableLayer* AddReverseV2Layer(const ReverseV2Descriptor& ReverseV2Descriptor,
-                                         const char* name = nullptr);
+    IConnectableLayer* AddReverseV2Layer(const char* name = nullptr);
 
     IConnectableLayer* AddShapeLayer(const char* name = nullptr);
 
diff --git a/src/armnn/layers/ReverseV2Layer.cpp b/src/armnn/layers/ReverseV2Layer.cpp
index 201e19819b..e1160b6e16 100644
--- a/src/armnn/layers/ReverseV2Layer.cpp
+++ b/src/armnn/layers/ReverseV2Layer.cpp
@@ -10,9 +10,10 @@
 
 namespace armnn
 {
-ReverseV2Layer::ReverseV2Layer(const armnn::ReverseV2Descriptor &param, const char *name)
-    : LayerWithParameters(1, 1, LayerType::ReverseV2, param, name)
-{}
+ReverseV2Layer::ReverseV2Layer(const char* name)
+    : Layer(2, 1, LayerType::ReverseV2, name)
+{
+}
 
 std::unique_ptr<IWorkload> ReverseV2Layer::CreateWorkload(const armnn::IWorkloadFactory &factory) const
 {
@@ -24,27 +25,48 @@ std::unique_ptr<IWorkload> ReverseV2Layer::CreateWorkload(const armnn::IWorkload
 
 ReverseV2Layer* ReverseV2Layer::Clone(armnn::Graph &graph) const
 {
-    auto layer = CloneBase<ReverseV2Layer>(graph, m_Param, GetName());
+    auto layer = CloneBase<ReverseV2Layer>(graph, GetName());
 
     return std::move(layer);
 }
 
-/// Use the default Layer::InferOutputShape method
+std::vector<TensorShape> ReverseV2Layer::InferOutputShapes(const std::vector<TensorShape>& inputShapes) const
+{
+    ARMNN_ASSERT(inputShapes.size() == 2);
+
+    const auto inputDims = inputShapes[0].GetNumDimensions();
+
+    std::vector<unsigned int> dimSizes(inputDims);
+    for (unsigned i=0;  i<inputDims;  i++)
+    {
+        dimSizes[i] = inputShapes[0][i];
+    }
+
+    TensorShape outputShape({ inputDims, dimSizes.data() });
+
+    return std::vector<TensorShape>({ outputShape });
+}
 
 void ReverseV2Layer::ValidateTensorShapesFromInputs()
 {
-    VerifyLayerConnections(1, CHECK_LOCATION());
+    VerifyLayerConnections(2, CHECK_LOCATION());
 
     const TensorShape& outputShape = GetOutputSlot(0).GetTensorInfo().GetShape();
 
     VerifyShapeInferenceType(outputShape, m_ShapeInferenceMethod);
 
     auto inferredShapes = InferOutputShapes({
-        GetInputSlot(0).GetTensorInfo().GetShape() });
+        GetInputSlot(0).GetTensorInfo().GetShape(),
+        GetInputSlot(1).GetTensorInfo().GetShape()});
 
     ARMNN_ASSERT(inferredShapes.size() == 1);
 
     ValidateAndCopyShape(outputShape, inferredShapes[0], m_ShapeInferenceMethod, "ReverseV2Layer");
 }
 
-}
\ No newline at end of file
+void ReverseV2Layer::ExecuteStrategy(IStrategy& strategy) const
+{
+    strategy.ExecuteStrategy(this, BaseDescriptor(), {}, GetName());
+}
+
+}
diff --git a/src/armnn/layers/ReverseV2Layer.hpp b/src/armnn/layers/ReverseV2Layer.hpp
index 046670e9de..7dc0656aca 100644
--- a/src/armnn/layers/ReverseV2Layer.hpp
+++ b/src/armnn/layers/ReverseV2Layer.hpp
@@ -11,7 +11,7 @@ namespace armnn
 {
 
     /// This layer represents a ReverseV2 operation.
-    class ReverseV2Layer : public LayerWithParameters<ReverseV2Descriptor>
+    class ReverseV2Layer : public Layer
     {
     public:
         /// Makes a workload for the ReverseV2 type.
@@ -28,19 +28,18 @@ namespace armnn
         /// otherwise infers the output shapes from given input shapes and layer properties.
         /// @param [in] inputShapes The vector of input shapes for ReverseV2.
         /// @return A vector to the inferred output shape.
-
-        /// Use the default Layer::InferOutputShape method
-        // std::vector<TensorShape> InferOutputShapes(const std::vector<TensorShape>& inputShapes) const override;
+        std::vector<TensorShape> InferOutputShapes(const std::vector<TensorShape>& inputShapes) const override;
 
         /// Check if the input tensor shape(s)
         /// will lead to a valid configuration of @ref ReverseV2Layer.
         void ValidateTensorShapesFromInputs() override;
 
+        void ExecuteStrategy(IStrategy& strategy) const override;
+
     protected:
         /// Constructor to create a ReverseV2Layer.
-        /// @param [in] param ReverseV2Descriptor to configure the ReverseV2 operation.
         /// @param [in] name Optional name for the layer.
-        ReverseV2Layer(const ReverseV2Descriptor& param, const char* name);
+        ReverseV2Layer(const char* name);
 
         /// Default destructor
         ~ReverseV2Layer() = default;