IVGCVSW-2202 Refactoring Arithmetic* names to Elementwise* names for workloads and workload functions

Change-Id: I6f3fce12a55f7d38ceafcdfcd6b5181bf56e2c09

6 files changed, 47 insertions, 47 deletions

diff --git a/src/backends/reference/workloads/CMakeLists.txt b/src/backends/reference/workloads/CMakeLists.txt
index 2d9ad926f7..86c5f908b9 100644
--- a/src/backends/reference/workloads/CMakeLists.txt
+++ b/src/backends/reference/workloads/CMakeLists.txt
@@ -6,8 +6,6 @@
 list(APPEND armnnRefBackendWorkloads_sources
     Activation.cpp
     Activation.hpp
-    ArithmeticFunction.cpp
-    ArithmeticFunction.hpp
     BatchNormImpl.hpp
     BatchToSpaceNd.cpp
     BatchToSpaceNd.hpp
@@ -15,6 +13,8 @@ list(APPEND armnnRefBackendWorkloads_sources
     Broadcast.hpp
     ConvImpl.cpp
     ConvImpl.hpp
+    ElementwiseFunction.cpp
+    ElementwiseFunction.hpp
     FullyConnected.cpp
     FullyConnected.hpp
     Merger.hpp
@@ -26,8 +26,6 @@ list(APPEND armnnRefBackendWorkloads_sources
     RefActivationFloat32Workload.hpp
     RefActivationUint8Workload.cpp
     RefActivationUint8Workload.hpp
-    RefArithmeticWorkload.cpp
-    RefArithmeticWorkload.hpp
     RefBaseConstantWorkload.cpp
     RefBaseConstantWorkload.hpp
     RefBatchNormalizationFloat32Workload.cpp
@@ -50,6 +48,8 @@ list(APPEND armnnRefBackendWorkloads_sources
     RefConvolution2dFloat32Workload.hpp
     RefConvolution2dUint8Workload.cpp
     RefConvolution2dUint8Workload.hpp
+    RefElementwiseWorkload.cpp
+    RefElementwiseWorkload.hpp
     RefDepthwiseConvolution2dFloat32Workload.cpp
     RefDepthwiseConvolution2dFloat32Workload.hpp
     RefDepthwiseConvolution2dUint8Workload.cpp
diff --git a/src/backends/reference/workloads/ArithmeticFunction.cpp b/src/backends/reference/workloads/ElementwiseFunction.cpp
index fede138253..bea3d2fb89 100644
--- a/src/backends/reference/workloads/ArithmeticFunction.cpp
+++ b/src/backends/reference/workloads/ElementwiseFunction.cpp
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include "ArithmeticFunction.hpp"
+#include "ElementwiseFunction.hpp"
 #include "Broadcast.hpp"
 #include <functional>
 
@@ -11,7 +11,7 @@ namespace armnn
 {
 
 template <typename Functor>
-ArithmeticFunction<Functor>::ArithmeticFunction(const TensorShape& inShape0,
+ElementwiseFunction<Functor>::ElementwiseFunction(const TensorShape& inShape0,
                                                 const TensorShape& inShape1,
                                                 const TensorShape& outShape,
                                                 const float* inData0,
@@ -23,7 +23,7 @@ ArithmeticFunction<Functor>::ArithmeticFunction(const TensorShape& inShape0,
 
 } //namespace armnn
 
-template struct armnn::ArithmeticFunction<std::plus<float>>;
-template struct armnn::ArithmeticFunction<std::minus<float>>;
-template struct armnn::ArithmeticFunction<std::multiplies<float>>;
-template struct armnn::ArithmeticFunction<std::divides<float>>;
+template struct armnn::ElementwiseFunction<std::plus<float>>;
+template struct armnn::ElementwiseFunction<std::minus<float>>;
+template struct armnn::ElementwiseFunction<std::multiplies<float>>;
+template struct armnn::ElementwiseFunction<std::divides<float>>;
diff --git a/src/backends/reference/workloads/ArithmeticFunction.hpp b/src/backends/reference/workloads/ElementwiseFunction.hpp
index eafb6444f6..5011616c0c 100644
--- a/src/backends/reference/workloads/ArithmeticFunction.hpp
+++ b/src/backends/reference/workloads/ElementwiseFunction.hpp
@@ -11,9 +11,9 @@ namespace armnn
 {
 
 template <typename Functor>
-struct ArithmeticFunction
+struct ElementwiseFunction
 {
-    ArithmeticFunction(const TensorShape& inShape0,
+    ElementwiseFunction(const TensorShape& inShape0,
                        const TensorShape& inShape1,
                        const TensorShape& outShape,
                        const float* inData0,
diff --git a/src/backends/reference/workloads/RefArithmeticWorkload.cpp b/src/backends/reference/workloads/RefElementwiseWorkload.cpp
index 6c39fa1186..8e312a7dd1 100644
--- a/src/backends/reference/workloads/RefArithmeticWorkload.cpp
+++ b/src/backends/reference/workloads/RefElementwiseWorkload.cpp
@@ -3,8 +3,8 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include "RefArithmeticWorkload.hpp"
-#include "ArithmeticFunction.hpp"
+#include "RefElementwiseWorkload.hpp"
+#include "ElementwiseFunction.hpp"
 #include "RefWorkloadUtils.hpp"
 #include "Profiling.hpp"
 #include <vector>
@@ -13,7 +13,7 @@ namespace armnn
 {
 
 template <typename ParentDescriptor, typename Functor>
-void BaseFloat32ArithmeticWorkload<ParentDescriptor, Functor>::ExecuteImpl(const char * debugString) const
+void BaseFloat32ElementwiseWorkload<ParentDescriptor, Functor>::ExecuteImpl(const char * debugString) const
 {
     ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, debugString);
 
@@ -26,11 +26,11 @@ void BaseFloat32ArithmeticWorkload<ParentDescriptor, Functor>::ExecuteImpl(const
     const float* inData1 = GetInputTensorDataFloat(1, data);
     float* outData = GetOutputTensorDataFloat(0, data);
 
-    ArithmeticFunction<Functor>(inShape0, inShape1, outShape, inData0, inData1, outData);
+    ElementwiseFunction<Functor>(inShape0, inShape1, outShape, inData0, inData1, outData);
 }
 
 template <typename ParentDescriptor, typename Functor>
-void BaseUint8ArithmeticWorkload<ParentDescriptor, Functor>::ExecuteImpl(const char * debugString) const
+void BaseUint8ElementwiseWorkload<ParentDescriptor, Functor>::ExecuteImpl(const char * debugString) const
 {
     ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, debugString);
 
@@ -44,7 +44,7 @@ void BaseUint8ArithmeticWorkload<ParentDescriptor, Functor>::ExecuteImpl(const c
 
     std::vector<float> results(outputInfo.GetNumElements());
 
-    ArithmeticFunction<Functor>(inputInfo0.GetShape(),
+    ElementwiseFunction<Functor>(inputInfo0.GetShape(),
                                 inputInfo1.GetShape(),
                                 outputInfo.GetShape(),
                                 dequant0.data(),
@@ -56,14 +56,14 @@ void BaseUint8ArithmeticWorkload<ParentDescriptor, Functor>::ExecuteImpl(const c
 
 }
 
-template class armnn::BaseFloat32ArithmeticWorkload<armnn::AdditionQueueDescriptor, std::plus<float>>;
-template class armnn::BaseUint8ArithmeticWorkload<armnn::AdditionQueueDescriptor, std::plus<float>>;
+template class armnn::BaseFloat32ElementwiseWorkload<armnn::AdditionQueueDescriptor, std::plus<float>>;
+template class armnn::BaseUint8ElementwiseWorkload<armnn::AdditionQueueDescriptor, std::plus<float>>;
 
-template class armnn::BaseFloat32ArithmeticWorkload<armnn::SubtractionQueueDescriptor, std::minus<float>>;
-template class armnn::BaseUint8ArithmeticWorkload<armnn::SubtractionQueueDescriptor, std::minus<float>>;
+template class armnn::BaseFloat32ElementwiseWorkload<armnn::SubtractionQueueDescriptor, std::minus<float>>;
+template class armnn::BaseUint8ElementwiseWorkload<armnn::SubtractionQueueDescriptor, std::minus<float>>;
 
-template class armnn::BaseFloat32ArithmeticWorkload<armnn::MultiplicationQueueDescriptor, std::multiplies<float>>;
-template class armnn::BaseUint8ArithmeticWorkload<armnn::MultiplicationQueueDescriptor, std::multiplies<float>>;
+template class armnn::BaseFloat32ElementwiseWorkload<armnn::MultiplicationQueueDescriptor, std::multiplies<float>>;
+template class armnn::BaseUint8ElementwiseWorkload<armnn::MultiplicationQueueDescriptor, std::multiplies<float>>;
 
-template class armnn::BaseFloat32ArithmeticWorkload<armnn::DivisionQueueDescriptor, std::divides<float>>;
-template class armnn::BaseUint8ArithmeticWorkload<armnn::DivisionQueueDescriptor, std::divides<float>>;
+template class armnn::BaseFloat32ElementwiseWorkload<armnn::DivisionQueueDescriptor, std::divides<float>>;
+template class armnn::BaseUint8ElementwiseWorkload<armnn::DivisionQueueDescriptor, std::divides<float>>;
diff --git a/src/backends/reference/workloads/RefArithmeticWorkload.hpp b/src/backends/reference/workloads/RefElementwiseWorkload.hpp
index 75606177a6..156613a49f 100644
--- a/src/backends/reference/workloads/RefArithmeticWorkload.hpp
+++ b/src/backends/reference/workloads/RefElementwiseWorkload.hpp
@@ -17,13 +17,13 @@ template <typename Functor,
           typename armnn::DataType DataType,
           typename ParentDescriptor,
           typename armnn::StringMapping::Id DebugString>
-class RefArithmeticWorkload
+class RefElementwiseWorkload
 {
     // Needs specialization. The default is empty on purpose.
 };
 
 template <typename ParentDescriptor, typename Functor>
-class BaseFloat32ArithmeticWorkload : public Float32Workload<ParentDescriptor>
+class BaseFloat32ElementwiseWorkload : public Float32Workload<ParentDescriptor>
 {
 public:
     using Float32Workload<ParentDescriptor>::Float32Workload;
@@ -33,21 +33,21 @@ public:
 template <typename Functor,
           typename ParentDescriptor,
           typename armnn::StringMapping::Id DebugString>
-class RefArithmeticWorkload<Functor, armnn::DataType::Float32, ParentDescriptor, DebugString>
-    : public BaseFloat32ArithmeticWorkload<ParentDescriptor, Functor>
+class RefElementwiseWorkload<Functor, armnn::DataType::Float32, ParentDescriptor, DebugString>
+    : public BaseFloat32ElementwiseWorkload<ParentDescriptor, Functor>
 {
 public:
-    using BaseFloat32ArithmeticWorkload<ParentDescriptor, Functor>::BaseFloat32ArithmeticWorkload;
+    using BaseFloat32ElementwiseWorkload<ParentDescriptor, Functor>::BaseFloat32ElementwiseWorkload;
 
     virtual void Execute() const override
     {
-        using Parent = BaseFloat32ArithmeticWorkload<ParentDescriptor, Functor>;
+        using Parent = BaseFloat32ElementwiseWorkload<ParentDescriptor, Functor>;
         Parent::ExecuteImpl(StringMapping::Instance().Get(DebugString));
     }
 };
 
 template <typename ParentDescriptor, typename Functor>
-class BaseUint8ArithmeticWorkload : public Uint8Workload<ParentDescriptor>
+class BaseUint8ElementwiseWorkload : public Uint8Workload<ParentDescriptor>
 {
 public:
     using Uint8Workload<ParentDescriptor>::Uint8Workload;
@@ -57,64 +57,64 @@ public:
 template <typename Functor,
           typename ParentDescriptor,
           typename armnn::StringMapping::Id DebugString>
-class RefArithmeticWorkload<Functor, armnn::DataType::QuantisedAsymm8, ParentDescriptor, DebugString>
-    : public BaseUint8ArithmeticWorkload<ParentDescriptor, Functor>
+class RefElementwiseWorkload<Functor, armnn::DataType::QuantisedAsymm8, ParentDescriptor, DebugString>
+    : public BaseUint8ElementwiseWorkload<ParentDescriptor, Functor>
 {
 public:
-    using BaseUint8ArithmeticWorkload<ParentDescriptor, Functor>::BaseUint8ArithmeticWorkload;
+    using BaseUint8ElementwiseWorkload<ParentDescriptor, Functor>::BaseUint8ElementwiseWorkload;
 
     virtual void Execute() const override
     {
-        using Parent = BaseUint8ArithmeticWorkload<ParentDescriptor, Functor>;
+        using Parent = BaseUint8ElementwiseWorkload<ParentDescriptor, Functor>;
         Parent::ExecuteImpl(StringMapping::Instance().Get(DebugString));
     }
 };
 
 using RefAdditionFloat32Workload =
-    RefArithmeticWorkload<std::plus<float>,
+    RefElementwiseWorkload<std::plus<float>,
                           DataType::Float32,
                           AdditionQueueDescriptor,
                           StringMapping::RefAdditionWorkload_Execute>;
 
 using RefAdditionUint8Workload =
-    RefArithmeticWorkload<std::plus<float>,
+    RefElementwiseWorkload<std::plus<float>,
                           DataType::QuantisedAsymm8,
                           AdditionQueueDescriptor,
                           StringMapping::RefAdditionWorkload_Execute>;
 
 
 using RefSubtractionFloat32Workload =
-    RefArithmeticWorkload<std::minus<float>,
+    RefElementwiseWorkload<std::minus<float>,
                           DataType::Float32,
                           SubtractionQueueDescriptor,
                           StringMapping::RefSubtractionWorkload_Execute>;
 
 using RefSubtractionUint8Workload =
-    RefArithmeticWorkload<std::minus<float>,
+    RefElementwiseWorkload<std::minus<float>,
                           DataType::QuantisedAsymm8,
                           SubtractionQueueDescriptor,
                           StringMapping::RefSubtractionWorkload_Execute>;
 
 using RefMultiplicationFloat32Workload =
-    RefArithmeticWorkload<std::multiplies<float>,
+    RefElementwiseWorkload<std::multiplies<float>,
                           DataType::Float32,
                           MultiplicationQueueDescriptor,
                           StringMapping::RefMultiplicationWorkload_Execute>;
 
 using RefMultiplicationUint8Workload =
-    RefArithmeticWorkload<std::multiplies<float>,
+    RefElementwiseWorkload<std::multiplies<float>,
                           DataType::QuantisedAsymm8,
                           MultiplicationQueueDescriptor,
                           StringMapping::RefMultiplicationWorkload_Execute>;
 
 using RefDivisionFloat32Workload =
-    RefArithmeticWorkload<std::divides<float>,
+    RefElementwiseWorkload<std::divides<float>,
                           DataType::Float32,
                           DivisionQueueDescriptor,
                           StringMapping::RefDivisionWorkload_Execute>;
 
 using RefDivisionUint8Workload =
-    RefArithmeticWorkload<std::divides<float>,
+    RefElementwiseWorkload<std::divides<float>,
                           DataType::QuantisedAsymm8,
                           DivisionQueueDescriptor,
                           StringMapping::RefDivisionWorkload_Execute>;
diff --git a/src/backends/reference/workloads/RefWorkloads.hpp b/src/backends/reference/workloads/RefWorkloads.hpp
index 20e9a9f5d3..86d86248b2 100644
--- a/src/backends/reference/workloads/RefWorkloads.hpp
+++ b/src/backends/reference/workloads/RefWorkloads.hpp
@@ -6,8 +6,8 @@
 #pragma once
 
 #include "RefConstantUint8Workload.hpp"
-#include "ArithmeticFunction.hpp"
-#include "RefArithmeticWorkload.hpp"
+#include "ElementwiseFunction.hpp"
+#include "RefElementwiseWorkload.hpp"
 #include "ConvImpl.hpp"
 #include "RefBaseConstantWorkload.hpp"
 #include "RefConvolution2dUint8Workload.hpp"