IVGCVSW-2093 Add SpaceToBatchNd layer and corresponding no-op factory implementations

Change-Id: Ibd457f3a2d4342c4d6335bd3c471282a14ab6b14

27 files changed, 282 insertions, 1 deletions

diff --git a/Android.mk b/Android.mk
index fc126ac649..cf5566fa96 100644
--- a/Android.mk
+++ b/Android.mk
@@ -101,6 +101,7 @@ LOCAL_SRC_FILES := \
         src/armnn/layers/DivisionLayer.cpp \
         src/armnn/layers/SubtractionLayer.cpp \
         src/armnn/layers/ReshapeLayer.cpp \
+        src/armnn/layers/SpaceToBatchNdLayer.cpp \
         src/armnn/layers/ResizeBilinearLayer.cpp \
         src/armnn/layers/SoftmaxLayer.cpp \
         src/armnn/layers/SplitterLayer.cpp \
@@ -229,4 +230,3 @@ LOCAL_SHARED_LIBRARIES := \
 	libOpenCL
 
 include $(BUILD_EXECUTABLE)
-
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9ae6e972f1..23c79bf543 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -220,6 +220,8 @@ list(APPEND armnn_sources
     src/armnn/layers/DivisionLayer.hpp
     src/armnn/layers/ReshapeLayer.hpp
     src/armnn/layers/ReshapeLayer.cpp
+    src/armnn/layers/SpaceToBatchNdLayer.hpp
+    src/armnn/layers/SpaceToBatchNdLayer.cpp
     src/armnn/layers/ResizeBilinearLayer.hpp
     src/armnn/layers/ResizeBilinearLayer.cpp
     src/armnn/layers/SoftmaxLayer.hpp
diff --git a/include/armnn/Descriptors.hpp b/include/armnn/Descriptors.hpp
index 5a7a647ee7..656afb1756 100644
--- a/include/armnn/Descriptors.hpp
+++ b/include/armnn/Descriptors.hpp
@@ -333,6 +333,24 @@ struct ReshapeDescriptor
     TensorShape m_TargetShape;
 };
 
+struct SpaceToBatchNdDescriptor
+{
+    SpaceToBatchNdDescriptor()
+    : m_DataLayout(DataLayout::NCHW)
+    {}
+
+    SpaceToBatchNdDescriptor(const std::vector<unsigned int>& blockShape,
+                             const std::vector<std::pair<unsigned int, unsigned int>>& padList)
+    : m_BlockShape(blockShape)
+    , m_PadList(padList)
+    , m_DataLayout(DataLayout::NCHW)
+    {}
+
+    std::vector<unsigned int> m_BlockShape;
+    std::vector<std::pair<unsigned int, unsigned int>> m_PadList;
+    DataLayoutIndexed m_DataLayout;
+};
+
 // temporary descriptor for Lstm
 struct LstmDescriptor
 {
diff --git a/include/armnn/DescriptorsFwd.hpp b/include/armnn/DescriptorsFwd.hpp
index 739c12056c..a2974d797d 100644
--- a/include/armnn/DescriptorsFwd.hpp
+++ b/include/armnn/DescriptorsFwd.hpp
@@ -20,6 +20,7 @@ struct MeanDescriptor;
 struct PadDescriptor;
 struct Pooling2dDescriptor;
 struct ReshapeDescriptor;
+struct SpaceToBatchNdDescriptor;
 struct ResizeBilinearDescriptor;
 struct SoftmaxDescriptor;
 struct OriginsDescriptor;
diff --git a/include/armnn/ILayerSupport.hpp b/include/armnn/ILayerSupport.hpp
index d63c3a7063..0e7adff0af 100644
--- a/include/armnn/ILayerSupport.hpp
+++ b/include/armnn/ILayerSupport.hpp
@@ -161,6 +161,11 @@ public:
     virtual bool IsReshapeSupported(const TensorInfo& input,
                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
+    virtual bool IsSpaceToBatchNdSupported(const TensorInfo& input,
+                                           const TensorInfo& output,
+                                           const SpaceToBatchNdDescriptor& descriptor,
+                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
+
     virtual bool IsResizeBilinearSupported(const TensorInfo& input,
                                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
diff --git a/include/armnn/INetwork.hpp b/include/armnn/INetwork.hpp
index 7a809350cb..2cb8f28d87 100644
--- a/include/armnn/INetwork.hpp
+++ b/include/armnn/INetwork.hpp
@@ -252,6 +252,13 @@ public:
     virtual IConnectableLayer* AddReshapeLayer(const ReshapeDescriptor& reshapeDescriptor,
                                                const char* name = nullptr) = 0;
 
+    /// 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.
+    /// @return - Interface for configuring the layer.
+    virtual IConnectableLayer* AddSpaceToBatchNdLayer(const SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
+                                                      const char* name = nullptr) = 0;
+
     /// Adds a floor layer to the network.
     /// @param name - Optional name for the layer.
     /// @return - Interface for configuring the layer.
diff --git a/include/armnn/LayerSupport.hpp b/include/armnn/LayerSupport.hpp
index 281807cf79..eb6b5da7b9 100644
--- a/include/armnn/LayerSupport.hpp
+++ b/include/armnn/LayerSupport.hpp
@@ -196,6 +196,14 @@ bool IsSoftmaxSupported(const BackendId& backend,
                         size_t reasonIfUnsupportedMaxLength = 1024);
 
 /// Deprecated in favor of IBackend and ILayerSupport interfaces
+bool IsSpaceToBatchNdSupported(const BackendId& backend,
+                               const TensorInfo& input,
+                               const TensorInfo& output,
+                               const SpaceToBatchNdDescriptor& descriptor,
+                               char* reasonIfUnsupported = nullptr,
+                               size_t reasonIfUnsupportedMaxLength = 1024);
+
+/// Deprecated in favor of IBackend and ILayerSupport interfaces
 bool IsSplitterSupported(const BackendId& backend,
                          const TensorInfo& input,
                          const ViewsDescriptor& descriptor,
diff --git a/src/armnn/InternalTypes.cpp b/src/armnn/InternalTypes.cpp
index 67c596eec7..931b6a3579 100644
--- a/src/armnn/InternalTypes.cpp
+++ b/src/armnn/InternalTypes.cpp
@@ -40,6 +40,7 @@ char const* GetLayerTypeAsCString(LayerType type)
         case LayerType::Reshape: return "Reshape";
         case LayerType::ResizeBilinear: return "ResizeBilinear";
         case LayerType::Softmax: return "Softmax";
+        case LayerType::SpaceToBatchNd: return "SpaceToBatchNd";
         case LayerType::Splitter: return "Splitter";
         case LayerType::Subtraction: return "Subtraction";
         default:
diff --git a/src/armnn/InternalTypes.hpp b/src/armnn/InternalTypes.hpp
index 1a612e9426..0661b16649 100644
--- a/src/armnn/InternalTypes.hpp
+++ b/src/armnn/InternalTypes.hpp
@@ -41,6 +41,7 @@ enum class LayerType
     Reshape,
     ResizeBilinear,
     Softmax,
+    SpaceToBatchNd,
     Splitter,
     // Last layer goes here.
     LastLayer,
diff --git a/src/armnn/LayerSupport.cpp b/src/armnn/LayerSupport.cpp
index 249c8f4654..325699d9ff 100644
--- a/src/armnn/LayerSupport.cpp
+++ b/src/armnn/LayerSupport.cpp
@@ -302,6 +302,16 @@ bool IsSoftmaxSupported(const BackendId& backend,
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsSoftmaxSupported, input, output, descriptor);
 }
 
+bool IsSpaceToBatchNdSupported(const BackendId& backend,
+                               const TensorInfo& input,
+                               const TensorInfo& output,
+                               const SpaceToBatchNdDescriptor& descriptor,
+                               char* reasonIfUnsupported,
+                               size_t reasonIfUnsupportedMaxLength)
+{
+    FORWARD_LAYER_SUPPORT_FUNC(backend, IsSpaceToBatchNdSupported, input, output, descriptor);
+}
+
 bool IsSplitterSupported(const BackendId& backend,
                          const TensorInfo& input,
                          const ViewsDescriptor& descriptor,
diff --git a/src/armnn/LayersFwd.hpp b/src/armnn/LayersFwd.hpp
index 8321be447d..5c08b6677f 100644
--- a/src/armnn/LayersFwd.hpp
+++ b/src/armnn/LayersFwd.hpp
@@ -33,6 +33,7 @@
 #include "layers/ReshapeLayer.hpp"
 #include "layers/ResizeBilinearLayer.hpp"
 #include "layers/SoftmaxLayer.hpp"
+#include "layers/SpaceToBatchNdLayer.hpp"
 #include "layers/SplitterLayer.hpp"
 #include "layers/SubtractionLayer.hpp"
 
@@ -90,6 +91,7 @@ DECLARE_LAYER(Pooling2d)
 DECLARE_LAYER(Reshape)
 DECLARE_LAYER(ResizeBilinear)
 DECLARE_LAYER(Softmax)
+DECLARE_LAYER(SpaceToBatchNd)
 DECLARE_LAYER(Splitter)
 DECLARE_LAYER(Subtraction)
 
diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp
index cab5106959..20c67160c0 100644
--- a/src/armnn/Network.cpp
+++ b/src/armnn/Network.cpp
@@ -545,6 +545,12 @@ IConnectableLayer* Network::AddReshapeLayer(const ReshapeDescriptor& reshapeDesc
     return m_Graph->AddLayer<ReshapeLayer>(reshapeDescriptor, name);
 }
 
+IConnectableLayer* Network::AddSpaceToBatchNdLayer(const SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
+                                                   const char* name)
+{
+    return m_Graph->AddLayer<SpaceToBatchNdLayer>(spaceToBatchNdDescriptor, name);
+}
+
 IConnectableLayer* Network::AddFloorLayer(const char* name)
 {
     return m_Graph->AddLayer<FloorLayer>(name);
diff --git a/src/armnn/Network.hpp b/src/armnn/Network.hpp
index 129513d657..4a93dd1ee4 100644
--- a/src/armnn/Network.hpp
+++ b/src/armnn/Network.hpp
@@ -106,6 +106,9 @@ public:
     IConnectableLayer* AddReshapeLayer(const ReshapeDescriptor& reshapeDescriptor,
                                        const char* name = nullptr) override;
 
+    IConnectableLayer* AddSpaceToBatchNdLayer(const SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
+                                              const char* name = nullptr) override;
+
     IConnectableLayer* AddFloorLayer(const char* name = nullptr) override;
 
     IConnectableLayer* AddOutputLayer(LayerBindingId id, const char* name = nullptr) override;
diff --git a/src/armnn/layers/SpaceToBatchNdLayer.cpp b/src/armnn/layers/SpaceToBatchNdLayer.cpp
new file mode 100644
index 0000000000..9c87ab5975
--- /dev/null
+++ b/src/armnn/layers/SpaceToBatchNdLayer.cpp
@@ -0,0 +1,79 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "SpaceToBatchNdLayer.hpp"
+
+#include "LayerCloneBase.hpp"
+
+#include <armnn/TypesUtils.hpp>
+#include <backends/WorkloadData.hpp>
+#include <backends/WorkloadFactory.hpp>
+
+#include <numeric>
+
+namespace armnn
+{
+
+SpaceToBatchNdLayer::SpaceToBatchNdLayer(const SpaceToBatchNdDescriptor param, const char* name)
+    : LayerWithParameters(1, 1, LayerType::SpaceToBatchNd, param, name)
+{}
+
+std::unique_ptr<IWorkload> SpaceToBatchNdLayer::CreateWorkload(const Graph& graph,
+                                                               const IWorkloadFactory& factory) const
+{
+    SpaceToBatchNdQueueDescriptor descriptor;
+    descriptor.m_Parameters.m_BlockShape = m_Param.m_BlockShape;
+    descriptor.m_Parameters.m_PadList = m_Param.m_PadList;
+
+    return factory.CreateSpaceToBatchNd(descriptor, PrepInfoAndDesc(descriptor, graph));
+}
+
+SpaceToBatchNdLayer* SpaceToBatchNdLayer::Clone(Graph& graph) const
+{
+    return CloneBase<SpaceToBatchNdLayer>(graph, m_Param, GetName());
+}
+
+std::vector<TensorShape> SpaceToBatchNdLayer::InferOutputShapes(const std::vector<TensorShape>& inputShapes) const
+{
+    BOOST_ASSERT(inputShapes.size() == 1);
+
+    TensorShape inputShape = inputShapes[0];
+    TensorShape outputShape(inputShape);
+
+    outputShape[0] = inputShape[0] * std::accumulate(m_Param.m_BlockShape.begin(),
+                                                     m_Param.m_BlockShape.end(),
+                                                     1U,
+                                                     std::multiplies<>());
+
+    unsigned int heightIndex = m_Param.m_DataLayout.GetHeightIndex();
+    unsigned int widthIndex = m_Param.m_DataLayout.GetWidthIndex();
+
+    std::pair<unsigned int, unsigned int> heightPad = m_Param.m_PadList[0];
+    std::pair<unsigned int, unsigned int> widthPad = m_Param.m_PadList[1];
+
+    outputShape[heightIndex] =
+        (inputShape[heightIndex] + heightPad.first + heightPad.second) / m_Param.m_BlockShape[0];
+    outputShape[widthIndex] =
+        (inputShape[widthIndex] + widthPad.first + widthPad.second) / m_Param.m_BlockShape[1];
+
+    return std::vector<TensorShape>({ outputShape });
+}
+
+void SpaceToBatchNdLayer::ValidateTensorShapesFromInputs()
+{
+    VerifyLayerConnections(1, CHECK_LOCATION());
+
+    std::vector<TensorShape> inferredShapes = InferOutputShapes({
+        GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape() });
+
+    BOOST_ASSERT(inferredShapes.size() == 1);
+
+    ConditionalThrowIfNotEqual<LayerValidationException>(
+        "SpaceToBatchNdLayer: TensorShape set on OutputSlot[0] does not match the inferred shape.",
+        GetOutputSlot(0).GetTensorInfo().GetShape(),
+        inferredShapes[0]);
+}
+
+} // namespace
diff --git a/src/armnn/layers/SpaceToBatchNdLayer.hpp b/src/armnn/layers/SpaceToBatchNdLayer.hpp
new file mode 100644
index 0000000000..090fb35989
--- /dev/null
+++ b/src/armnn/layers/SpaceToBatchNdLayer.hpp
@@ -0,0 +1,30 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "LayerWithParameters.hpp"
+
+namespace armnn
+{
+
+class SpaceToBatchNdLayer : public LayerWithParameters<SpaceToBatchNdDescriptor>
+{
+public:
+    virtual std::unique_ptr<IWorkload> CreateWorkload(const Graph&            graph,
+                                                      const IWorkloadFactory& factory) const override;
+
+    SpaceToBatchNdLayer* Clone(Graph& graph) const override;
+
+    std::vector<TensorShape> InferOutputShapes(const std::vector<TensorShape>& inputShapes) const override;
+
+    void ValidateTensorShapesFromInputs() override;
+
+protected:
+    SpaceToBatchNdLayer(const SpaceToBatchNdDescriptor param, const char* name);
+    ~SpaceToBatchNdLayer() = default;
+};
+
+} // namespace
diff --git a/src/backends/ILayerSupport.cpp b/src/backends/ILayerSupport.cpp
index 34168c55b8..ebfff5d429 100644
--- a/src/backends/ILayerSupport.cpp
+++ b/src/backends/ILayerSupport.cpp
@@ -256,6 +256,14 @@ bool ILayerSupport::IsSoftmaxSupported(const TensorInfo& input,
     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 }
 
+bool ILayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
+                                              const TensorInfo& output,
+                                              const SpaceToBatchNdDescriptor& descriptor,
+                                              Optional<std::string&> reasonIfUnsupported) const
+{
+    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
+}
+
 bool ILayerSupport::IsSplitterSupported(const TensorInfo& input,
                                         const ViewsDescriptor& descriptor,
                                         Optional<std::string&> reasonIfUnsupported) const
diff --git a/src/backends/WorkloadData.cpp b/src/backends/WorkloadData.cpp
index ef31fbd1fb..495d4ecde9 100644
--- a/src/backends/WorkloadData.cpp
+++ b/src/backends/WorkloadData.cpp
@@ -741,6 +741,46 @@ void ReshapeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
     }
 }
 
+void SpaceToBatchNdQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
+{
+    ValidateSingleInput(workloadInfo, "SpaceToBatchNdQueueDescriptor");
+    ValidateSingleOutput(workloadInfo, "SpaceToBatchNdQueueDescriptor");
+
+    ValidateTensorNumDimensions(workloadInfo.m_InputTensorInfos[0], "SpaceToBatchNdQueueDescriptor", 4, "input");
+    ValidateTensorNumDimensions(workloadInfo.m_OutputTensorInfos[0], "SpaceToBatchNdQueueDescriptor", 4, "output");
+
+    if (workloadInfo.m_InputTensorInfos[0].GetNumElements() != workloadInfo.m_OutputTensorInfos[0].GetNumElements())
+    {
+        throw InvalidArgumentException("SpaceToBatchNdQueueDescriptor: Input tensor has " +
+            to_string(workloadInfo.m_InputTensorInfos[0].GetNumElements()) + " but output tensor has " +
+            to_string(workloadInfo.m_OutputTensorInfos[0].GetNumElements()) + " elements.");
+    }
+
+    if (m_Parameters.m_BlockShape.size() != 2)
+    {
+        throw InvalidArgumentException("Block Shape must contains 2 spatial dimensions");
+    }
+
+    if (m_Parameters.m_BlockShape.size() != m_Parameters.m_PadList.size())
+    {
+        throw InvalidArgumentException("Pad List must contains the same number of dimensions as Block Shape.");
+    }
+
+    const TensorShape inputShape = workloadInfo.m_InputTensorInfos[0].GetShape();
+
+    std::pair<unsigned int, unsigned int> heightPad = m_Parameters.m_PadList[0];
+    std::pair<unsigned int, unsigned int> widthPad = m_Parameters.m_PadList[1];
+
+    if ((inputShape[m_Parameters.m_DataLayout.GetHeightIndex()] + heightPad.first + heightPad.second)
+            % m_Parameters.m_BlockShape[0] != 0 ||
+        (inputShape[m_Parameters.m_DataLayout.GetWidthIndex()] + widthPad.first + widthPad.second)
+            % m_Parameters.m_BlockShape[1] != 0)
+    {
+        throw InvalidArgumentException(
+            "Input shape after padding must be divisible by Block Shape in all spatial dimensions");
+    }
+}
+
 void FloorQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
 {
     ValidateSingleInput(workloadInfo, "FloorQueueDescriptor");
diff --git a/src/backends/WorkloadData.hpp b/src/backends/WorkloadData.hpp
index 40e89f76e4..867d9f2159 100644
--- a/src/backends/WorkloadData.hpp
+++ b/src/backends/WorkloadData.hpp
@@ -271,6 +271,11 @@ struct ReshapeQueueDescriptor : QueueDescriptorWithParameters<ReshapeDescriptor>
     void Validate(const WorkloadInfo& workloadInfo) const;
 };
 
+struct SpaceToBatchNdQueueDescriptor : QueueDescriptorWithParameters<SpaceToBatchNdDescriptor>
+{
+    void Validate(const WorkloadInfo& workloadInfo) const;
+};
+
 struct FloorQueueDescriptor : QueueDescriptor
 {
     void Validate(const WorkloadInfo& workloadInfo) const;
diff --git a/src/backends/WorkloadFactory.cpp b/src/backends/WorkloadFactory.cpp
index 2e7a24f732..e9c2ab7a5d 100644
--- a/src/backends/WorkloadFactory.cpp
+++ b/src/backends/WorkloadFactory.cpp
@@ -542,6 +542,17 @@ bool IWorkloadFactory::IsLayerSupported(const BackendId& backendId,
                                                             reason);
             break;
         }
+        case LayerType::SpaceToBatchNd:
+        {
+            auto cLayer = boost::polymorphic_downcast<const SpaceToBatchNdLayer*>(&layer);
+            const TensorInfo& input = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
+            const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
+            result = layerSupportObject->IsSpaceToBatchNdSupported(OverrideDataType(input, dataType),
+                                                                   OverrideDataType(output, dataType),
+                                                                   cLayer->GetParameters(),
+                                                                   reason);
+            break;
+        }
         case LayerType::Splitter:
         {
             auto cLayer = boost::polymorphic_downcast<const SplitterLayer*>(&layer);
diff --git a/src/backends/WorkloadFactory.hpp b/src/backends/WorkloadFactory.hpp
index 2f422ab4f6..96906cb7f5 100644
--- a/src/backends/WorkloadFactory.hpp
+++ b/src/backends/WorkloadFactory.hpp
@@ -116,6 +116,9 @@ public:
     virtual std::unique_ptr<IWorkload> CreateReshape(const ReshapeQueueDescriptor& descriptor,
                                                      const WorkloadInfo& info) const = 0;
 
+    virtual std::unique_ptr<IWorkload> CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
+                                                            const WorkloadInfo& info) const = 0;
+
     virtual std::unique_ptr<IWorkload> CreateFloor(const FloorQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const = 0;
 
diff --git a/src/backends/cl/ClWorkloadFactory.cpp b/src/backends/cl/ClWorkloadFactory.cpp
index 08ee9e922d..ae9d471f13 100644
--- a/src/backends/cl/ClWorkloadFactory.cpp
+++ b/src/backends/cl/ClWorkloadFactory.cpp
@@ -274,6 +274,12 @@ std::unique_ptr<IWorkload> ClWorkloadFactory::CreateReshape(const ReshapeQueueDe
     return MakeWorkload<ClReshapeWorkload>(descriptor, info);
 }
 
+std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
+    const WorkloadInfo& info) const
+{
+    return nullptr;
+}
+
 std::unique_ptr<IWorkload> ClWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
     const WorkloadInfo& info) const
 {
@@ -477,6 +483,12 @@ std::unique_ptr<IWorkload> ClWorkloadFactory::CreateReshape(const ReshapeQueueDe
     return nullptr;
 }
 
+std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
+    const WorkloadInfo& info) const
+{
+    return nullptr;
+}
+
 std::unique_ptr<IWorkload> ClWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
     const WorkloadInfo& info) const
 {
diff --git a/src/backends/cl/ClWorkloadFactory.hpp b/src/backends/cl/ClWorkloadFactory.hpp
index ba7cf6931f..bd4ab50be0 100644
--- a/src/backends/cl/ClWorkloadFactory.hpp
+++ b/src/backends/cl/ClWorkloadFactory.hpp
@@ -99,6 +99,9 @@ public:
     virtual std::unique_ptr<IWorkload> CreateReshape(const ReshapeQueueDescriptor& descriptor,
                                                      const WorkloadInfo& info) const override;
 
+    virtual std::unique_ptr<IWorkload> CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
+                                                            const WorkloadInfo& info) const override;
+
     virtual std::unique_ptr<IWorkload> CreateFloor(const FloorQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const override;
 
diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp
index c16d383554..81d088b5aa 100644
--- a/src/backends/neon/NeonWorkloadFactory.cpp
+++ b/src/backends/neon/NeonWorkloadFactory.cpp
@@ -238,6 +238,12 @@ std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateReshape(const ReshapeQueue
     return std::make_unique<NeonReshapeWorkload>(descriptor, info);
 }
 
+std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
+    const WorkloadInfo& info) const
+{
+    return nullptr;
+}
+
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
     const WorkloadInfo& info) const
 {
@@ -441,6 +447,12 @@ std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateReshape(const ReshapeQueue
     return nullptr;
 }
 
+std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
+    const WorkloadInfo& info) const
+{
+    return nullptr;
+}
+
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
     const WorkloadInfo& info) const
 {
diff --git a/src/backends/neon/NeonWorkloadFactory.hpp b/src/backends/neon/NeonWorkloadFactory.hpp
index 030e982a20..da83693a35 100644
--- a/src/backends/neon/NeonWorkloadFactory.hpp
+++ b/src/backends/neon/NeonWorkloadFactory.hpp
@@ -100,6 +100,9 @@ public:
     virtual std::unique_ptr<IWorkload> CreateReshape(const ReshapeQueueDescriptor& descriptor,
                                                      const WorkloadInfo& info) const override;
 
+    virtual std::unique_ptr<IWorkload> CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
+                                                            const WorkloadInfo& info) const override;
+
     virtual std::unique_ptr<IWorkload> CreateFloor(const FloorQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const override;
 
diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp
index 864ffdbf4f..3af81567e5 100644
--- a/src/backends/reference/RefWorkloadFactory.cpp
+++ b/src/backends/reference/RefWorkloadFactory.cpp
@@ -214,6 +214,12 @@ std::unique_ptr<IWorkload> RefWorkloadFactory::CreateReshape(const ReshapeQueueD
     return MakeWorkload<RefReshapeFloat32Workload, RefReshapeUint8Workload>(descriptor, info);
 }
 
+std::unique_ptr<IWorkload> RefWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
+    const WorkloadInfo& info) const
+{
+    return MakeWorkload<NullWorkload, NullWorkload>(descriptor, info);
+}
+
 std::unique_ptr<IWorkload> RefWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
                                                           const WorkloadInfo& info) const
 {
diff --git a/src/backends/reference/RefWorkloadFactory.hpp b/src/backends/reference/RefWorkloadFactory.hpp
index be0dafc159..2e51ec37cc 100644
--- a/src/backends/reference/RefWorkloadFactory.hpp
+++ b/src/backends/reference/RefWorkloadFactory.hpp
@@ -117,6 +117,9 @@ public:
     virtual std::unique_ptr<IWorkload> CreateReshape(const ReshapeQueueDescriptor& descriptor,
                                                      const WorkloadInfo& info) const override;
 
+    virtual std::unique_ptr<IWorkload> CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
+                                                            const WorkloadInfo& info) const override;
+
     virtual std::unique_ptr<IWorkload> CreateFloor(const FloorQueueDescriptor& descriptor,
                                                    const WorkloadInfo& info) const override;
 
diff --git a/src/backends/test/IsLayerSupportedTestImpl.hpp b/src/backends/test/IsLayerSupportedTestImpl.hpp
index 1bcf56dc61..722d82d8ab 100644
--- a/src/backends/test/IsLayerSupportedTestImpl.hpp
+++ b/src/backends/test/IsLayerSupportedTestImpl.hpp
@@ -352,6 +352,8 @@ DECLARE_LAYER_POLICY_2_PARAM(Reshape)
 
 DECLARE_LAYER_POLICY_2_PARAM(Softmax)
 
+DECLARE_LAYER_POLICY_2_PARAM(SpaceToBatchNd)
+
 DECLARE_LAYER_POLICY_2_PARAM(Splitter)
 
 DECLARE_LAYER_POLICY_1_PARAM(Subtraction)