IVGCVSW-5257 'Remove CreateTensorHandle in the test for layers beginning with S'

* Re-factored SoftmaxTestImpl to use TensorHandleFactory to create TensorHandles

Signed-off-by: Sadik Armagan <sadik.armagan@arm.com>
Change-Id: I83559a89187bbed0d6f34ca589ea81c694bf5683

1 files changed, 57 insertions, 34 deletions

diff --git a/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp
index 1ffb34f932..d26b3dbba8 100644
--- a/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp
@@ -59,13 +59,13 @@ template<armnn::DataType ArmnnType, std::size_t n, typename T = armnn::ResolveTy
 LayerTestResult<T, n> SimpleSoftmaxBaseTestImpl(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::ITensorHandleFactory* tensorHandleFactory,
     float beta,
     const armnn::TensorShape& inputShape,
     const std::vector<float>& outputData,
     const std::vector<float>& inputData,
     int axis = -1)
 {
-    IgnoreUnused(memoryManager);
     using std::exp;
 
     const float qScale = 1.f / 256.f;
@@ -87,10 +87,8 @@ LayerTestResult<T, n> SimpleSoftmaxBaseTestImpl(
     // Each row is independently softmax'd.
     auto input = MakeTensor<T, n>(inputTensorInfo, armnnUtils::QuantizedVector<T>(inputData, qScale, qOffset));
 
-    ARMNN_NO_DEPRECATE_WARN_BEGIN
-    std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
-    std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
-    ARMNN_NO_DEPRECATE_WARN_END
+    std::unique_ptr<armnn::ITensorHandle> inputHandle  = tensorHandleFactory->CreateTensorHandle(inputTensorInfo);
+    std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory->CreateTensorHandle(outputTensorInfo);
 
     armnn::SoftmaxQueueDescriptor data;
     data.m_Parameters.m_Beta = beta;
@@ -122,6 +120,7 @@ template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 2> SimpleSoftmaxTestImpl(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::ITensorHandleFactory* tensorHandleFactory,
     float beta)
 {
     using std::exp;
@@ -143,7 +142,7 @@ LayerTestResult<T, 2> SimpleSoftmaxTestImpl(
                 .5f, 0.f, 0.f, 0.f,
             };
 
-    return SimpleSoftmaxBaseTestImpl<ArmnnType, 2>(workloadFactory, memoryManager, beta,
+    return SimpleSoftmaxBaseTestImpl<ArmnnType, 2>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                    inputShape, outputData, inputData);
 }
 
@@ -151,6 +150,7 @@ template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 2> SimpleSoftmaxTestImpl(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta,
         int axis)
 {
@@ -198,7 +198,7 @@ LayerTestResult<T, 2> SimpleSoftmaxTestImpl(
         break;
         }
     }
-    return SimpleSoftmaxBaseTestImpl<ArmnnType, 2>(workloadFactory, memoryManager, beta,
+    return SimpleSoftmaxBaseTestImpl<ArmnnType, 2>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                    inputShape, outputData, inputData, axis);
 }
 
@@ -206,13 +206,14 @@ template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 3> Simple3dSoftmaxTestImpl(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::ITensorHandleFactory* tensorHandleFactory,
     float beta,
     const armnn::TensorShape& inputShape,
     const std::vector<float>& outputData,
     const std::vector<float>& inputData,
     int axis = 1)
 {
-    return SimpleSoftmaxBaseTestImpl<ArmnnType, 3>(workloadFactory, memoryManager, beta,
+    return SimpleSoftmaxBaseTestImpl<ArmnnType, 3>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                    inputShape, outputData, inputData, axis);
 }
 
@@ -220,6 +221,7 @@ template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 LayerTestResult<T, 4> Simple4dSoftmaxTestImpl(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::ITensorHandleFactory* tensorHandleFactory,
     float beta,
     const armnn::TensorShape& inputShape,
     const std::vector<float>& outputData,
@@ -227,7 +229,7 @@ LayerTestResult<T, 4> Simple4dSoftmaxTestImpl(
     int axis = 1)
 {
 
-    return SimpleSoftmaxBaseTestImpl<ArmnnType, 4>(workloadFactory, memoryManager, beta,
+    return SimpleSoftmaxBaseTestImpl<ArmnnType, 4>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                    inputShape, outputData, inputData, axis);
 }
 
@@ -236,9 +238,10 @@ LayerTestResult<T, 2> CompareSoftmaxTestImpl(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
         armnn::IWorkloadFactory& refWorkloadFactory,
+        const armnn::ITensorHandleFactory* tensorHandleFactory,
+        const armnn::ITensorHandleFactory* refTensorHandleFactory,
         float beta)
 {
-
     const int batchSize = 20;
     const int channels = 30;
 
@@ -260,10 +263,8 @@ LayerTestResult<T, 2> CompareSoftmaxTestImpl(
     LayerTestResult<T, 2> ret(outputTensorInfo);
     auto input = MakeRandomTensor<T, 2>(inputTensorInfo, 0xF00D, 0.0f, 1.0f);
 
-    ARMNN_NO_DEPRECATE_WARN_BEGIN
-    std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
-    std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
-    ARMNN_NO_DEPRECATE_WARN_END
+    std::unique_ptr<armnn::ITensorHandle> inputHandle  = tensorHandleFactory->CreateTensorHandle(inputTensorInfo);
+    std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory->CreateTensorHandle(outputTensorInfo);
 
     armnn::SoftmaxQueueDescriptor data;
     data.m_Parameters.m_Beta = beta;
@@ -272,10 +273,10 @@ LayerTestResult<T, 2> CompareSoftmaxTestImpl(
     AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
     AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
 
-    ARMNN_NO_DEPRECATE_WARN_BEGIN
-    std::unique_ptr<armnn::ITensorHandle> outputHandleRef = refWorkloadFactory.CreateTensorHandle(outputTensorInfo);
-    std::unique_ptr<armnn::ITensorHandle> inputHandleRef = refWorkloadFactory.CreateTensorHandle(inputTensorInfo);
-    ARMNN_NO_DEPRECATE_WARN_END
+    std::unique_ptr<armnn::ITensorHandle> outputHandleRef =
+        refTensorHandleFactory->CreateTensorHandle(outputTensorInfo);
+    std::unique_ptr<armnn::ITensorHandle> inputHandleRef  =
+        refTensorHandleFactory->CreateTensorHandle(inputTensorInfo);
 
     armnn::SoftmaxQueueDescriptor refData = data;
     armnn::WorkloadInfo refInfo = info;
@@ -309,33 +310,38 @@ LayerTestResult<T, 2> CompareSoftmaxTestImpl(
 LayerTestResult<float,2> SimpleSoftmaxTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::ITensorHandleFactory* tensorHandleFactory,
     float beta)
 {
-    return SimpleSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta);
+    return SimpleSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, tensorHandleFactory, beta);
 }
 
 LayerTestResult<float,2> SimpleAxisSoftmaxTest(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta,
         int axis)
 {
-    return SimpleSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta, axis);
+    return SimpleSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager,
+                                                           tensorHandleFactory, beta, axis);
 }
 
 LayerTestResult<float,3> Simple3dSoftmaxTest(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
     Simple3dSoftmaxOutputData data;
-    return Simple3dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta,
+    return Simple3dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                              data.inputShape, data.outputData, data.inputData);
 }
 
 LayerTestResult<float,3> Simple3dAxisSoftmaxTest(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta,
         int axis)
 {
@@ -423,23 +429,25 @@ LayerTestResult<float,3> Simple3dAxisSoftmaxTest(
         }
     }
 
-    return Simple3dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta,
+    return Simple3dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                              inputShape, outputData, inputData, axis);
 }
 
 LayerTestResult<float,4> Simple4dSoftmaxTest(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
     Simple4dSoftmaxData data;
-    return Simple4dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta, data.inputShape,
-                                                             data.outputData, data.inputData);
+    return Simple4dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, tensorHandleFactory,
+                                                             beta, data.inputShape, data.outputData, data.inputData);
 }
 
 LayerTestResult<float,4> Simple4dAxisSoftmaxTest(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta,
         int axis)
 {
@@ -594,6 +602,7 @@ LayerTestResult<float,4> Simple4dAxisSoftmaxTest(
     return Simple4dSoftmaxTestImpl<armnn::DataType::Float32>(
         workloadFactory,
         memoryManager,
+        tensorHandleFactory,
         beta,
         inputShape,
         outputData,
@@ -604,20 +613,23 @@ LayerTestResult<float,4> Simple4dAxisSoftmaxTest(
 LayerTestResult<uint8_t,2> SimpleSoftmaxUint8Test(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+    armnn::ITensorHandleFactory* tensorHandleFactory,
     float beta)
 {
-    return SimpleSoftmaxTestImpl<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, beta);
+    return SimpleSoftmaxTestImpl<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, tensorHandleFactory, beta);
 }
 
 LayerTestResult<uint8_t,3> Simple3dSoftmaxUint8Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
     Simple3dSoftmaxOutputData data;
     return Simple3dSoftmaxTestImpl<armnn::DataType::QAsymmU8>(
         workloadFactory,
         memoryManager,
+        tensorHandleFactory,
         beta,
         data.inputShape,
         data.outputData,
@@ -627,68 +639,75 @@ LayerTestResult<uint8_t,3> Simple3dSoftmaxUint8Test(
 LayerTestResult<uint8_t,4> Simple4dSoftmaxUint8Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
     Simple4dSoftmaxData data;
 
-    return Simple4dSoftmaxTestImpl<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, beta,
+    return Simple4dSoftmaxTestImpl<armnn::DataType::QAsymmU8>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                                      data.inputShape, data.outputData, data.inputData);
 }
 
 LayerTestResult<armnn::Half,2> SimpleSoftmaxFloat16Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
-    return SimpleSoftmaxTestImpl<armnn::DataType::Float16>(workloadFactory, memoryManager, beta);
+    return SimpleSoftmaxTestImpl<armnn::DataType::Float16>(workloadFactory, memoryManager, tensorHandleFactory, beta);
 }
 
 LayerTestResult<armnn::Half,3> Simple3dSoftmaxFloat16Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
     Simple3dSoftmaxOutputData data;
-    return Simple3dSoftmaxTestImpl<armnn::DataType::Float16>(workloadFactory, memoryManager, beta,
+    return Simple3dSoftmaxTestImpl<armnn::DataType::Float16>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                              data.inputShape, data.outputData, data.inputData);
 }
 
 LayerTestResult<armnn::Half,4> Simple4dSoftmaxFloat16Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
     Simple4dSoftmaxData data;
-    return Simple4dSoftmaxTestImpl<armnn::DataType::Float16>(workloadFactory, memoryManager, beta,
+    return Simple4dSoftmaxTestImpl<armnn::DataType::Float16>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                              data.inputShape, data.outputData, data.inputData);
 }
 
 LayerTestResult<int16_t,2> SimpleSoftmaxUint16Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
-    return SimpleSoftmaxTestImpl<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, beta);
+    return SimpleSoftmaxTestImpl<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, tensorHandleFactory, beta);
 }
 
 LayerTestResult<int16_t,3> Simple3dSoftmaxUint16Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
     Simple3dSoftmaxOutputData data;
-    return Simple3dSoftmaxTestImpl<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, beta,
+    return Simple3dSoftmaxTestImpl<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                                      data.inputShape, data.outputData, data.inputData);
 }
 
 LayerTestResult<int16_t,4> Simple4dSoftmaxUint16Test(
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
+        armnn::ITensorHandleFactory* tensorHandleFactory,
         float beta)
 {
     Simple4dSoftmaxData data;
 
-    return Simple4dSoftmaxTestImpl<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, beta,
+    return Simple4dSoftmaxTestImpl<armnn::DataType::QSymmS16>(workloadFactory, memoryManager, tensorHandleFactory, beta,
                                                                      data.inputShape, data.outputData, data.inputData);
 }
 
@@ -696,18 +715,22 @@ LayerTestResult<float,2> CompareSoftmaxTest(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::IWorkloadFactory& refWorkloadFactory,
+    const armnn::ITensorHandleFactory* tensorHandleFactory,
+    const armnn::ITensorHandleFactory* refTensorHandleFactory,
     float beta)
 {
     return CompareSoftmaxTestImpl<armnn::DataType::Float32>(
-        workloadFactory, memoryManager, refWorkloadFactory, beta);
+        workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory, beta);
 }
 
 LayerTestResult<uint8_t,2> CompareSoftmaxUint8Test(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     armnn::IWorkloadFactory& refWorkloadFactory,
+    const armnn::ITensorHandleFactory* tensorHandleFactory,
+    const armnn::ITensorHandleFactory* refTensorHandleFactory,
     float beta)
 {
     return CompareSoftmaxTestImpl<armnn::DataType::QAsymmU8>(
-        workloadFactory, memoryManager, refWorkloadFactory, beta);
+        workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory, beta);
 }