IVGCVSW-5005 Fix Deprecated Functions in CL/NEON Resize Workload

 * Update CL pin to f3ad9513dd46fca1d6c5e4550286480fdbaba056

IVGCVSW-5005: Fix Deprecated Functions in CL/NEON Resize Workload
 * Add missing virtual function to NeonIntercepterScheduler
 * Update CL/Neon Resize Workloads to use ScaleKernelInfo
 * Update CL/Neon Resize workloads to set correct Sampling Policy for Half Pixels

IVGCVSW-4981: Change CL/NEON Softmax axis value
 * Default value is now 0

Signed-off-by: David Monahan <david.monahan@arm.com>
Change-Id: I8a14c6a64e5a24bc1a66a7d3685cd388c2245702

8 files changed, 71 insertions, 30 deletions

diff --git a/scripts/get_compute_library.sh b/scripts/get_compute_library.sh
index 112ded1b32..dffc7f2058 100755
--- a/scripts/get_compute_library.sh
+++ b/scripts/get_compute_library.sh
@@ -10,7 +10,7 @@ CMD=$( basename $0 )
 #DEFAULT_CLFRAMEWORKREVISION="branches/arm_compute_20_05" # Release 20.05
 #
 # For pinning to a revision use this:
-DEFAULT_CLFRAMEWORKREVISION="980a9168b81d778f4902973b4920b54c103907e0" #COMPMID-3177: Remove padding from NEBatchNormalizationLayer.
+DEFAULT_CLFRAMEWORKREVISION="f3ad9513dd46fca1d6c5e4550286480fdbaba056" #COMPMID-3324: Fix paths in Android.bp
 
 usage() {
     echo "Usage: $CMD (Use the default clframework SHA)"
diff --git a/src/backends/aclCommon/ArmComputeUtils.hpp b/src/backends/aclCommon/ArmComputeUtils.hpp
index 0ee13b3e7f..eae152dc20 100644
--- a/src/backends/aclCommon/ArmComputeUtils.hpp
+++ b/src/backends/aclCommon/ArmComputeUtils.hpp
@@ -153,18 +153,21 @@ inline arm_compute::InterpolationPolicy ConvertResizeMethodToAclInterpolationPol
 template<typename T>
 inline T ComputeSoftmaxAclAxis(const SoftmaxDescriptor& softmaxDesc, const armnn::TensorInfo& tensor)
 {
-    // Detect the Android default value of -1 and return the ACL default value of 1.
+    // Detect the Android default value of -1 and return the ACL default value of 0.
     if (softmaxDesc.m_Axis == -1)
     {
-        return 1;
+        return 0;
     }
 
-   unsigned int dim = tensor.GetNumDimensions();
+    unsigned int dim = tensor.GetNumDimensions();
 
     ARMNN_ASSERT(dim != 0);
 
     // Currently ArmNN support axis 1.
-    return static_cast<T>(dim) - 1;
+    auto aclAxis = (static_cast<T>(dim) - 1);
+    aclAxis = aclAxis > 0 ? aclAxis -1 : aclAxis;
+
+    return aclAxis;
 }
 
 inline std::set<unsigned int> ComputeSplitAxis(const armnn::SplitterDescriptor& desc, const TensorShape& input)
diff --git a/src/backends/backendsCommon/test/JsonPrinterTestImpl.cpp b/src/backends/backendsCommon/test/JsonPrinterTestImpl.cpp
index 50dc61b1f4..6251507e51 100644
--- a/src/backends/backendsCommon/test/JsonPrinterTestImpl.cpp
+++ b/src/backends/backendsCommon/test/JsonPrinterTestImpl.cpp
@@ -134,10 +134,10 @@ std::string GetSoftmaxProfilerJson(const std::vector<armnn::BackendId>& backends
 
     IConnectableLayer* input = net->AddInputLayer(0, "input");
     SoftmaxDescriptor softmaxDescriptor;
-    // Set Axis to 1 if CL or Neon until further Axes are supported.
+    // Set Axis to 0 if CL or Neon until further Axes are supported.
     if ( backends.front() == armnn::Compute::CpuAcc || backends.front() == armnn::Compute::GpuAcc)
     {
-        softmaxDescriptor.m_Axis = 1;
+        softmaxDescriptor.m_Axis = 0;
     }
     IConnectableLayer* softmax = net->AddSoftmaxLayer(softmaxDescriptor, "softmax");
     IConnectableLayer* output  = net->AddOutputLayer(0, "output");
diff --git a/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp
index 953b543acb..fa7ab90b16 100644
--- a/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/SoftmaxTestImpl.cpp
@@ -63,7 +63,7 @@ LayerTestResult<T, n> SimpleSoftmaxBaseTestImpl(
     const armnn::TensorShape& inputShape,
     const std::vector<float>& outputData,
     const std::vector<float>& inputData,
-    int axis = 1)
+    int axis = -1)
 {
     IgnoreUnused(memoryManager);
     using std::exp;
diff --git a/src/backends/cl/workloads/ClResizeWorkload.cpp b/src/backends/cl/workloads/ClResizeWorkload.cpp
index adfb3686fd..744a915616 100644
--- a/src/backends/cl/workloads/ClResizeWorkload.cpp
+++ b/src/backends/cl/workloads/ClResizeWorkload.cpp
@@ -33,14 +33,17 @@ arm_compute::Status ClResizeWorkloadValidate(const TensorInfo& input,
     arm_compute::InterpolationPolicy aclInterpolationPolicy =
         ConvertResizeMethodToAclInterpolationPolicy(descriptor.m_Method);
 
+    arm_compute::SamplingPolicy samplingPolicy = descriptor.m_HalfPixelCenters ? arm_compute::SamplingPolicy::CENTER :
+                                                                                 arm_compute::SamplingPolicy::TOP_LEFT;
+
     return arm_compute::CLScale::validate(&aclInputInfo,
                                           &aclOutputInfo,
-                                          aclInterpolationPolicy,
-                                          arm_compute::BorderMode::REPLICATE,
-                                          arm_compute::PixelValue(0.f),
-                                          arm_compute::SamplingPolicy::TOP_LEFT,
-                                          true,
-                                          descriptor.m_AlignCorners);
+                                          arm_compute::ScaleKernelInfo(aclInterpolationPolicy,
+                                                                       arm_compute::BorderMode::REPLICATE,
+                                                                       arm_compute::PixelValue(0.f),
+                                                                       samplingPolicy,
+                                                                       true,
+                                                                       descriptor.m_AlignCorners));
 }
 
 ClResizeWorkload::ClResizeWorkload(const ResizeQueueDescriptor& descriptor, const WorkloadInfo& info) :
@@ -58,14 +61,19 @@ ClResizeWorkload::ClResizeWorkload(const ResizeQueueDescriptor& descriptor, cons
     arm_compute::InterpolationPolicy aclInterpolationPolicy =
         ConvertResizeMethodToAclInterpolationPolicy(descriptor.m_Parameters.m_Method);
 
+    arm_compute::SamplingPolicy samplingPolicy = descriptor.m_Parameters.m_HalfPixelCenters
+                                                 ? arm_compute::SamplingPolicy::CENTER
+                                                 : arm_compute::SamplingPolicy::TOP_LEFT;
+
     m_ResizeLayer.configure(&input,
                             &output,
-                            aclInterpolationPolicy,
-                            arm_compute::BorderMode::REPLICATE,
-                            arm_compute::PixelValue(0.f),
-                            arm_compute::SamplingPolicy::TOP_LEFT,
-                            true,
-                            descriptor.m_Parameters.m_AlignCorners);
+                            arm_compute::ScaleKernelInfo(aclInterpolationPolicy,
+                                                         arm_compute::BorderMode::REPLICATE,
+                                                         arm_compute::PixelValue(0.f),
+                                                         samplingPolicy,
+                                                         true,
+                                                         descriptor.m_Parameters.m_AlignCorners));
+
 };
 
 void ClResizeWorkload::Execute() const
diff --git a/src/backends/neon/NeonInterceptorScheduler.cpp b/src/backends/neon/NeonInterceptorScheduler.cpp
index 745c5fde62..b4d9b300df 100644
--- a/src/backends/neon/NeonInterceptorScheduler.cpp
+++ b/src/backends/neon/NeonInterceptorScheduler.cpp
@@ -52,4 +52,18 @@ void NeonInterceptorScheduler::run_tagged_workloads(std::vector<Workload> &workl
     m_Kernels->emplace_back(std::string(tag != nullptr ? tag : "Unknown"), delta.count(), Measurement::Unit::TIME_US);
 }
 
+void NeonInterceptorScheduler::schedule_op(arm_compute::ICPPKernel *kernel,
+                                           const Hints &hints,
+                                           const arm_compute::InputTensorMap &inputs,
+                                           const arm_compute::OutputTensorMap &outputs )
+{
+
+    WallClockTimer::clock::time_point startTime = WallClockTimer::clock::now();
+    m_RealScheduler.schedule_op(kernel, hints, inputs, outputs);
+    WallClockTimer::clock::time_point stopTime = WallClockTimer::clock::now();
+
+    const auto delta       = std::chrono::duration<double, std::micro>(stopTime - startTime);
+    m_Kernels->emplace_back(kernel->name(), delta.count(), Measurement::Unit::TIME_US);
+}
+
 } // namespace armnn
\ No newline at end of file
diff --git a/src/backends/neon/NeonInterceptorScheduler.hpp b/src/backends/neon/NeonInterceptorScheduler.hpp
index 3a6f2aa5ec..fe80c62c5f 100644
--- a/src/backends/neon/NeonInterceptorScheduler.hpp
+++ b/src/backends/neon/NeonInterceptorScheduler.hpp
@@ -10,6 +10,7 @@
 #include <arm_compute/runtime/IScheduler.h>
 #include <arm_compute/runtime/Scheduler.h>
 #include <arm_compute/core/CPP/ICPPKernel.h>
+#include <arm_compute/core/experimental/Types.h>
 
 namespace armnn
 {
@@ -32,6 +33,11 @@ public:
 
     void SetKernels(NeonTimer::KernelMeasurements* kernels) { m_Kernels = kernels; }
     NeonTimer::KernelMeasurements* GetKernels() { return m_Kernels; }
+
+    void schedule_op(arm_compute::ICPPKernel *kernel,
+                     const Hints &hints,
+                     const arm_compute::InputTensorMap &inputs,
+                     const arm_compute::OutputTensorMap &outputs ) override;
 private:
     NeonTimer::KernelMeasurements* m_Kernels;
     arm_compute::IScheduler& m_RealScheduler;
diff --git a/src/backends/neon/workloads/NeonResizeWorkload.cpp b/src/backends/neon/workloads/NeonResizeWorkload.cpp
index afb753fd64..fc378cae2f 100644
--- a/src/backends/neon/workloads/NeonResizeWorkload.cpp
+++ b/src/backends/neon/workloads/NeonResizeWorkload.cpp
@@ -33,12 +33,18 @@ arm_compute::Status NeonResizeWorkloadValidate(const TensorInfo& input,
     arm_compute::InterpolationPolicy aclInterpolationPolicy =
             ConvertResizeMethodToAclInterpolationPolicy(descriptor.m_Method);
 
+    arm_compute::SamplingPolicy samplingPolicy = descriptor.m_HalfPixelCenters ? arm_compute::SamplingPolicy::CENTER :
+                                                                                 arm_compute::SamplingPolicy::TOP_LEFT;
+
     return arm_compute::NEScale::validate(&aclInputInfo,
                                           &aclOutputInfo,
-                                          aclInterpolationPolicy,
-                                          arm_compute::BorderMode::REPLICATE,
-                                          arm_compute::PixelValue(0.f),
-                                          arm_compute::SamplingPolicy::TOP_LEFT);
+                                          arm_compute::ScaleKernelInfo(aclInterpolationPolicy,
+                                                                       arm_compute::BorderMode::REPLICATE,
+                                                                       arm_compute::PixelValue(0.f),
+                                                                       samplingPolicy,
+                                                                       true,
+                                                                       descriptor.m_AlignCorners));
+
 }
 
 NeonResizeWorkload::NeonResizeWorkload(const ResizeQueueDescriptor& descriptor,
@@ -57,14 +63,18 @@ NeonResizeWorkload::NeonResizeWorkload(const ResizeQueueDescriptor& descriptor,
     arm_compute::InterpolationPolicy aclInterpolationPolicy =
             ConvertResizeMethodToAclInterpolationPolicy(descriptor.m_Parameters.m_Method);
 
+    arm_compute::SamplingPolicy samplingPolicy = descriptor.m_Parameters.m_HalfPixelCenters
+                                                 ? arm_compute::SamplingPolicy::CENTER
+                                                 : arm_compute::SamplingPolicy::TOP_LEFT;
+
     m_ResizeLayer.configure(&input,
                             &output,
-                            aclInterpolationPolicy,
-                            arm_compute::BorderMode::REPLICATE,
-                            arm_compute::PixelValue(0.f),
-                            arm_compute::SamplingPolicy::TOP_LEFT,
-                            true,
-                            descriptor.m_Parameters.m_AlignCorners);
+                            arm_compute::ScaleKernelInfo(aclInterpolationPolicy,
+                                                         arm_compute::BorderMode::REPLICATE,
+                                                         arm_compute::PixelValue(0.f),
+                                                         samplingPolicy,
+                                                         true,
+                                                         descriptor.m_Parameters.m_AlignCorners));
 };
 
 void NeonResizeWorkload::Execute() const