From d57415d9a2117da9cc5c58f8b5e39ba7455417d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89anna=20=C3=93=20Cath=C3=A1in?=
 <eanna.ocathain@arm.com>
Date: Wed, 28 Nov 2018 16:24:38 +0000
Subject: IVGCVSW-2202 Refactoring Arithmetic* names to Elementwise* names for
 workloads and workload functions

Change-Id: I6f3fce12a55f7d38ceafcdfcd6b5181bf56e2c09
---
 .../reference/workloads/RefElementwiseWorkload.hpp | 122 +++++++++++++++++++++
 1 file changed, 122 insertions(+)
 create mode 100644 src/backends/reference/workloads/RefElementwiseWorkload.hpp

(limited to 'src/backends/reference/workloads/RefElementwiseWorkload.hpp')

diff --git a/src/backends/reference/workloads/RefElementwiseWorkload.hpp b/src/backends/reference/workloads/RefElementwiseWorkload.hpp
new file mode 100644
index 0000000000..156613a49f
--- /dev/null
+++ b/src/backends/reference/workloads/RefElementwiseWorkload.hpp
@@ -0,0 +1,122 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnn/Types.hpp>
+#include <backendsCommon/StringMapping.hpp>
+#include <backendsCommon/Workload.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+
+namespace armnn
+{
+
+template <typename Functor,
+          typename armnn::DataType DataType,
+          typename ParentDescriptor,
+          typename armnn::StringMapping::Id DebugString>
+class RefElementwiseWorkload
+{
+    // Needs specialization. The default is empty on purpose.
+};
+
+template <typename ParentDescriptor, typename Functor>
+class BaseFloat32ElementwiseWorkload : public Float32Workload<ParentDescriptor>
+{
+public:
+    using Float32Workload<ParentDescriptor>::Float32Workload;
+    void ExecuteImpl(const char * debugString) const;
+};
+
+template <typename Functor,
+          typename ParentDescriptor,
+          typename armnn::StringMapping::Id DebugString>
+class RefElementwiseWorkload<Functor, armnn::DataType::Float32, ParentDescriptor, DebugString>
+    : public BaseFloat32ElementwiseWorkload<ParentDescriptor, Functor>
+{
+public:
+    using BaseFloat32ElementwiseWorkload<ParentDescriptor, Functor>::BaseFloat32ElementwiseWorkload;
+
+    virtual void Execute() const override
+    {
+        using Parent = BaseFloat32ElementwiseWorkload<ParentDescriptor, Functor>;
+        Parent::ExecuteImpl(StringMapping::Instance().Get(DebugString));
+    }
+};
+
+template <typename ParentDescriptor, typename Functor>
+class BaseUint8ElementwiseWorkload : public Uint8Workload<ParentDescriptor>
+{
+public:
+    using Uint8Workload<ParentDescriptor>::Uint8Workload;
+    void ExecuteImpl(const char * debugString) const;
+};
+
+template <typename Functor,
+          typename ParentDescriptor,
+          typename armnn::StringMapping::Id DebugString>
+class RefElementwiseWorkload<Functor, armnn::DataType::QuantisedAsymm8, ParentDescriptor, DebugString>
+    : public BaseUint8ElementwiseWorkload<ParentDescriptor, Functor>
+{
+public:
+    using BaseUint8ElementwiseWorkload<ParentDescriptor, Functor>::BaseUint8ElementwiseWorkload;
+
+    virtual void Execute() const override
+    {
+        using Parent = BaseUint8ElementwiseWorkload<ParentDescriptor, Functor>;
+        Parent::ExecuteImpl(StringMapping::Instance().Get(DebugString));
+    }
+};
+
+using RefAdditionFloat32Workload =
+    RefElementwiseWorkload<std::plus<float>,
+                          DataType::Float32,
+                          AdditionQueueDescriptor,
+                          StringMapping::RefAdditionWorkload_Execute>;
+
+using RefAdditionUint8Workload =
+    RefElementwiseWorkload<std::plus<float>,
+                          DataType::QuantisedAsymm8,
+                          AdditionQueueDescriptor,
+                          StringMapping::RefAdditionWorkload_Execute>;
+
+
+using RefSubtractionFloat32Workload =
+    RefElementwiseWorkload<std::minus<float>,
+                          DataType::Float32,
+                          SubtractionQueueDescriptor,
+                          StringMapping::RefSubtractionWorkload_Execute>;
+
+using RefSubtractionUint8Workload =
+    RefElementwiseWorkload<std::minus<float>,
+                          DataType::QuantisedAsymm8,
+                          SubtractionQueueDescriptor,
+                          StringMapping::RefSubtractionWorkload_Execute>;
+
+using RefMultiplicationFloat32Workload =
+    RefElementwiseWorkload<std::multiplies<float>,
+                          DataType::Float32,
+                          MultiplicationQueueDescriptor,
+                          StringMapping::RefMultiplicationWorkload_Execute>;
+
+using RefMultiplicationUint8Workload =
+    RefElementwiseWorkload<std::multiplies<float>,
+                          DataType::QuantisedAsymm8,
+                          MultiplicationQueueDescriptor,
+                          StringMapping::RefMultiplicationWorkload_Execute>;
+
+using RefDivisionFloat32Workload =
+    RefElementwiseWorkload<std::divides<float>,
+                          DataType::Float32,
+                          DivisionQueueDescriptor,
+                          StringMapping::RefDivisionWorkload_Execute>;
+
+using RefDivisionUint8Workload =
+    RefElementwiseWorkload<std::divides<float>,
+                          DataType::QuantisedAsymm8,
+                          DivisionQueueDescriptor,
+                          StringMapping::RefDivisionWorkload_Execute>;
+
+} // armnn
-- 
cgit v1.2.1