MLCE-510 Add CpuRef Shape Operator to ArmNN

 * Add front end
 * Add reference workload
 * Serialization/Deserialization
 * Add unit tests
 * Update ArmNN Versioning

Signed-off-by: Keith Davis <keith.davis@arm.com>
Change-Id: I6fcb1fa341d6f08dea4003b13544e6e9f53fefd3

52 files changed, 1017 insertions, 44 deletions

diff --git a/Android.mk b/Android.mk
index 69c6ee4352..aec32699b0 100644
--- a/Android.mk
+++ b/Android.mk
@@ -204,6 +204,7 @@ LOCAL_SRC_FILES := \
         src/armnn/layers/ReduceLayer.cpp \
         src/armnn/layers/ReshapeLayer.cpp \
         src/armnn/layers/ResizeLayer.cpp \
+        src/armnn/layers/ShapeLayer.cpp \
         src/armnn/layers/SliceLayer.cpp \
         src/armnn/layers/SoftmaxLayer.cpp \
         src/armnn/layers/SpaceToBatchNdLayer.cpp \
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 17785a6cb7..054e4d7096 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -276,6 +276,8 @@ list(APPEND armnn_sources
     src/armnn/layers/ReshapeLayer.cpp
     src/armnn/layers/ResizeLayer.hpp
     src/armnn/layers/ResizeLayer.cpp
+    src/armnn/layers/ShapeLayer.cpp
+    src/armnn/layers/ShapeLayer.hpp
     src/armnn/layers/SliceLayer.cpp
     src/armnn/layers/SliceLayer.hpp
     src/armnn/layers/SoftmaxLayer.hpp
@@ -757,6 +759,7 @@ if(BUILD_UNIT_TESTS)
             src/armnnDeserializer/test/DeserializeReshape.cpp
             src/armnnDeserializer/test/DeserializeResizeBilinear.cpp
             src/armnnDeserializer/test/DeserializeRsqrt.cpp
+            src/armnnDeserializer/test/DeserializeShape.cpp
             src/armnnDeserializer/test/DeserializeSlice.cpp
             src/armnnDeserializer/test/DeserializeSpaceToBatchNd.cpp
             src/armnnDeserializer/test/DeserializeStridedSlice.cpp
diff --git a/InstallationViaAptRepository.md b/InstallationViaAptRepository.md
index 16837be110..e4078603eb 100644
--- a/InstallationViaAptRepository.md
+++ b/InstallationViaAptRepository.md
@@ -113,7 +113,7 @@ In order to check for the latest available Arm NN version use apt-cache search:
 
 
  # Export the ARMNN_MAJOR_VERSION to the latest visible e.g. libarmnn25 to allow installation using the below examples
- export ARMNN_MAJOR_VERSION=25
+ export ARMNN_MAJOR_VERSION=26
 ```
 
 
@@ -124,7 +124,7 @@ The easiest way to install all of the available packages for your systems archit
  sudo apt-get install -y python3-pyarmnn libarmnn-cpuacc-backend${ARMNN_MAJOR_VERSION} libarmnn-gpuacc-backend${ARMNN_MAJOR_VERSION} libarmnn-cpuref-backend${ARMNN_MAJOR_VERSION}
  # Verify installation via python:
  python3 -c "import pyarmnn as ann;print(ann.GetVersion())" 
- # Returns '{ARMNN_MAJOR_VERSION}.0.0' e.g. 25.0.0
+ # Returns '{ARMNN_MAJOR_VERSION}.0.0' e.g. 26.0.0
 ```
 This will install PyArmNN and the three backends for Neon, Compute Library and our Reference Backend.
 It will also install their dependencies including the arm-compute-library package along with the Tensorflow Lite Parser
diff --git a/docs/01_02_deserializer_serializer.dox b/docs/01_02_deserializer_serializer.dox
index 1df3999d0a..811af1cfb5 100644
--- a/docs/01_02_deserializer_serializer.dox
+++ b/docs/01_02_deserializer_serializer.dox
@@ -63,6 +63,7 @@ The Arm NN SDK Serializer currently supports the following layers:
 - Reduce
 - Reshape
 - Resize
+- Shape
 - Slice
 - Softmax
 - SpaceToBatchNd
diff --git a/include/armnn/BackendHelper.hpp b/include/armnn/BackendHelper.hpp
index 527d865694..093f822040 100644
--- a/include/armnn/BackendHelper.hpp
+++ b/include/armnn/BackendHelper.hpp
@@ -359,6 +359,10 @@ public:
                           const TensorInfo& output,
                           Optional<std::string&> reasonIfUnsupported = EmptyOptional());
 
+    bool IsShapeSupported(const TensorInfo& input,
+                          const TensorInfo& output,
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional());
+
     bool IsSliceSupported(const TensorInfo& input,
                           const TensorInfo& output,
                           const SliceDescriptor& descriptor,
diff --git a/include/armnn/DescriptorsFwd.hpp b/include/armnn/DescriptorsFwd.hpp
index 4e7082e88f..9b22644c7b 100644
--- a/include/armnn/DescriptorsFwd.hpp
+++ b/include/armnn/DescriptorsFwd.hpp
@@ -38,10 +38,10 @@ struct ReshapeDescriptor;
 struct ResizeBilinearDescriptor;
 struct ResizeDescriptor;
 struct ReduceDescriptor;
+struct SliceDescriptor;
 struct SoftmaxDescriptor;
 struct SpaceToBatchNdDescriptor;
 struct SpaceToDepthDescriptor;
-struct SliceDescriptor;
 struct StackDescriptor;
 struct StandInDescriptor;
 struct StridedSliceDescriptor;
diff --git a/include/armnn/INetwork.hpp b/include/armnn/INetwork.hpp
index 8d94ed77f6..3c45262f1d 100644
--- a/include/armnn/INetwork.hpp
+++ b/include/armnn/INetwork.hpp
@@ -506,6 +506,11 @@ public:
     IConnectableLayer* AddReshapeLayer(const ReshapeDescriptor& reshapeDescriptor,
                                        const char* name = nullptr);
 
+    /// Adds a shape layer to the network.
+    /// @param name - Optional name for the layer.
+    /// @return - Interface for configuring the layer.
+    IConnectableLayer* AddShapeLayer(const char* name = nullptr);
+
     /// Adds a space to batch layer to the network.
     /// @param spaceToBatchNdDescriptor - Parameters for the space to batch operation.
     /// @param name - Optional name for the layer.
diff --git a/include/armnn/Types.hpp b/include/armnn/Types.hpp
index ac4dd31999..e7c17608ca 100644
--- a/include/armnn/Types.hpp
+++ b/include/armnn/Types.hpp
@@ -332,7 +332,8 @@ using InferenceTimingPair = std::pair<HighResolutionClock, HighResolutionClock>;
     X(Addition) \
     X(ArgMinMax) \
     X(BatchNormalization) \
-    X(BatchToSpaceNd) \
+    X(BatchToSpaceNd)      \
+    X(Cast) \
     X(Comparison) \
     X(Concat) \
     X(Constant) \
@@ -381,6 +382,7 @@ using InferenceTimingPair = std::pair<HighResolutionClock, HighResolutionClock>;
     X(Rank) \
     X(Resize) \
     X(Reduce) \
+    X(Shape) \
     X(Slice) \
     X(Softmax) \
     X(SpaceToBatchNd) \
@@ -394,7 +396,7 @@ using InferenceTimingPair = std::pair<HighResolutionClock, HighResolutionClock>;
     X(Transpose) \
     X(TransposeConvolution2d) \
     X(Unmap) \
-    X(Cast)
+
 /// When adding a new layer, adapt also the LastLayer enum value in the
 /// enum class LayerType below
 enum class LayerType
@@ -403,7 +405,7 @@ enum class LayerType
     LIST_OF_LAYER_TYPE
 #undef X
     FirstLayer = Activation,
-    LastLayer = Cast
+    LastLayer = Unmap
 };
 
 const char* GetLayerTypeAsCString(LayerType type);
diff --git a/include/armnn/Version.hpp b/include/armnn/Version.hpp
index 2139637b5b..5347097982 100644
--- a/include/armnn/Version.hpp
+++ b/include/armnn/Version.hpp
@@ -10,7 +10,7 @@
 #define STRINGIFY_MACRO(s) #s
 
 // ArmNN version components
-#define ARMNN_MAJOR_VERSION 25
+#define ARMNN_MAJOR_VERSION 26
 #define ARMNN_MINOR_VERSION 0
 #define ARMNN_PATCH_VERSION 0
 
diff --git a/include/armnn/backends/ILayerSupport.hpp b/include/armnn/backends/ILayerSupport.hpp
index 52b6df7117..462668d738 100644
--- a/include/armnn/backends/ILayerSupport.hpp
+++ b/include/armnn/backends/ILayerSupport.hpp
@@ -351,6 +351,10 @@ public:
                                   const TensorInfo& output,
                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
 
+    virtual bool IsShapeSupported(const TensorInfo& input,
+                                  const TensorInfo& output,
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
+
     virtual bool IsSliceSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const SliceDescriptor& descriptor,
diff --git a/python/pyarmnn/README.md b/python/pyarmnn/README.md
index 56ac78bb76..ee5ddf08d7 100644
--- a/python/pyarmnn/README.md
+++ b/python/pyarmnn/README.md
@@ -91,14 +91,14 @@ This step will put all generated files under `./src/pyarmnn/_generated` folder a
 ```bash
 $ python setup.py sdist
 ```
-As the result you will get `./dist/pyarmnn-25.0.0.tar.gz` file. As you can see it is platform independent.
+As the result you will get `./dist/pyarmnn-26.0.0.tar.gz` file. As you can see it is platform independent.
 
 ##### 5. Build the binary package
 
 ```bash
 $ python setup.py bdist_wheel
 ```
-As the result you will get something like `./dist/pyarmnn-25.0.0-cp36-cp36m-linux_x86_64.whl` file. As you can see it
+As the result you will get something like `./dist/pyarmnn-26.0.0-cp36-cp36m-linux_x86_64.whl` file. As you can see it
  is platform dependent.
 
 # PyArmNN installation
@@ -107,8 +107,8 @@ PyArmNN can be distributed as a source package or a binary package (wheel).
 
 Binary package is platform dependent, the name of the package will indicate the platform it was built for, e.g.:
 
-* Linux x86 64bit machine: pyarmnn-25.0.0-cp36-cp36m-*linux_x86_64*.whl
-* Linux Aarch 64 bit machine: pyarmnn-25.0.0-cp36-cp36m-*linux_aarch64*.whl
+* Linux x86 64bit machine: pyarmnn-26.0.0-cp36-cp36m-*linux_x86_64*.whl
+* Linux Aarch 64 bit machine: pyarmnn-26.0.0-cp36-cp36m-*linux_aarch64*.whl
 
 The source package is platform independent but installation involves compilation of Arm NN python extension. You will need to have g++ compatible with C++ 14 standard and a python development library installed on the build machine.
 
@@ -126,7 +126,7 @@ $ gcc --print-search-dirs
 ```
 Install PyArmNN from binary by pointing to the wheel file:
 ```bash
-$ pip install /path/to/pyarmnn-25.0.0-cp36-cp36m-linux_aarch64.whl
+$ pip install /path/to/pyarmnn-26.0.0-cp36-cp36m-linux_aarch64.whl
 ```
 
 ## Installing from source package
@@ -143,7 +143,7 @@ $ export  ARMNN_INCLUDE=/path/to/headers
 
 Install PyArmNN as follows:
 ```bash
-$ pip install /path/to/pyarmnn-25.0.0.tar.gz
+$ pip install /path/to/pyarmnn-26.0.0.tar.gz
 ```
 
 If PyArmNN installation script fails to find Arm NN libraries it will raise an error like this
@@ -157,7 +157,7 @@ $ pip show pyarmnn
 You can also verify it by running the following and getting output similar to below:
 ```bash
 $ python -c "import pyarmnn as ann;print(ann.GetVersion())"
-'25.0.0'
+'26.0.0'
 ```
 
 # PyArmNN API overview
diff --git a/python/pyarmnn/examples/image_classification/README.md b/python/pyarmnn/examples/image_classification/README.md
index 27ed4cad8b..ea8f4c30a4 100644
--- a/python/pyarmnn/examples/image_classification/README.md
+++ b/python/pyarmnn/examples/image_classification/README.md
@@ -20,7 +20,7 @@ $ pip show pyarmnn
 You can also verify it by running the following and getting output similar to below:

 ```bash

 $ python -c "import pyarmnn as ann;print(ann.GetVersion())"

-'25.0.0'

+'26.0.0'

 ```

 

 ##### Dependencies

diff --git a/python/pyarmnn/examples/object_detection/README.md b/python/pyarmnn/examples/object_detection/README.md
index 267d2e9ece..97bb164b17 100644
--- a/python/pyarmnn/examples/object_detection/README.md
+++ b/python/pyarmnn/examples/object_detection/README.md
@@ -23,7 +23,7 @@ $ pip show pyarmnn
 You can also verify it by running the following and getting output similar to below:
 ```bash
 $ python -c "import pyarmnn as ann;print(ann.GetVersion())"
-'25.0.0'
+'26.0.0'
 ```
 
 ##### Dependencies
diff --git a/python/pyarmnn/examples/speech_recognition/README.md b/python/pyarmnn/examples/speech_recognition/README.md
index 7af1b188f4..cad4126c4d 100644
--- a/python/pyarmnn/examples/speech_recognition/README.md
+++ b/python/pyarmnn/examples/speech_recognition/README.md
@@ -18,7 +18,7 @@ You can also verify it by running the following and getting output similar to be
 
 ```bash
 $ python -c "import pyarmnn as ann;print(ann.GetVersion())"
-'25.0.0'
+'26.0.0'
 ```
 
 ### Dependencies
diff --git a/python/pyarmnn/src/pyarmnn/_version.py b/python/pyarmnn/src/pyarmnn/_version.py
index f7fc8c9a9c..587efc4424 100644
--- a/python/pyarmnn/src/pyarmnn/_version.py
+++ b/python/pyarmnn/src/pyarmnn/_version.py
@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: MIT
 import os
 
-version_info = (25, 0, 0)
+version_info = (26, 0, 0)
 
 __dev_version_env = os.getenv("PYARMNN_DEV_VER", "")
 
@@ -24,7 +24,7 @@ def check_armnn_version(installed_armnn_version: str, expected_armnn_version: st
     """Compares expected Arm NN version and Arm NN version used to build the package.
 
     Args:
-        installed_armnn_version (str): Arm NN version used to generate the package (e.g. 25.0.0)
+        installed_armnn_version (str): Arm NN version used to generate the package (e.g. 26.0.0)
         expected_armnn_version (str): Expected Arm NN version
 
     Returns:
diff --git a/python/pyarmnn/test/test_setup.py b/python/pyarmnn/test/test_setup.py
index f47addb1f5..8f1d81c093 100644
--- a/python/pyarmnn/test/test_setup.py
+++ b/python/pyarmnn/test/test_setup.py
@@ -87,15 +87,15 @@ def test_gcc_serch_path():
 
 
 def test_armnn_version():
-    check_armnn_version('25.0.0', '25.0.0')
+    check_armnn_version('26.0.0', '26.0.0')
 
 
 def test_incorrect_armnn_version():
     with pytest.raises(AssertionError) as err:
-        check_armnn_version('25.0.0', '25.1.0')
+        check_armnn_version('26.0.0', '26.1.0')
 
-    assert 'Expected ArmNN version is 25.1.0 but installed ArmNN version is 25.0.0' in str(err.value)
+    assert 'Expected ArmNN version is 26.1.0 but installed ArmNN version is 26.0.0' in str(err.value)
 
 
 def test_armnn_version_patch_does_not_matter():
-    check_armnn_version('25.0.0', '25.0.1')
+    check_armnn_version('26.0.0', '26.0.1')
diff --git a/python/pyarmnn/test/test_version.py b/python/pyarmnn/test/test_version.py
index ddb4abe0dc..9c21e82178 100644
--- a/python/pyarmnn/test/test_version.py
+++ b/python/pyarmnn/test/test_version.py
@@ -18,7 +18,7 @@ def test_dev_version():
 
     importlib.reload(v)
 
-    assert "25.0.0.dev1" == v.__version__
+    assert "26.0.0.dev1" == v.__version__
 
     del os.environ["PYARMNN_DEV_VER"]
     del v
@@ -30,7 +30,7 @@ def test_arm_version_not_affected():
 
     importlib.reload(v)
 
-    assert "25.0.0" == v.__arm_ml_version__
+    assert "26.0.0" == v.__arm_ml_version__
 
     del os.environ["PYARMNN_DEV_VER"]
     del v
diff --git a/samples/ObjectDetection/Readme.md b/samples/ObjectDetection/Readme.md
index 408917eebc..025268a34f 100644
--- a/samples/ObjectDetection/Readme.md
+++ b/samples/ObjectDetection/Readme.md
@@ -168,8 +168,8 @@ From the build directory, copy the following to the host platform:
 The full list of libs after cross-compilation to copy on your board:
 ```
 libarmnn.so
-libarmnn.so.25
-libarmnn.so.25.0
+libarmnn.so.26
+libarmnn.so.26.0
 libarmnnTfLiteParser.so
 libarmnnTfLiteParser.so.24.1
 libavcodec.so
diff --git a/src/armnn/BackendHelper.cpp b/src/armnn/BackendHelper.cpp
index be21412e97..a7bf419a7c 100644
--- a/src/armnn/BackendHelper.cpp
+++ b/src/armnn/BackendHelper.cpp
@@ -722,6 +722,13 @@ bool LayerSupportHandle::IsRsqrtSupported(const TensorInfo& input,
     return m_LayerSupport->IsRsqrtSupported(input, output, reasonIfUnsupported.value());
 }
 
+bool LayerSupportHandle::IsShapeSupported(const TensorInfo& input,
+                                          const TensorInfo& output,
+                                          Optional<std::string&> reasonIfUnsupported)
+{
+    return m_LayerSupport->IsShapeSupported(input, output, reasonIfUnsupported.value());
+}
+
 bool LayerSupportHandle::IsSliceSupported(const TensorInfo& input,
                                           const TensorInfo& output,
                                           const SliceDescriptor& descriptor,
diff --git a/src/armnn/LayersFwd.hpp b/src/armnn/LayersFwd.hpp
index 19cd9bdf6c..cdbcaa7e90 100644
--- a/src/armnn/LayersFwd.hpp
+++ b/src/armnn/LayersFwd.hpp
@@ -60,6 +60,7 @@
 #include "layers/ReduceLayer.hpp"
 #include "layers/ReshapeLayer.hpp"
 #include "layers/ResizeLayer.hpp"
+#include "layers/ShapeLayer.hpp"
 #include "layers/SliceLayer.hpp"
 #include "layers/SoftmaxLayer.hpp"
 #include "layers/SpaceToBatchNdLayer.hpp"
@@ -154,6 +155,7 @@ DECLARE_LAYER(Rank)
 DECLARE_LAYER(Reduce)
 DECLARE_LAYER(Reshape)
 DECLARE_LAYER(Resize)
+DECLARE_LAYER(Shape)
 DECLARE_LAYER(Slice)
 DECLARE_LAYER(Softmax)
 DECLARE_LAYER(SpaceToBatchNd)
diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp
index 5807d1705a..71f19313b8 100644
--- a/src/armnn/Network.cpp
+++ b/src/armnn/Network.cpp
@@ -482,6 +482,11 @@ IConnectableLayer* INetwork::AddTransposeLayer(const TransposeDescriptor& transp
     return pNetworkImpl->AddTransposeLayer(transposeDescriptor, name);
 }
 
+IConnectableLayer* INetwork::AddShapeLayer(const char* name)
+{
+    return pNetworkImpl->AddShapeLayer(name);
+}
+
 IConnectableLayer* INetwork::AddStackLayer(const StackDescriptor& descriptor,
                                            const char* name)
 {
@@ -2099,6 +2104,11 @@ IConnectableLayer* NetworkImpl::AddResizeLayer(const ResizeDescriptor& resizeDes
     return m_Graph->AddLayer<ResizeLayer>(resizeDescriptor, name);
 }
 
+IConnectableLayer* NetworkImpl::AddShapeLayer(const char* name)
+{
+    return m_Graph->AddLayer<ShapeLayer>(name);
+}
+
 IConnectableLayer* NetworkImpl::AddInstanceNormalizationLayer(const InstanceNormalizationDescriptor& desc,
                                                               const char* name)
 {
diff --git a/src/armnn/Network.hpp b/src/armnn/Network.hpp
index ad9b51cf35..e07075fbb5 100644
--- a/src/armnn/Network.hpp
+++ b/src/armnn/Network.hpp
@@ -250,6 +250,8 @@ public:
     IConnectableLayer* AddTransposeLayer(const TransposeDescriptor& transposeDescriptor,
                                          const char* name = nullptr);
 
+    IConnectableLayer* AddShapeLayer(const char* name = nullptr);
+
     IConnectableLayer* AddStackLayer(const StackDescriptor& stackDescriptor,
                                      const char* name = nullptr);
 
diff --git a/src/armnn/layers/ShapeLayer.cpp b/src/armnn/layers/ShapeLayer.cpp
new file mode 100644
index 0000000000..4193fa9aab
--- /dev/null
+++ b/src/armnn/layers/ShapeLayer.cpp
@@ -0,0 +1,73 @@
+//
+// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ShapeLayer.hpp"
+
+#include "LayerCloneBase.hpp"
+
+#include <armnn/TypesUtils.hpp>
+#include <armnn/utility/NumericCast.hpp>
+
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+
+namespace armnn
+{
+
+ShapeLayer::ShapeLayer(const char* name)
+    : Layer(1, 1, LayerType::Shape, name)
+{
+}
+
+std::unique_ptr<IWorkload> ShapeLayer::CreateWorkload(const IWorkloadFactory& factory) const
+{
+    ShapeQueueDescriptor descriptor;
+    SetAdditionalInfo(descriptor);
+
+    return factory.CreateShape(descriptor, PrepInfoAndDesc(descriptor));
+}
+
+ShapeLayer* ShapeLayer::Clone(Graph& graph) const
+{
+    return CloneBase<ShapeLayer>(graph, GetName());
+}
+
+void ShapeLayer::ValidateTensorShapesFromInputs()
+{
+    VerifyLayerConnections(1, CHECK_LOCATION());
+
+    const TensorShape& outputShape = GetOutputSlot(0).GetTensorInfo().GetShape();
+
+    VerifyShapeInferenceType(outputShape, m_ShapeInferenceMethod);
+
+    auto inferredShape = InferOutputShapes({ GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape() });
+
+    ARMNN_ASSERT(inferredShape.size() == 1);
+
+    ValidateAndCopyShape(outputShape, inferredShape[0], m_ShapeInferenceMethod, "ShapeLayer");
+}
+
+std::vector<TensorShape> ShapeLayer::InferOutputShapes(const std::vector<TensorShape>& inputShapes) const
+{
+    IgnoreUnused(inputShapes);
+    ARMNN_ASSERT(inputShapes.size() == 1);
+
+    TensorShape outputShape({ inputShapes[0].GetNumDimensions()} );
+
+    return std::vector<TensorShape>({ outputShape });
+}
+
+void ShapeLayer::Accept(ILayerVisitor& visitor) const
+{
+    IgnoreUnused(visitor);
+    throw armnn::Exception("ShapeLayer VisitShapeLayer is not implemented");
+}
+
+void ShapeLayer::ExecuteStrategy(IStrategy& strategy) const
+{
+    strategy.ExecuteStrategy(this, BaseDescriptor(), {}, GetName());
+}
+
+} // namespace armnn
diff --git a/src/armnn/layers/ShapeLayer.hpp b/src/armnn/layers/ShapeLayer.hpp
new file mode 100644
index 0000000000..fee285c2f0
--- /dev/null
+++ b/src/armnn/layers/ShapeLayer.hpp
@@ -0,0 +1,50 @@
+//
+// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "LayerWithParameters.hpp"
+
+namespace armnn
+{
+
+class ShapeLayer : public Layer
+{
+public:
+    /// Makes a workload for the Shape type.
+    /// @param [in] graph The graph where this layer can be found.
+    /// @param [in] factory The workload factory which will create the workload.
+    /// @return A pointer to the created workload, or nullptr if not created.
+    virtual std::unique_ptr<IWorkload> CreateWorkload(const IWorkloadFactory& factory) const override;
+
+    /// Creates a dynamically-allocated copy of this layer.
+    /// @param [in] graph The graph into which this layer is being cloned.
+    ShapeLayer* Clone(Graph& graph) const override;
+
+    /// Check if the input tensor shape(s)
+    /// will lead to a valid configuration of @ref ShapeLayer.
+    /// @param [in] shapeInferenceMethod Indicates if output shape shall be overwritten or just validated.
+    void ValidateTensorShapesFromInputs() override;
+
+    /// By default returns inputShapes if the number of inputs are equal to number of outputs,
+    /// otherwise infers the output shapes from given input shapes and layer properties.
+    /// @param [in] inputShapes The input shapes layer has.
+    /// @return A vector to the inferred output shape.
+    std::vector<TensorShape> InferOutputShapes(const std::vector<TensorShape>& inputShapes) const override;
+
+    void Accept(ILayerVisitor& visitor) const override;
+
+    void ExecuteStrategy(IStrategy& strategy) const override;
+
+protected:
+    /// Constructor to create a ShapeLayer.
+    /// @param [in] name Optional name for the layer.
+    ShapeLayer(const char* name);
+
+    /// Default destructor.
+    ~ShapeLayer() = default;
+};
+
+} // namespace armnn
diff --git a/src/armnnDeserializer/Deserializer.cpp b/src/armnnDeserializer/Deserializer.cpp
index b5bf9daef0..af6ff842a7 100644
--- a/src/armnnDeserializer/Deserializer.cpp
+++ b/src/armnnDeserializer/Deserializer.cpp
@@ -257,6 +257,7 @@ m_ParserFunctions(Layer_MAX+1, &IDeserializer::DeserializerImpl::ParseUnsupporte
     m_ParserFunctions[Layer_ResizeBilinearLayer]         = &DeserializerImpl::ParseResizeBilinear;
     m_ParserFunctions[Layer_ResizeLayer]                 = &DeserializerImpl::ParseResize;
     m_ParserFunctions[Layer_RsqrtLayer]                  = &DeserializerImpl::ParseRsqrt;
+    m_ParserFunctions[Layer_ShapeLayer]                  = &DeserializerImpl::ParseShape;
     m_ParserFunctions[Layer_SliceLayer]                  = &DeserializerImpl::ParseSlice;
     m_ParserFunctions[Layer_SoftmaxLayer]                = &DeserializerImpl::ParseSoftmax;
     m_ParserFunctions[Layer_SpaceToBatchNdLayer]         = &DeserializerImpl::ParseSpaceToBatchNd;
@@ -377,6 +378,8 @@ LayerBaseRawPtr IDeserializer::DeserializerImpl::GetBaseLayer(const GraphPtr& gr
             return graphPtr->layers()->Get(layerIndex)->layer_as_ResizeLayer()->base();
         case Layer::Layer_RsqrtLayer:
             return graphPtr->layers()->Get(layerIndex)->layer_as_RsqrtLayer()->base();
+        case Layer::Layer_ShapeLayer:
+            return graphPtr->layers()->Get(layerIndex)->layer_as_ShapeLayer()->base();
         case Layer::Layer_SliceLayer:
             return graphPtr->layers()->Get(layerIndex)->layer_as_SliceLayer()->base();
         case Layer::Layer_SoftmaxLayer:
@@ -2338,6 +2341,26 @@ void IDeserializer::DeserializerImpl::ParseResizeBilinear(GraphPtr graph, unsign
     RegisterOutputSlots(graph, layerIndex, layer);
 }
 
+void IDeserializer::DeserializerImpl::ParseShape(GraphPtr graph, unsigned int layerIndex)
+{
+    CHECK_LAYERS(graph, 0, layerIndex);
+
+    TensorRawPtrVector inputs = GetInputs(graph, layerIndex);
+    CHECK_VALID_SIZE(inputs.size(), 1);
+
+    TensorRawPtrVector outputs = GetOutputs(graph, layerIndex);
+    CHECK_VALID_SIZE(outputs.size(), 1);
+
+    auto layerName = GetLayerName(graph, layerIndex);
+    IConnectableLayer* layer = m_Network->AddShapeLayer( layerName.c_str());
+
+    armnn::TensorInfo outputTensorInfo = ToTensorInfo(outputs[0]);
+    layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
+
+    RegisterInputSlots(graph, layerIndex, layer);
+    RegisterOutputSlots(graph, layerIndex, layer);
+}
+
 void IDeserializer::DeserializerImpl::ParseSoftmax(GraphPtr graph, unsigned int layerIndex)
 {
     CHECK_LAYERS(graph, 0, layerIndex);
diff --git a/src/armnnDeserializer/Deserializer.hpp b/src/armnnDeserializer/Deserializer.hpp
index 8f38058ae5..0b05e16849 100644
--- a/src/armnnDeserializer/Deserializer.hpp
+++ b/src/armnnDeserializer/Deserializer.hpp
@@ -125,6 +125,7 @@ private:
     void ParseResize(GraphPtr graph, unsigned int layerIndex);
     void ParseResizeBilinear(GraphPtr graph, unsigned int layerIndex);
     void ParseRsqrt(GraphPtr graph, unsigned int layerIndex);
+    void ParseShape(GraphPtr graph, unsigned int layerIndex);
     void ParseSlice(GraphPtr graph, unsigned int layerIndex);
     void ParseSoftmax(GraphPtr graph, unsigned int layerIndex);
     void ParseSpaceToBatchNd(GraphPtr graph, unsigned int layerIndex);
diff --git a/src/armnnDeserializer/test/DeserializeShape.cpp b/src/armnnDeserializer/test/DeserializeShape.cpp
new file mode 100644
index 0000000000..a20fb59699
--- /dev/null
+++ b/src/armnnDeserializer/test/DeserializeShape.cpp
@@ -0,0 +1,131 @@
+//
+// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include <boost/test/unit_test.hpp>
+#include "ParserFlatbuffersSerializeFixture.hpp"
+#include <armnnDeserializer/IDeserializer.hpp>
+
+#include <string>
+
+BOOST_AUTO_TEST_SUITE(Deserializer)
+
+struct ShapeFixture : public ParserFlatbuffersSerializeFixture
+{
+    explicit ShapeFixture()
+    {
+        m_JsonString = R"(
+            {
+              layers: [
+                {
+                  layer_type: "InputLayer",
+                  layer: {
+                    base: {
+                      base: {
+                        layerName: "InputLayer",
+                        layerType: "Input",
+                        inputSlots: [
+
+                        ],
+                        outputSlots: [
+                          {
+                            tensorInfo: {
+                              dimensions: [
+                                1,
+                                3,
+                                3,
+                                1
+                              ],
+                              dataType: "Signed32",
+                              quantizationScale: 0.0
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  layer_type: "ShapeLayer",
+                  layer: {
+                    base: {
+                      index: 1,
+                      layerName: "shape",
+                      layerType: "Shape",
+                      inputSlots: [
+                        {
+                          connection: {
+                            sourceLayerIndex: 0,
+                            outputSlotIndex: 0
+                          }
+                        }
+                      ],
+                      outputSlots: [
+                        {
+                          tensorInfo: {
+                            dimensions: [
+                              4
+                            ],
+                            dataType: "Signed32",
+                            quantizationScale: 0.0
+                          }
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  layer_type: "OutputLayer",
+                  layer: {
+                    base: {
+                      base: {
+                        index: 2,
+                        layerName: "OutputLayer",
+                        layerType: "Output",
+                        inputSlots: [
+                          {
+                            connection: {
+                              sourceLayerIndex: 1,
+                              outputSlotIndex: 0
+                            }
+                          }
+                        ],
+                        outputSlots: [
+
+                        ]
+                      }
+                    }
+                  }
+                }
+              ],
+              inputIds: [
+                0
+              ],
+              outputIds: [
+                0
+              ],
+              featureVersions: {
+                bindingIdsScheme: 1
+              }
+            }
+    )";
+        Setup();
+    }
+};
+
+
+struct SimpleShapeFixture : ShapeFixture
+{
+    SimpleShapeFixture() : ShapeFixture() {}
+};
+
+BOOST_FIXTURE_TEST_CASE(DeserializeShape, SimpleShapeFixture)
+{
+    RunTest<1, armnn::DataType::Signed32>(
+            0,
+            {{"InputLayer", { 1, 1, 1, 1, 1, 1, 1, 1, 1 }}},
+            {{"OutputLayer",{ 1, 3, 3, 1 }}});
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/armnnSerializer/ArmnnSchema.fbs b/src/armnnSerializer/ArmnnSchema.fbs
index 753c2443a4..32a9bba5ab 100644
--- a/src/armnnSerializer/ArmnnSchema.fbs
+++ b/src/armnnSerializer/ArmnnSchema.fbs
@@ -171,7 +171,8 @@ enum LayerType : uint {
     Rank = 58,
     LogicalBinary = 59,
     Reduce = 60,
-    Cast = 61
+    Cast = 61,
+    Shape = 62
 }
 
 // Base layer table to be used as part of other layers
@@ -487,7 +488,7 @@ table ReshapeLayer {
 }
 
 table ReshapeDescriptor {
-  targetShape:[uint];
+    targetShape:[uint];
 }
 
 table PermuteLayer {
@@ -499,6 +500,10 @@ table PermuteDescriptor {
     dimMappings:[uint];
 }
 
+table ShapeLayer {
+    base:LayerBase;
+}
+
 table SpaceToBatchNdLayer {
     base:LayerBase;
     descriptor:SpaceToBatchNdDescriptor;
@@ -972,7 +977,8 @@ union Layer {
     RankLayer,
     LogicalBinaryLayer,
     ReduceLayer,
-    CastLayer
+    CastLayer,
+    ShapeLayer
 }
 
 table AnyLayer {
diff --git a/src/armnnSerializer/ArmnnSchema_generated.h b/src/armnnSerializer/ArmnnSchema_generated.h
index 675fcc6490..4a352ddb6c 100644
--- a/src/armnnSerializer/ArmnnSchema_generated.h
+++ b/src/armnnSerializer/ArmnnSchema_generated.h
@@ -4,6 +4,7 @@
 //
 // automatically generated by the FlatBuffers compiler, do not modify
 
+
 #ifndef FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_
 #define FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_
 
@@ -193,6 +194,9 @@ struct PermuteLayerBuilder;
 struct PermuteDescriptor;
 struct PermuteDescriptorBuilder;
 
+struct ShapeLayer;
+struct ShapeLayerBuilder;
+
 struct SpaceToBatchNdLayer;
 struct SpaceToBatchNdLayerBuilder;
 
@@ -735,11 +739,12 @@ enum LayerType {
   LayerType_LogicalBinary = 59,
   LayerType_Reduce = 60,
   LayerType_Cast = 61,
+  LayerType_Shape = 62,
   LayerType_MIN = LayerType_Addition,
-  LayerType_MAX = LayerType_Cast
+  LayerType_MAX = LayerType_Shape
 };
 
-inline const LayerType (&EnumValuesLayerType())[62] {
+inline const LayerType (&EnumValuesLayerType())[63] {
   static const LayerType values[] = {
     LayerType_Addition,
     LayerType_Input,
@@ -802,13 +807,14 @@ inline const LayerType (&EnumValuesLayerType())[62] {
     LayerType_Rank,
     LayerType_LogicalBinary,
     LayerType_Reduce,
-    LayerType_Cast
+    LayerType_Cast,
+    LayerType_Shape
   };
   return values;
 }
 
 inline const char * const *EnumNamesLayerType() {
-  static const char * const names[63] = {
+  static const char * const names[64] = {
     "Addition",
     "Input",
     "Multiplication",
@@ -871,13 +877,14 @@ inline const char * const *EnumNamesLayerType() {
     "LogicalBinary",
     "Reduce",
     "Cast",
+    "Shape",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameLayerType(LayerType e) {
-  if (flatbuffers::IsOutRange(e, LayerType_Addition, LayerType_Cast)) return "";
+  if (flatbuffers::IsOutRange(e, LayerType_Addition, LayerType_Shape)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesLayerType()[index];
 }
@@ -1219,11 +1226,12 @@ enum Layer {
   Layer_LogicalBinaryLayer = 60,
   Layer_ReduceLayer = 61,
   Layer_CastLayer = 62,
+  Layer_ShapeLayer = 63,
   Layer_MIN = Layer_NONE,
-  Layer_MAX = Layer_CastLayer
+  Layer_MAX = Layer_ShapeLayer
 };
 
-inline const Layer (&EnumValuesLayer())[63] {
+inline const Layer (&EnumValuesLayer())[64] {
   static const Layer values[] = {
     Layer_NONE,
     Layer_ActivationLayer,
@@ -1287,13 +1295,14 @@ inline const Layer (&EnumValuesLayer())[63] {
     Layer_RankLayer,
     Layer_LogicalBinaryLayer,
     Layer_ReduceLayer,
-    Layer_CastLayer
+    Layer_CastLayer,
+    Layer_ShapeLayer
   };
   return values;
 }
 
 inline const char * const *EnumNamesLayer() {
-  static const char * const names[64] = {
+  static const char * const names[65] = {
     "NONE",
     "ActivationLayer",
     "AdditionLayer",
@@ -1357,13 +1366,14 @@ inline const char * const *EnumNamesLayer() {
     "LogicalBinaryLayer",
     "ReduceLayer",
     "CastLayer",
+    "ShapeLayer",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameLayer(Layer e) {
-  if (flatbuffers::IsOutRange(e, Layer_NONE, Layer_CastLayer)) return "";
+  if (flatbuffers::IsOutRange(e, Layer_NONE, Layer_ShapeLayer)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesLayer()[index];
 }
@@ -1620,6 +1630,10 @@ template<> struct LayerTraits<armnnSerializer::CastLayer> {
   static const Layer enum_value = Layer_CastLayer;
 };
 
+template<> struct LayerTraits<armnnSerializer::ShapeLayer> {
+  static const Layer enum_value = Layer_ShapeLayer;
+};
+
 bool VerifyLayer(flatbuffers::Verifier &verifier, const void *obj, Layer type);
 bool VerifyLayerVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
 
@@ -5180,6 +5194,49 @@ inline flatbuffers::Offset<PermuteDescriptor> CreatePermuteDescriptorDirect(
       dimMappings__);
 }
 
+struct ShapeLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef ShapeLayerBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BASE = 4
+  };
+  const armnnSerializer::LayerBase *base() const {
+    return GetPointer<const armnnSerializer::LayerBase *>(VT_BASE);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_BASE) &&
+           verifier.VerifyTable(base()) &&
+           verifier.EndTable();
+  }
+};
+
+struct ShapeLayerBuilder {
+  typedef ShapeLayer Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_base(flatbuffers::Offset<armnnSerializer::LayerBase> base) {
+    fbb_.AddOffset(ShapeLayer::VT_BASE, base);
+  }
+  explicit ShapeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ShapeLayerBuilder &operator=(const ShapeLayerBuilder &);
+  flatbuffers::Offset<ShapeLayer> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<ShapeLayer>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<ShapeLayer> CreateShapeLayer(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<armnnSerializer::LayerBase> base = 0) {
+  ShapeLayerBuilder builder_(_fbb);
+  builder_.add_base(base);
+  return builder_.Finish();
+}
+
 struct SpaceToBatchNdLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef SpaceToBatchNdLayerBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -9567,6 +9624,9 @@ struct AnyLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const armnnSerializer::CastLayer *layer_as_CastLayer() const {
     return layer_type() == armnnSerializer::Layer_CastLayer ? static_cast<const armnnSerializer::CastLayer *>(layer()) : nullptr;
   }
+  const armnnSerializer::ShapeLayer *layer_as_ShapeLayer() const {
+    return layer_type() == armnnSerializer::Layer_ShapeLayer ? static_cast<const armnnSerializer::ShapeLayer *>(layer()) : nullptr;
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_LAYER_TYPE) &&
@@ -9824,6 +9884,10 @@ template<> inline const armnnSerializer::CastLayer *AnyLayer::layer_as<armnnSeri
   return layer_as_CastLayer();
 }
 
+template<> inline const armnnSerializer::ShapeLayer *AnyLayer::layer_as<armnnSerializer::ShapeLayer>() const {
+  return layer_as_ShapeLayer();
+}
+
 struct AnyLayerBuilder {
   typedef AnyLayer Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -10292,6 +10356,10 @@ inline bool VerifyLayer(flatbuffers::Verifier &verifier, const void *obj, Layer
       auto ptr = reinterpret_cast<const armnnSerializer::CastLayer *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case Layer_ShapeLayer: {
+      auto ptr = reinterpret_cast<const armnnSerializer::ShapeLayer *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return true;
   }
 }
diff --git a/src/armnnSerializer/Serializer.cpp b/src/armnnSerializer/Serializer.cpp
index 30a7e74a58..fd7f8dc7dc 100644
--- a/src/armnnSerializer/Serializer.cpp
+++ b/src/armnnSerializer/Serializer.cpp
@@ -1309,6 +1309,17 @@ void SerializerStrategy::SerializeNormalizationLayer(const armnn::IConnectableLa
     CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_NormalizationLayer);
 }
 
+void SerializerStrategy::SerializeShapeLayer(const armnn::IConnectableLayer* layer,
+                                             const char* name)
+{
+    IgnoreUnused(name);
+
+    auto shapeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Shape);
+    auto shapeLayer = serializer::CreateShapeLayer(m_flatBufferBuilder, shapeBaseLayer);
+
+    CreateAnyLayer(shapeLayer.o, serializer::Layer::Layer_ShapeLayer);
+}
+
 void SerializerStrategy::SerializeStackLayer(const armnn::IConnectableLayer* layer,
                                         const armnn::StackDescriptor& stackDescriptor,
                                         const char* name)
@@ -2138,6 +2149,11 @@ void SerializerStrategy::ExecuteStrategy(const armnn::IConnectableLayer* layer,
             SerializeResizeLayer(layer, layerDescriptor, name);
             break;
         }
+        case armnn::LayerType::Shape:
+        {
+            SerializeShapeLayer(layer, name);
+            break;
+        }
         case armnn::LayerType::Slice:
         {
             const armnn::SliceDescriptor& layerDescriptor =
diff --git a/src/armnnSerializer/Serializer.hpp b/src/armnnSerializer/Serializer.hpp
index 7bbcc2464e..c99e87d3e9 100644
--- a/src/armnnSerializer/Serializer.hpp
+++ b/src/armnnSerializer/Serializer.hpp
@@ -315,6 +315,9 @@ private:
                                      const armnn::NormalizationDescriptor& normalizationDescriptor,
                                      const char* name = nullptr);
 
+    void SerializeShapeLayer(const armnn::IConnectableLayer* layer,
+                             const char* name = nullptr);
+
     void SerializeSplitterLayer(const armnn::IConnectableLayer* layer,
                                 const armnn::ViewsDescriptor& viewsDescriptor,
                                 const char* name = nullptr);
diff --git a/src/armnnSerializer/test/SerializerTests.cpp b/src/armnnSerializer/test/SerializerTests.cpp
index 8e7ca37cfa..98532d0cec 100644
--- a/src/armnnSerializer/test/SerializerTests.cpp
+++ b/src/armnnSerializer/test/SerializerTests.cpp
@@ -1951,6 +1951,31 @@ TEST_CASE("EnsureResizeBilinearBackwardCompatibility")
     deserializedNetwork->ExecuteStrategy(verifier);
 }
 
+TEST_CASE("SerializeShape")
+{
+    const std::string layerName("shape");
+    const armnn::TensorInfo inputInfo({1, 3, 3, 1}, armnn::DataType::Signed32);
+    const armnn::TensorInfo outputInfo({ 4 }, armnn::DataType::Signed32);
+
+    armnn::INetworkPtr network = armnn::INetwork::Create();
+    armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
+    armnn::IConnectableLayer* const shapeLayer = network->AddShapeLayer(layerName.c_str());
+    armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
+
+    inputLayer->GetOutputSlot(0).Connect(shapeLayer->GetInputSlot(0));
+    shapeLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
+
+    inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    shapeLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
+
+    armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
+    CHECK(deserializedNetwork);
+
+    LayerVerifierBase verifier(layerName, {inputInfo}, {outputInfo});
+
+    deserializedNetwork->ExecuteStrategy(verifier);
+}
+
 TEST_CASE("SerializeSlice")
 {
     const std::string layerName{"slice"};
diff --git a/src/backends/backendsCommon/LayerSupportBase.cpp b/src/backends/backendsCommon/LayerSupportBase.cpp
index 2e171f98ae..8a24e1161b 100644
--- a/src/backends/backendsCommon/LayerSupportBase.cpp
+++ b/src/backends/backendsCommon/LayerSupportBase.cpp
@@ -557,6 +557,13 @@ bool LayerSupportBase::IsRsqrtSupported(const TensorInfo&, // input
     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 }
 
+bool LayerSupportBase::IsShapeSupported(const TensorInfo&, // input
+                                        const TensorInfo&, // output
+                                        Optional<std::string&> reasonIfUnsupported) const
+{
+    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
+}
+
 bool LayerSupportBase::IsSliceSupported(const TensorInfo&, // input
                                         const TensorInfo&, // output
                                         const SliceDescriptor&, // descriptor
diff --git a/src/backends/backendsCommon/LayerSupportBase.hpp b/src/backends/backendsCommon/LayerSupportBase.hpp
index a4f972f961..0277a782a1 100644
--- a/src/backends/backendsCommon/LayerSupportBase.hpp
+++ b/src/backends/backendsCommon/LayerSupportBase.hpp
@@ -344,6 +344,10 @@ public:
                           const TensorInfo& output,
                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 
+    bool IsShapeSupported(const TensorInfo& input,
+                          const TensorInfo& output,
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
     bool IsSliceSupported(const TensorInfo& input,
                           const TensorInfo& output,
                           const SliceDescriptor& descriptor,
diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp
index 44a6a17b37..8c78136185 100644
--- a/src/backends/backendsCommon/WorkloadData.cpp
+++ b/src/backends/backendsCommon/WorkloadData.cpp
@@ -2805,6 +2805,33 @@ void MergeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
     ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName, "input_0", "output");
 }
 
+void ShapeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
+{
+    const std::string& descriptorName{"ShapeQueueDescriptor"};
+
+    ValidateNumInputs(workloadInfo,  descriptorName, 1);
+    ValidateNumOutputs(workloadInfo, descriptorName, 1);
+
+    const TensorInfo& inputTensorInfo = workloadInfo.m_InputTensorInfos[0];
+    const TensorInfo& outputTensorInfo = workloadInfo.m_OutputTensorInfos[0];
+
+    std::vector<DataType> supportedTypes =
+    {
+        DataType::BFloat16,
+        DataType::Float16,
+        DataType::Float32,
+        DataType::QAsymmS8,
+        DataType::QAsymmU8,
+        DataType::QAsymmS8,
+        DataType::QSymmS8,
+        DataType::QSymmS16,
+        DataType::Signed32
+    };
+
+    ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
+    ValidateDataTypes(outputTensorInfo, {DataType::Signed32}, descriptorName);
+}
+
 void SwitchQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
 {
     const std::string& descriptorName{"SwitchQueueDescriptor"};
diff --git a/src/backends/backendsCommon/WorkloadData.hpp b/src/backends/backendsCommon/WorkloadData.hpp
index 11ce2cb44f..36653bdc0d 100644
--- a/src/backends/backendsCommon/WorkloadData.hpp
+++ b/src/backends/backendsCommon/WorkloadData.hpp
@@ -690,4 +690,9 @@ struct ReduceQueueDescriptor : QueueDescriptorWithParameters<ReduceDescriptor>
     void Validate(const WorkloadInfo& workloadInfo) const;
 };
 
+struct ShapeQueueDescriptor : QueueDescriptor
+{
+    void Validate(const WorkloadInfo& workloadInfo) const;
+};
+
 } // namespace armnn
diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp
index c5fc9d0fe2..61ad20995b 100644
--- a/src/backends/backendsCommon/WorkloadFactory.cpp
+++ b/src/backends/backendsCommon/WorkloadFactory.cpp
@@ -1003,6 +1003,16 @@ bool IWorkloadFactory::IsLayerConfigurationSupported(const BackendId& backendId,
                                                           reason);
             break;
         }
+        case LayerType::Shape:
+        {
+            const TensorInfo& input  = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
+            const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
+
+            result = layerSupportObject.IsShapeSupported(OverrideDataType(input, dataType),
+                                                         OverrideDataType(output, dataType),
+                                                         reason);
+            break;
+        }
         case LayerType::Slice:
         {
             auto cLayer = PolymorphicDowncast<const SliceLayer*>(&layer);
@@ -1673,6 +1683,12 @@ std::unique_ptr<IWorkload> IWorkloadFactory::CreateRsqrt(const RsqrtQueueDescrip
     return std::unique_ptr<IWorkload>();
 }
 
+std::unique_ptr<IWorkload> IWorkloadFactory::CreateShape(const ShapeQueueDescriptor& /*descriptor*/,
+                                                         const WorkloadInfo& /*info*/) const
+{
+    return std::unique_ptr<IWorkload>();
+}
+
 std::unique_ptr<IWorkload> IWorkloadFactory::CreateSlice(const SliceQueueDescriptor& /*descriptor*/,
                                                          const WorkloadInfo& /*info*/) const
 {
diff --git a/src/backends/backendsCommon/WorkloadFactory.hpp b/src/backends/backendsCommon/WorkloadFactory.hpp
index 42360d37ff..1987b9b664 100644
--- a/src/backends/backendsCommon/WorkloadFactory.hpp
+++ b/src/backends/backendsCommon/WorkloadFactory.hpp
@@ -252,6 +252,9 @@ public:
     virtual std::unique_ptr<IWorkload> CreateRsqrt(const RsqrtQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const;
 
+    virtual std::unique_ptr<IWorkload> CreateShape(const ShapeQueueDescriptor& descriptor,
+                                                   const WorkloadInfo& info) const;
+
     virtual std::unique_ptr<IWorkload> CreateSlice(const SliceQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const;
 
diff --git a/src/backends/backendsCommon/common.mk b/src/backends/backendsCommon/common.mk
index 73a16d00e1..ff9375dec1 100644
--- a/src/backends/backendsCommon/common.mk
+++ b/src/backends/backendsCommon/common.mk
@@ -85,6 +85,7 @@ COMMON_TEST_SOURCES := \
     test/layerTests/SliceTestImpl.cpp \
     test/layerTests/QuantizeTestImpl.cpp \
     test/layerTests/SinTestImpl.cpp \
+    test/layerTests/ShapeTestImpl.cpp \
     test/layerTests/SoftmaxTestImpl.cpp \
     test/layerTests/SpaceToBatchNdTestImpl.cpp \
     test/layerTests/SpaceToDepthTestImpl.cpp \
diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt
index 82381a8b84..162368fd43 100644
--- a/src/backends/backendsCommon/test/CMakeLists.txt
+++ b/src/backends/backendsCommon/test/CMakeLists.txt
@@ -157,6 +157,8 @@ list(APPEND armnnBackendsCommonUnitTests_sources
     layerTests/RsqrtTestImpl.hpp
     layerTests/SinTestImpl.cpp
     layerTests/SinTestImpl.hpp
+    layerTests/ShapeTestImpl.cpp
+    layerTests/ShapeTestImpl.cpp
     layerTests/SliceTestImpl.cpp
     layerTests/SliceTestImpl.hpp
     layerTests/SoftmaxTestImpl.cpp
diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
index 5a05ee1d85..adc7bc4c3c 100644
--- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
+++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
@@ -663,6 +663,8 @@ DECLARE_LAYER_POLICY_2_PARAM(Resize)
 
 DECLARE_LAYER_POLICY_2_PARAM(Reshape)
 
+DECLARE_LAYER_POLICY_1_PARAM(Shape)
+
 DECLARE_LAYER_POLICY_2_PARAM(Slice)
 
 DECLARE_LAYER_POLICY_2_PARAM(Softmax)
diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp
index 4ae6553362..46eb6ee2a5 100644
--- a/src/backends/backendsCommon/test/LayerTests.hpp
+++ b/src/backends/backendsCommon/test/LayerTests.hpp
@@ -55,6 +55,7 @@
 #include <backendsCommon/test/layerTests/ReshapeTestImpl.hpp>
 #include <backendsCommon/test/layerTests/ResizeTestImpl.hpp>
 #include <backendsCommon/test/layerTests/RsqrtTestImpl.hpp>
+#include <backendsCommon/test/layerTests/ShapeTestImpl.hpp>
 #include <backendsCommon/test/layerTests/SinTestImpl.hpp>
 #include <backendsCommon/test/layerTests/SliceTestImpl.hpp>
 #include <backendsCommon/test/layerTests/SoftmaxTestImpl.hpp>
diff --git a/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.cpp
new file mode 100644
index 0000000000..d6c03141ab
--- /dev/null
+++ b/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.cpp
@@ -0,0 +1,306 @@
+//
+// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ShapeTestImpl.hpp"
+
+#include <backendsCommon/test/DataTypeUtils.hpp>
+#include <backendsCommon/test/TensorCopyUtils.hpp>
+#include <backendsCommon/test/WorkloadTestUtils.hpp>
+
+#include <test/TensorHelpers.hpp>
+
+template<typename T, std::size_t n>
+LayerTestResult<int32_t, 1> ShapeTest(
+    armnn::TensorInfo inputTensorInfo,
+    std::vector<T> input,
+    armnn::TensorInfo outputTensorInfo,
+    std::vector<int32_t> expectedOutputData,
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    IgnoreUnused(memoryManager);
+
+    std::vector<int32_t> actualOutput(outputTensorInfo.GetNumElements());
+
+    std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo);
+    std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo);
+
+    armnn::ShapeQueueDescriptor data;
+    armnn::WorkloadInfo info;
+    AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
+    AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
+
+    std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateShape(data, info);
+
+    inputHandle->Allocate();
+    outputHandle->Allocate();
+
+    CopyDataToITensorHandle(inputHandle.get(), input.data());
+
+    workload->Execute();
+
+    CopyDataFromITensorHandle(actualOutput.data(), outputHandle.get());
+
+    return LayerTestResult<int32_t, 1>(actualOutput,
+                                       expectedOutputData,
+                                       outputHandle->GetShape(),
+                                       outputTensorInfo.GetShape());
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<int32_t, 1> ShapeDimSize1Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    armnn::TensorInfo inputTensorInfo({ 1 }, ArmnnType, 1.0f, 0);
+    armnn::TensorInfo outputTensorInfo({ 1 }, armnn::DataType::Signed32);
+
+    auto input = ConvertToDataType<ArmnnType>({ 1.0f }, inputTensorInfo);
+
+    return ShapeTest<T, 1>(inputTensorInfo, input, outputTensorInfo, { 1 }, workloadFactory, memoryManager,
+                           tensorHandleFactory);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<int32_t, 1> ShapeDimSize2Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    armnn::TensorInfo inputTensorInfo({ 1, 2 }, ArmnnType, 1.0f, 0);
+    armnn::TensorInfo outputTensorInfo({ 2 }, armnn::DataType::Signed32);
+
+    auto input = ConvertToDataType<ArmnnType>({ 1.0f, 1.0f }, inputTensorInfo);
+
+    return ShapeTest<T, 2>(inputTensorInfo, input, outputTensorInfo, { 1, 2 }, workloadFactory, memoryManager,
+                           tensorHandleFactory);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<int32_t, 1> ShapeDimSize3Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    armnn::TensorInfo inputTensorInfo({ 1, 2, 3 }, ArmnnType, 1.0f, 0);
+    armnn::TensorInfo outputTensorInfo({ 3 }, armnn::DataType::Signed32);
+
+    auto input = ConvertToDataType<ArmnnType>({ 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }, inputTensorInfo);
+
+    return ShapeTest<T, 3>(inputTensorInfo, input, outputTensorInfo, { 1, 2, 3 }, workloadFactory, memoryManager,
+                           tensorHandleFactory);
+}
+
+template<armnn::DataType ArmnnType, typename T>
+LayerTestResult<int32_t, 1> ShapeDimSize4Test(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory)
+{
+    armnn::TensorInfo inputTensorInfo({ 2, 2, 3, 2 }, ArmnnType, 1.0f, 0);
+    armnn::TensorInfo outputTensorInfo({ 4 }, armnn::DataType::Signed32);
+
+    auto input = ConvertToDataType<ArmnnType>({ 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
+                                                1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
+                                                1.0f },
+                                              inputTensorInfo);
+
+    return ShapeTest<T, 4>(inputTensorInfo, input, outputTensorInfo, { 2, 2, 3, 2 }, workloadFactory, memoryManager,
+                           tensorHandleFactory);
+}
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize4Test<armnn::DataType::Float16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize4Test<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize4Test<armnn::DataType::QAsymmU8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize4Test<armnn::DataType::Signed32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize4Test<armnn::DataType::QSymmS16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize4Test<armnn::DataType::QSymmS8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize4Test<armnn::DataType::QAsymmS8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize4Test<armnn::DataType::BFloat16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize3Test<armnn::DataType::Float16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize3Test<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize3Test<armnn::DataType::QAsymmU8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize3Test<armnn::DataType::Signed32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize3Test<armnn::DataType::QSymmS16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize3Test<armnn::DataType::QSymmS8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize3Test<armnn::DataType::QAsymmS8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize3Test<armnn::DataType::BFloat16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize2Test<armnn::DataType::Float16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize2Test<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize2Test<armnn::DataType::QAsymmU8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize2Test<armnn::DataType::Signed32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize2Test<armnn::DataType::QSymmS16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize2Test<armnn::DataType::QSymmS8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize2Test<armnn::DataType::QAsymmS8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize2Test<armnn::DataType::BFloat16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize1Test<armnn::DataType::Float16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize1Test<armnn::DataType::Float32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize1Test<armnn::DataType::QAsymmU8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize1Test<armnn::DataType::Signed32>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize1Test<armnn::DataType::QSymmS16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize1Test<armnn::DataType::QSymmS8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize1Test<armnn::DataType::QAsymmS8>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template LayerTestResult<int32_t, 1>
+ShapeDimSize1Test<armnn::DataType::BFloat16>(
+    armnn::IWorkloadFactory& workloadFactory,
+    const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
\ No newline at end of file
diff --git a/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.hpp
new file mode 100644
index 0000000000..85f7c0a453
--- /dev/null
+++ b/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.hpp
@@ -0,0 +1,45 @@
+//
+// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "LayerTestResult.hpp"
+
+#include <ResolveType.hpp>
+
+#include <armnn/backends/IBackendInternal.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+
+template<typename T , std::size_t n>
+LayerTestResult<int32_t, 1> ShapeTest(
+        armnn::TensorInfo inputTensorInfo,
+        std::vector<T> input,
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<int32_t, 1> ShapeDimSize1Test(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<int32_t, 1> ShapeDimSize2Test(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<int32_t, 1> ShapeDimSize3Test(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
+
+template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
+LayerTestResult<int32_t, 1> ShapeDimSize4Test(
+        armnn::IWorkloadFactory& workloadFactory,
+        const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        const armnn::ITensorHandleFactory& tensorHandleFactory);
diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp
index 14a40f9d5d..1b05c4e0f4 100644
--- a/src/backends/reference/RefLayerSupport.cpp
+++ b/src/backends/reference/RefLayerSupport.cpp
@@ -1859,6 +1859,24 @@ bool RefLayerSupport::IsRsqrtSupported(const TensorInfo& input,
                                        reasonIfUnsupported);
 }
 
+bool RefLayerSupport::IsShapeSupported(const TensorInfo& input,
+                                       const TensorInfo& output,
+                                       Optional<std::string&> reasonIfUnsupported) const
+{
+    IgnoreUnused(input);
+    bool supported = true;
+
+    std::array<DataType, 1> supportedTypes =
+    {
+        DataType::Signed32
+    };
+
+    supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
+                                  "Reference Shape: output type not supported");
+
+    return supported;
+}
+
 bool RefLayerSupport::IsSliceSupported(const TensorInfo& input,
                                        const TensorInfo& output,
                                        const SliceDescriptor& descriptor,
diff --git a/src/backends/reference/RefLayerSupport.hpp b/src/backends/reference/RefLayerSupport.hpp
index 7a95bb06ac..c060f79b5a 100644
--- a/src/backends/reference/RefLayerSupport.hpp
+++ b/src/backends/reference/RefLayerSupport.hpp
@@ -297,12 +297,16 @@ public:
                            const TensorInfo& output,
                            const ResizeDescriptor& descriptor,
                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-    
+
     ARMNN_DEPRECATED_MSG("Use IsElementwiseUnarySupported instead")
     bool IsRsqrtSupported(const TensorInfo& input,
                           const TensorInfo& output,
                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 
+    bool IsShapeSupported(const TensorInfo& input,
+                          const TensorInfo& output,
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
     bool IsSliceSupported(const TensorInfo& input,
                           const TensorInfo& output,
                           const SliceDescriptor& descriptor,
diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp
index 8e3bbe468f..606f531630 100644
--- a/src/backends/reference/RefWorkloadFactory.cpp
+++ b/src/backends/reference/RefWorkloadFactory.cpp
@@ -7,7 +7,6 @@
 #include <backendsCommon/MemImportWorkload.hpp>
 #include <backendsCommon/MakeWorkloadHelper.hpp>
 #include <backendsCommon/TensorHandle.hpp>
-#include <reference/workloads/RefFillWorkload.hpp>
 #include "RefWorkloadFactory.hpp"
 #include "RefBackendId.hpp"
 #include "workloads/RefWorkloads.hpp"
@@ -626,6 +625,12 @@ std::unique_ptr<IWorkload> RefWorkloadFactory::CreateRsqrt(const RsqrtQueueDescr
     return CreateElementwiseUnary(elementwiseUnaryDescriptor, info);
 }
 
+std::unique_ptr<IWorkload> RefWorkloadFactory::CreateShape(const ShapeQueueDescriptor& descriptor,
+                                                           const WorkloadInfo& info) const
+{
+    return std::make_unique<RefShapeWorkload>(descriptor, info);
+}
+
 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSlice(const SliceQueueDescriptor& descriptor,
                                                            const WorkloadInfo& info) const
 {
diff --git a/src/backends/reference/RefWorkloadFactory.hpp b/src/backends/reference/RefWorkloadFactory.hpp
index 734c5e49c3..2beffa77f3 100644
--- a/src/backends/reference/RefWorkloadFactory.hpp
+++ b/src/backends/reference/RefWorkloadFactory.hpp
@@ -243,6 +243,9 @@ public:
     std::unique_ptr<IWorkload> CreateRsqrt(const RsqrtQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
+    std::unique_ptr<IWorkload> CreateShape(const ShapeQueueDescriptor& descriptor,
+                                           const WorkloadInfo& info) const override;
+
     std::unique_ptr<IWorkload> CreateSlice(const SliceQueueDescriptor& descriptor,
                                            const WorkloadInfo& info) const override;
 
diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp
index 1cc6fa8d36..45e3717268 100644
--- a/src/backends/reference/test/RefLayerTests.cpp
+++ b/src/backends/reference/test/RefLayerTests.cpp
@@ -1733,6 +1733,43 @@ ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_2, DepthToSpaceTest2<DataType::QSymmS
 ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_3, DepthToSpaceTest3<DataType::QSymmS16>, DataLayout::NHWC);
 ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_4, DepthToSpaceTest4<DataType::QSymmS16>, DataLayout::NHWC);
 
+// Shape
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1Float16,  ShapeDimSize1Test<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1Float32,  ShapeDimSize1Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1QAsymmU8, ShapeDimSize1Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1Signed32, ShapeDimSize1Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1QSymmS16, ShapeDimSize1Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1QSymmS8,  ShapeDimSize1Test<DataType::QSymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1QAsymmS8, ShapeDimSize1Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1BFloat16, ShapeDimSize1Test<DataType::BFloat16>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2Float16,  ShapeDimSize2Test<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2Float32,  ShapeDimSize2Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2QAsymmU8, ShapeDimSize2Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2Signed32, ShapeDimSize2Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2QSymmS16, ShapeDimSize2Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2QSymmS8,  ShapeDimSize2Test<DataType::QSymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2QAsymmS8, ShapeDimSize2Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2BFloat16, ShapeDimSize2Test<DataType::BFloat16>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3Float16,  ShapeDimSize3Test<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3Float32,  ShapeDimSize3Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3QAsymmU8, ShapeDimSize3Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3Signed32, ShapeDimSize3Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3QSymmS16, ShapeDimSize3Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3QSymmS8,  ShapeDimSize3Test<DataType::QSymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3QAsymmS8, ShapeDimSize3Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3BFloat16, ShapeDimSize3Test<DataType::BFloat16>)
+
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4Float16,  ShapeDimSize4Test<DataType::Float16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4Float32,  ShapeDimSize4Test<DataType::Float32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4QAsymmU8, ShapeDimSize4Test<DataType::QAsymmU8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4Signed32, ShapeDimSize4Test<DataType::Signed32>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4QSymmS16, ShapeDimSize4Test<DataType::QSymmS16>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4QSymmS8,  ShapeDimSize4Test<DataType::QSymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4QAsymmS8, ShapeDimSize4Test<DataType::QAsymmS8>)
+ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4BFloat16, ShapeDimSize4Test<DataType::BFloat16>)
+
 // SpaceToDepth
 ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNchwAsymmQ8, SpaceToDepthNchwAsymmQ8Test)
 ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNhwcAsymmQ8, SpaceToDepthNhwcAsymmQ8Test)
diff --git a/src/backends/reference/workloads/CMakeLists.txt b/src/backends/reference/workloads/CMakeLists.txt
index 09e02e67bd..7a769e5246 100644
--- a/src/backends/reference/workloads/CMakeLists.txt
+++ b/src/backends/reference/workloads/CMakeLists.txt
@@ -143,6 +143,7 @@ list(APPEND armnnRefBackendWorkloads_sources
     RefResizeBilinearWorkload.hpp
     RefResizeWorkload.cpp
     RefResizeWorkload.hpp
+    RefShapeWorkload.hpp
     RefSliceWorkload.cpp
     RefSliceWorkload.hpp
     RefSoftmaxWorkload.cpp
diff --git a/src/backends/reference/workloads/RefShapeWorkload.hpp b/src/backends/reference/workloads/RefShapeWorkload.hpp
new file mode 100644
index 0000000000..8e2a410b0c
--- /dev/null
+++ b/src/backends/reference/workloads/RefShapeWorkload.hpp
@@ -0,0 +1,48 @@
+//
+// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+
+#include "RefWorkloadUtils.hpp"
+
+namespace armnn
+{
+
+struct RefShapeWorkload : public BaseWorkload<ShapeQueueDescriptor>
+{
+public:
+    using BaseWorkload<ShapeQueueDescriptor>::BaseWorkload;
+    virtual void Execute() const override
+    {
+        Execute(m_Data.m_Inputs, m_Data.m_Outputs);
+    }
+    void ExecuteAsync(WorkingMemDescriptor& workingMemDescriptor)  override
+    {
+        Execute(workingMemDescriptor.m_Inputs, workingMemDescriptor.m_Outputs);
+    }
+
+private:
+    void Execute(std::vector<ITensorHandle*> inputs, std::vector<ITensorHandle*> outputs) const
+    {
+        const TensorShape Shape = GetTensorInfo(inputs[0]).GetShape();
+
+        const TensorInfo& outputInfo = GetTensorInfo(outputs[0]);
+
+        unsigned int numBytes =
+            GetTensorInfo(inputs[0]).GetNumDimensions() * GetDataTypeSize(outputInfo.GetDataType());
+
+        std::memcpy(outputs[0]->Map(), &Shape, numBytes);
+        outputs[0]->Unmap();
+    }
+};
+
+} //namespace armnn
+
+
+
+
diff --git a/src/backends/reference/workloads/RefWorkloads.hpp b/src/backends/reference/workloads/RefWorkloads.hpp
index d3995f2b82..afe63d13c0 100644
--- a/src/backends/reference/workloads/RefWorkloads.hpp
+++ b/src/backends/reference/workloads/RefWorkloads.hpp
@@ -35,10 +35,10 @@
 #include "RefDequantizeWorkload.hpp"
 #include "RefElementwiseWorkload.hpp"
 #include "RefElementwiseUnaryWorkload.hpp"
+#include "RefFakeQuantizationFloat32Workload.hpp"
 #include "RefFillWorkload.hpp"
-#include "RefFullyConnectedWorkload.hpp"
 #include "RefFloorWorkload.hpp"
-#include "RefFakeQuantizationFloat32Workload.hpp"
+#include "RefFullyConnectedWorkload.hpp"
 #include "RefGatherWorkload.hpp"
 #include "RefInstanceNormalizationWorkload.hpp"
 #include "RefL2NormalizationWorkload.hpp"
@@ -59,6 +59,7 @@
 #include "RefReshapeWorkload.hpp"
 #include "RefResizeBilinearWorkload.hpp"
 #include "RefResizeWorkload.hpp"
+#include "RefShapeWorkload.hpp"
 #include "RefSliceWorkload.hpp"
 #include "RefSplitterWorkload.hpp"
 #include "RefSoftmaxWorkload.hpp"