IVGCVSW-7635 Remove deprecated code due to be removed in 23.08 (ILayerSupport)

 * Fix failure in SampleDynamicLayerSupport and SampleDynamicWorkloadFactory.
 * Provide implementation of CreateWorkload() accepting LayerType
 * Made WorkloadFactory::CreateWorkload() pure virtual again to force
   backend API users to implement.

Signed-off-by: Francis Murtagh <francis.murtagh@arm.com>
Change-Id: Iecd180214a92c9fd7174fd36ae8aa2bdbc9d3deb

5 files changed, 50 insertions, 28 deletions

diff --git a/include/armnn/backends/WorkloadFactory.hpp b/include/armnn/backends/WorkloadFactory.hpp
index d5ebf28ed3..cdbe372219 100644
--- a/include/armnn/backends/WorkloadFactory.hpp
+++ b/include/armnn/backends/WorkloadFactory.hpp
@@ -64,16 +64,20 @@ public:
     virtual std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
                                                               DataLayout dataLayout,
                                                               const bool IsMemoryManaged = true) const = 0;
+
+    /// Backends should implement their own CreateWorkload function with a switch statement.
+    /// The case for the switch should be the LayerType and based on that they will call their
+    /// specific workload creation functionality.
     virtual std::unique_ptr<IWorkload> CreateWorkload(LayerType type,
                                                       const QueueDescriptor& descriptor,
-                                                      const WorkloadInfo& info) const;
+                                                      const WorkloadInfo& info) const = 0;
 
 private:
     static bool IsLayerConfigurationSupported(const BackendId& backendId,
-                                       const IConnectableLayer& connectableLayer,
-                                       Optional<DataType> dataType,
-                                       std::string& outReasonIfUnsupported,
-                                       const ModelOptions& modelOptions = {});
+                                              const IConnectableLayer& connectableLayer,
+                                              Optional<DataType> dataType,
+                                              std::string& outReasonIfUnsupported,
+                                              const ModelOptions& modelOptions = {});
 };
 
 } // namespace armnn
diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp
index 7a9e46ce7d..f067056ce1 100644
--- a/src/backends/backendsCommon/WorkloadFactory.cpp
+++ b/src/backends/backendsCommon/WorkloadFactory.cpp
@@ -1611,20 +1611,4 @@ bool IWorkloadFactory::IsLayerSupported(const BackendId& backendId,
                                          modelOptions);
 }
 
-/// Backends should implement their own CreateWorkload function with a switch statement.
-/// The case for the switch should be the LayerType and based on that they will call their
-/// specific workload creation functionality.
-std::unique_ptr<IWorkload> IWorkloadFactory::CreateWorkload(LayerType type,
-                                                            const QueueDescriptor& descriptor,
-                                                            const WorkloadInfo& info) const
-{
-    IgnoreUnused(descriptor);
-    IgnoreUnused(info);
-    switch(type)
-    {
-        default:
-            return std::unique_ptr<IWorkload>();
-    }
-}
-
 } // namepsace armnn
diff --git a/src/dynamic/sample/SampleDynamicLayerSupport.hpp b/src/dynamic/sample/SampleDynamicLayerSupport.hpp
index 2f0744aab7..3881ad760e 100644
--- a/src/dynamic/sample/SampleDynamicLayerSupport.hpp
+++ b/src/dynamic/sample/SampleDynamicLayerSupport.hpp
@@ -16,20 +16,20 @@ public:
     bool IsAdditionSupported(const armnn::TensorInfo& input0,
                              const armnn::TensorInfo& input1,
                              const armnn::TensorInfo& output,
-                             armnn::Optional<std::string&> reasonIfUnsupported = armnn::EmptyOptional()) const override;
+                             armnn::Optional<std::string&> reasonIfUnsupported = armnn::EmptyOptional()) const;
 
     bool IsInputSupported(const armnn::TensorInfo& input,
-                          armnn::Optional<std::string&> reasonIfUnsupported) const override;
+                          armnn::Optional<std::string&> reasonIfUnsupported) const;
 
     bool IsOutputSupported(const armnn::TensorInfo& output,
-                           armnn::Optional<std::string&> reasonIfUnsupported) const override;
+                           armnn::Optional<std::string&> reasonIfUnsupported) const;
 
     bool IsLayerSupported(const armnn::LayerType& type,
                           const std::vector<armnn::TensorInfo>& infos,
                           const armnn::BaseDescriptor& descriptor,
                           const armnn::Optional<armnn::LstmInputParamsInfo>& lstmParamsInfo,
                           const armnn::Optional<armnn::QuantizedLstmInputParamsInfo>& quantizedLstmParamsInfo,
-                          armnn::Optional<std::string&> reasonIfUnsupported = armnn::EmptyOptional()) const override;
+                          armnn::Optional<std::string&> reasonIfUnsupported = armnn::EmptyOptional()) const;
 };
 
 } // namespace sdb
diff --git a/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp b/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp
index 8796716c98..d4be0fcb3e 100644
--- a/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp
+++ b/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp
@@ -5,6 +5,7 @@
 
 #include <armnn/backends/MemCopyWorkload.hpp>
 #include <armnn/backends/TensorHandle.hpp>
+#include <armnn/utility/PolymorphicDowncast.hpp>
 
 #include "SampleDynamicAdditionWorkload.hpp"
 #include "SampleDynamicBackend.hpp"
@@ -77,4 +78,33 @@ std::unique_ptr<armnn::IWorkload> SampleDynamicWorkloadFactory::CreateOutput(
     return std::make_unique<armnn::CopyMemGenericWorkload>(descriptor, info);
 }
 
+std::unique_ptr<armnn::IWorkload> SampleDynamicWorkloadFactory::CreateWorkload(
+        armnn::LayerType type,
+        const armnn::QueueDescriptor& descriptor,
+        const armnn::WorkloadInfo& info) const
+{
+    using namespace armnn;
+    using namespace sdb;
+    switch(type)
+    {
+        case LayerType::Addition:
+        {
+            auto additionQueueDescriptor = PolymorphicDowncast<const AdditionQueueDescriptor*>(&descriptor);
+            return std::make_unique<SampleDynamicAdditionWorkload>(*additionQueueDescriptor, info);
+        }
+        case LayerType::Input:
+        {
+            auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
+            return std::make_unique<CopyMemGenericWorkload>(*inputQueueDescriptor, info);
+        }
+        case LayerType::Output:
+        {
+            auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
+            return std::make_unique<CopyMemGenericWorkload>(*outputQueueDescriptor, info);
+        }
+        default:
+            return nullptr;
+    }
+}
+
 } // namespace sdb
diff --git a/src/dynamic/sample/SampleDynamicWorkloadFactory.hpp b/src/dynamic/sample/SampleDynamicWorkloadFactory.hpp
index a5a31e5d6e..8cd36c5518 100644
--- a/src/dynamic/sample/SampleDynamicWorkloadFactory.hpp
+++ b/src/dynamic/sample/SampleDynamicWorkloadFactory.hpp
@@ -52,14 +52,18 @@ public:
 
     std::unique_ptr<armnn::IWorkload> CreateAddition(
             const armnn::AdditionQueueDescriptor& descriptor,
-            const armnn::WorkloadInfo& info) const override;
+            const armnn::WorkloadInfo& info) const;
 
 
     std::unique_ptr<armnn::IWorkload> CreateInput(const armnn::InputQueueDescriptor& descriptor,
-                                                  const armnn::WorkloadInfo& info) const override;
+                                                  const armnn::WorkloadInfo& info) const;
 
     std::unique_ptr<armnn::IWorkload> CreateOutput(const armnn::OutputQueueDescriptor& descriptor,
-                                                   const armnn::WorkloadInfo& info) const override;
+                                                   const armnn::WorkloadInfo& info) const;
+
+    std::unique_ptr<armnn::IWorkload> CreateWorkload(armnn::LayerType type,
+                                                    const armnn::QueueDescriptor& descriptor,
+                                                    const armnn::WorkloadInfo& info) const override;
 
 private:
     mutable std::shared_ptr<SampleMemoryManager> m_MemoryManager;