From b4540bef0b0327683fe8e63f727c1212800dc2a9 Mon Sep 17 00:00:00 2001
From: David Beck <david.beck@arm.com>
Date: Mon, 24 Sep 2018 13:18:27 +0100
Subject: IVGCVSW-1898 : Ref backend folder structure

* Reference backend is renamed to backends/reference as per
  https://confluence.arm.com/display/MLENG/Pluggable+backends

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

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

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