IVGCVSW-1784: Rename float32 workloads for ACL
Change-Id: I98bdfe9cb12c663d1d5cfa456e2cc967d70ab22b
diff --git a/src/armnn/backends/ClLayerSupport.cpp b/src/armnn/backends/ClLayerSupport.cpp
index 77e74f5..623bdca 100644
--- a/src/armnn/backends/ClLayerSupport.cpp
+++ b/src/armnn/backends/ClLayerSupport.cpp
@@ -14,22 +14,22 @@
#include <boost/core/ignore_unused.hpp>
#ifdef ARMCOMPUTECL_ENABLED
-#include "ClWorkloads/ClAdditionFloat32Workload.hpp"
-#include "ClWorkloads/ClActivationFloat32Workload.hpp"
-#include "ClWorkloads/ClBatchNormalizationFloat32Workload.hpp"
+#include "ClWorkloads/ClAdditionFloatWorkload.hpp"
+#include "ClWorkloads/ClActivationFloatWorkload.hpp"
+#include "ClWorkloads/ClBatchNormalizationFloatWorkload.hpp"
#include "ClWorkloads/ClConvertFp16ToFp32Workload.hpp"
#include "ClWorkloads/ClConvertFp32ToFp16Workload.hpp"
#include "ClWorkloads/ClConvolution2dBaseWorkload.hpp"
#include "ClWorkloads/ClDepthwiseConvolutionBaseWorkload.hpp"
#include "ClWorkloads/ClDivisionFloatWorkload.hpp"
-#include "ClWorkloads/ClL2NormalizationFloat32Workload.hpp"
-#include "ClWorkloads/ClMultiplicationFloat32Workload.hpp"
-#include "ClWorkloads/ClFullyConnectedFloat32Workload.hpp"
+#include "ClWorkloads/ClL2NormalizationFloatWorkload.hpp"
+#include "ClWorkloads/ClMultiplicationFloatWorkload.hpp"
+#include "ClWorkloads/ClFullyConnectedFloatWorkload.hpp"
#include "ClWorkloads/ClPooling2dBaseWorkload.hpp"
#include "ClWorkloads/ClPermuteWorkload.hpp"
-#include "ClWorkloads/ClNormalizationFloat32Workload.hpp"
+#include "ClWorkloads/ClNormalizationFloatWorkload.hpp"
#include "ClWorkloads/ClSoftmaxBaseWorkload.hpp"
-#include "ClWorkloads/ClLstmFloat32Workload.hpp"
+#include "ClWorkloads/ClLstmFloatWorkload.hpp"
#endif
using namespace boost;
@@ -417,7 +417,7 @@
const TensorInfo* projectionBias, const TensorInfo* cellToForgetWeights,
const TensorInfo* cellToOutputWeights, std::string* reasonIfUnsupported)
{
- FORWARD_WORKLOAD_VALIDATE_FUNC(ClLstmFloat32WorkloadValidate, reasonIfUnsupported,
+ FORWARD_WORKLOAD_VALIDATE_FUNC(ClLstmFloatWorkloadValidate, reasonIfUnsupported,
input, outputStateIn, cellStateIn, scratchBuffer, outputStateOut, cellStateOut,
output, descriptor, inputToForgetWeights, inputToCellWeights,
inputToOutputWeights, recurrentToForgetWeights,
diff --git a/src/armnn/backends/ClWorkloadFactory.cpp b/src/armnn/backends/ClWorkloadFactory.cpp
index 77959d1..86624ce 100644
--- a/src/armnn/backends/ClWorkloadFactory.cpp
+++ b/src/armnn/backends/ClWorkloadFactory.cpp
@@ -91,32 +91,32 @@
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateActivation(const ActivationQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClActivationFloat32Workload, ClActivationUint8Workload>(descriptor, info);
+ return MakeWorkload<ClActivationFloatWorkload, ClActivationUint8Workload>(descriptor, info);
}
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSoftmax(const SoftmaxQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClSoftmaxFloat32Workload, ClSoftmaxUint8Workload>(descriptor, info,
+ return MakeWorkload<ClSoftmaxFloatWorkload, ClSoftmaxUint8Workload>(descriptor, info,
m_MemoryManager.GetIntraLayerManager());
}
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSplitter(const SplitterQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClSplitterFloat32Workload, ClSplitterUint8Workload>(descriptor, info);
+ return MakeWorkload<ClSplitterFloatWorkload, ClSplitterUint8Workload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreateMerger(const MergerQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClMergerFloat32Workload, ClMergerUint8Workload>(descriptor, info);
+ return MakeWorkload<ClMergerFloatWorkload, ClMergerUint8Workload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreateFullyConnected(
const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<ClFullyConnectedFloat32Workload, NullWorkload>(descriptor, info,
+ return MakeWorkload<ClFullyConnectedFloatWorkload, NullWorkload>(descriptor, info,
m_MemoryManager.GetIntraLayerManager());
}
@@ -129,38 +129,38 @@
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreatePooling2d(const Pooling2dQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClPooling2dFloat32Workload, ClPooling2dUint8Workload>(descriptor, info);
+ return MakeWorkload<ClPooling2dFloatWorkload, ClPooling2dUint8Workload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreateConvolution2d(const Convolution2dQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClConvolution2dFloat32Workload, ClConvolution2dUint8Workload>(descriptor, info,
+ return MakeWorkload<ClConvolution2dFloatWorkload, ClConvolution2dUint8Workload>(descriptor, info,
m_MemoryManager.GetIntraLayerManager());
}
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateDepthwiseConvolution2d(
const DepthwiseConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<ClDepthwiseConvolutionFloat32Workload, ClDepthwiseConvolutionUint8Workload>(descriptor, info);
+ return MakeWorkload<ClDepthwiseConvolutionFloatWorkload, ClDepthwiseConvolutionUint8Workload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreateNormalization(const NormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClNormalizationFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<ClNormalizationFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreateAddition(const AdditionQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClAdditionFloat32Workload, ClAdditionUint8Workload>(descriptor, info);
+ return MakeWorkload<ClAdditionFloatWorkload, ClAdditionUint8Workload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreateMultiplication(
const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<ClMultiplicationFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<ClMultiplicationFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreateDivision(
@@ -172,7 +172,7 @@
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreateBatchNormalization(
const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<ClBatchNormalizationFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<ClBatchNormalizationFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> ClWorkloadFactory::CreateMemCopy(const MemCopyQueueDescriptor& descriptor,
@@ -190,7 +190,7 @@
const ResizeBilinearQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClResizeBilinearFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<ClResizeBilinearFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateFakeQuantization(
@@ -203,31 +203,31 @@
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateL2Normalization(const L2NormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClL2NormalizationFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<ClL2NormalizationFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateConstant(const ConstantQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClConstantFloat32Workload, ClConstantUint8Workload>(descriptor, info);
+ return MakeWorkload<ClConstantFloatWorkload, ClConstantUint8Workload>(descriptor, info);
}
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateReshape(const ReshapeQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClReshapeFloat32Workload, ClReshapeUint8Workload>(descriptor, info);
+ return MakeWorkload<ClReshapeFloatWorkload, ClReshapeUint8Workload>(descriptor, info);
}
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClFloorFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<ClFloorFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateLstm(const LstmQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<ClLstmFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<ClLstmFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<IWorkload> ClWorkloadFactory::CreateConvertFp16ToFp32(
diff --git a/src/armnn/backends/ClWorkloads.hpp b/src/armnn/backends/ClWorkloads.hpp
index 6eb8ada..0010830 100644
--- a/src/armnn/backends/ClWorkloads.hpp
+++ b/src/armnn/backends/ClWorkloads.hpp
@@ -4,37 +4,37 @@
//
#pragma once
-#include "backends/ClWorkloads/ClActivationFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClActivationFloatWorkload.hpp"
#include "backends/ClWorkloads/ClActivationUint8Workload.hpp"
-#include "backends/ClWorkloads/ClAdditionFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClAdditionFloatWorkload.hpp"
#include "backends/ClWorkloads/ClAdditionUint8Workload.hpp"
#include "backends/ClWorkloads/ClBaseConstantWorkload.hpp"
#include "backends/ClWorkloads/ClBaseMergerWorkload.hpp"
-#include "backends/ClWorkloads/ClBatchNormalizationFloat32Workload.hpp"
-#include "backends/ClWorkloads/ClConstantFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClBatchNormalizationFloatWorkload.hpp"
+#include "backends/ClWorkloads/ClConstantFloatWorkload.hpp"
#include "backends/ClWorkloads/ClConstantUint8Workload.hpp"
-#include "backends/ClWorkloads/ClConvolution2dFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClConvolution2dFloatWorkload.hpp"
#include "backends/ClWorkloads/ClConvolution2dUint8Workload.hpp"
-#include "backends/ClWorkloads/ClDepthwiseConvolutionFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClDepthwiseConvolutionFloatWorkload.hpp"
#include "backends/ClWorkloads/ClDepthwiseConvolutionUint8Workload.hpp"
#include "backends/ClWorkloads/ClDivisionFloatWorkload.hpp"
-#include "backends/ClWorkloads/ClFloorFloat32Workload.hpp"
-#include "backends/ClWorkloads/ClFullyConnectedFloat32Workload.hpp"
-#include "backends/ClWorkloads/ClL2NormalizationFloat32Workload.hpp"
-#include "backends/ClWorkloads/ClLstmFloat32Workload.hpp"
-#include "backends/ClWorkloads/ClMergerFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClFloorFloatWorkload.hpp"
+#include "backends/ClWorkloads/ClFullyConnectedFloatWorkload.hpp"
+#include "backends/ClWorkloads/ClL2NormalizationFloatWorkload.hpp"
+#include "backends/ClWorkloads/ClLstmFloatWorkload.hpp"
+#include "backends/ClWorkloads/ClMergerFloatWorkload.hpp"
#include "backends/ClWorkloads/ClMergerUint8Workload.hpp"
-#include "backends/ClWorkloads/ClMultiplicationFloat32Workload.hpp"
-#include "backends/ClWorkloads/ClNormalizationFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClMultiplicationFloatWorkload.hpp"
+#include "backends/ClWorkloads/ClNormalizationFloatWorkload.hpp"
#include "backends/ClWorkloads/ClPermuteWorkload.hpp"
-#include "backends/ClWorkloads/ClPooling2dFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClPooling2dFloatWorkload.hpp"
#include "backends/ClWorkloads/ClPooling2dUint8Workload.hpp"
-#include "backends/ClWorkloads/ClReshapeFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClReshapeFloatWorkload.hpp"
#include "backends/ClWorkloads/ClReshapeUint8Workload.hpp"
-#include "backends/ClWorkloads/ClResizeBilinearFloat32Workload.hpp"
-#include "backends/ClWorkloads/ClSoftmaxFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClResizeBilinearFloatWorkload.hpp"
+#include "backends/ClWorkloads/ClSoftmaxFloatWorkload.hpp"
#include "backends/ClWorkloads/ClSoftmaxUint8Workload.hpp"
-#include "backends/ClWorkloads/ClSplitterFloat32Workload.hpp"
+#include "backends/ClWorkloads/ClSplitterFloatWorkload.hpp"
#include "backends/ClWorkloads/ClSplitterUint8Workload.hpp"
#include "backends/ClWorkloads/ClConvertFp16ToFp32Workload.hpp"
#include "backends/ClWorkloads/ClConvertFp32ToFp16Workload.hpp"
diff --git a/src/armnn/backends/ClWorkloads/ClActivationFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClActivationFloatWorkload.cpp
similarity index 85%
rename from src/armnn/backends/ClWorkloads/ClActivationFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClActivationFloatWorkload.cpp
index f072549..1e5cf0c 100644
--- a/src/armnn/backends/ClWorkloads/ClActivationFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClActivationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClActivationFloat32Workload.hpp"
+#include "ClActivationFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/ArmComputeUtils.hpp"
@@ -31,11 +31,11 @@
activationLayerInfo);
}
-ClActivationFloat32Workload::ClActivationFloat32Workload(const ActivationQueueDescriptor& descriptor,
+ClActivationFloatWorkload::ClActivationFloatWorkload(const ActivationQueueDescriptor& descriptor,
const WorkloadInfo& info)
: FloatWorkload<ActivationQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("ClActivationFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("ClActivationFloatWorkload", 1, 1);
const arm_compute::ActivationLayerInfo activationLayerInfo =
ConvertActivationDescriptorToAclActivationLayerInfo(m_Data.m_Parameters);
@@ -45,9 +45,9 @@
m_ActivationLayer.configure(&input, &output, activationLayerInfo);
}
-void ClActivationFloat32Workload::Execute() const
+void ClActivationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClActivationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClActivationFloatWorkload_Execute");
m_ActivationLayer.run();
}
diff --git a/src/armnn/backends/ClWorkloads/ClActivationFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClActivationFloatWorkload.hpp
similarity index 76%
rename from src/armnn/backends/ClWorkloads/ClActivationFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClActivationFloatWorkload.hpp
index 9fbfe95..56367ce 100644
--- a/src/armnn/backends/ClWorkloads/ClActivationFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClActivationFloatWorkload.hpp
@@ -14,10 +14,10 @@
const ActivationDescriptor& descriptor);
// Activation layer execution.
-class ClActivationFloat32Workload : public FloatWorkload<ActivationQueueDescriptor>
+class ClActivationFloatWorkload : public FloatWorkload<ActivationQueueDescriptor>
{
public:
- ClActivationFloat32Workload(const ActivationQueueDescriptor& descriptor, const WorkloadInfo& info);
+ ClActivationFloatWorkload(const ActivationQueueDescriptor& descriptor, const WorkloadInfo& info);
void Execute() const override;
private:
diff --git a/src/armnn/backends/ClWorkloads/ClAdditionFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClAdditionFloatWorkload.cpp
similarity index 69%
rename from src/armnn/backends/ClWorkloads/ClAdditionFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClAdditionFloatWorkload.cpp
index b69593f..089b84a 100644
--- a/src/armnn/backends/ClWorkloads/ClAdditionFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClAdditionFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClAdditionFloat32Workload.hpp"
+#include "ClAdditionFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
@@ -13,9 +13,9 @@
{
using namespace armcomputetensorutils;
-void ClAdditionFloat32Workload::Execute() const
+void ClAdditionFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClAdditionFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClAdditionFloatWorkload_Execute");
ClAdditionBaseWorkload::Execute();
}
diff --git a/src/armnn/backends/ClWorkloads/ClAdditionFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClAdditionFloatWorkload.hpp
similarity index 78%
rename from src/armnn/backends/ClWorkloads/ClAdditionFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClAdditionFloatWorkload.hpp
index 7eac485..03df9cf 100644
--- a/src/armnn/backends/ClWorkloads/ClAdditionFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClAdditionFloatWorkload.hpp
@@ -10,7 +10,7 @@
namespace armnn
{
-class ClAdditionFloat32Workload : public ClAdditionBaseWorkload<DataType::Float16, DataType::Float32>
+class ClAdditionFloatWorkload : public ClAdditionBaseWorkload<DataType::Float16, DataType::Float32>
{
public:
using ClAdditionBaseWorkload<DataType::Float16, DataType::Float32>::ClAdditionBaseWorkload;
diff --git a/src/armnn/backends/ClWorkloads/ClBatchNormalizationFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClBatchNormalizationFloatWorkload.cpp
similarity index 89%
rename from src/armnn/backends/ClWorkloads/ClBatchNormalizationFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClBatchNormalizationFloatWorkload.cpp
index 1849c5d..a5d5b82 100644
--- a/src/armnn/backends/ClWorkloads/ClBatchNormalizationFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClBatchNormalizationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClBatchNormalizationFloat32Workload.hpp"
+#include "ClBatchNormalizationFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
@@ -37,7 +37,7 @@
desc.m_Eps);
}
-ClBatchNormalizationFloat32Workload::ClBatchNormalizationFloat32Workload(
+ClBatchNormalizationFloatWorkload::ClBatchNormalizationFloatWorkload(
const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info)
: FloatWorkload<BatchNormalizationQueueDescriptor>(descriptor, info)
{
@@ -53,7 +53,7 @@
m_Beta = std::make_unique<arm_compute::CLTensor>();
BuildArmComputeTensor(*m_Beta, m_Data.m_Beta->GetTensorInfo());
- m_Data.ValidateInputsOutputs("ClBatchNormalizationFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("ClBatchNormalizationFloatWorkload", 1, 1);
arm_compute::ICLTensor& input = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -77,13 +77,13 @@
FreeUnusedTensors();
}
-void ClBatchNormalizationFloat32Workload::Execute() const
+void ClBatchNormalizationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClBatchNormalizationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClBatchNormalizationFloatWorkload_Execute");
m_Layer.run();
}
-void ClBatchNormalizationFloat32Workload::FreeUnusedTensors()
+void ClBatchNormalizationFloatWorkload::FreeUnusedTensors()
{
FreeTensorIfUnused(m_Mean);
FreeTensorIfUnused(m_Variance);
diff --git a/src/armnn/backends/ClWorkloads/ClBatchNormalizationFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClBatchNormalizationFloatWorkload.hpp
similarity index 84%
rename from src/armnn/backends/ClWorkloads/ClBatchNormalizationFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClBatchNormalizationFloatWorkload.hpp
index a45614a..edc0d3c 100644
--- a/src/armnn/backends/ClWorkloads/ClBatchNormalizationFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClBatchNormalizationFloatWorkload.hpp
@@ -18,10 +18,10 @@
const TensorInfo& gamma,
const BatchNormalizationDescriptor& desc);
-class ClBatchNormalizationFloat32Workload : public FloatWorkload<BatchNormalizationQueueDescriptor>
+class ClBatchNormalizationFloatWorkload : public FloatWorkload<BatchNormalizationQueueDescriptor>
{
public:
- ClBatchNormalizationFloat32Workload(const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info);
+ ClBatchNormalizationFloatWorkload(const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info);
using FloatWorkload<BatchNormalizationQueueDescriptor>::FloatWorkload;
void Execute() const override;
diff --git a/src/armnn/backends/ClWorkloads/ClConstantFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClConstantFloat32Workload.cpp
deleted file mode 100644
index 5859499..0000000
--- a/src/armnn/backends/ClWorkloads/ClConstantFloat32Workload.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "ClConstantFloat32Workload.hpp"
-namespace armnn
-{
-
-void ClConstantFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClConstantFloat32Workload_Execute");
- ClBaseConstantWorkload::Execute();
-}
-
-} //namespace armnn
\ No newline at end of file
diff --git a/src/armnn/backends/ClWorkloads/ClConstantFloatWorkload.cpp b/src/armnn/backends/ClWorkloads/ClConstantFloatWorkload.cpp
new file mode 100644
index 0000000..842f757
--- /dev/null
+++ b/src/armnn/backends/ClWorkloads/ClConstantFloatWorkload.cpp
@@ -0,0 +1,16 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "ClConstantFloatWorkload.hpp"
+namespace armnn
+{
+
+void ClConstantFloatWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClConstantFloatWorkload_Execute");
+ ClBaseConstantWorkload::Execute();
+}
+
+} //namespace armnn
\ No newline at end of file
diff --git a/src/armnn/backends/ClWorkloads/ClConstantFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClConstantFloatWorkload.hpp
similarity index 78%
rename from src/armnn/backends/ClWorkloads/ClConstantFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClConstantFloatWorkload.hpp
index 11c3fda..52b1be4 100644
--- a/src/armnn/backends/ClWorkloads/ClConstantFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClConstantFloatWorkload.hpp
@@ -9,7 +9,7 @@
namespace armnn
{
-class ClConstantFloat32Workload : public ClBaseConstantWorkload<DataType::Float16, DataType::Float32>
+class ClConstantFloatWorkload : public ClBaseConstantWorkload<DataType::Float16, DataType::Float32>
{
public:
using ClBaseConstantWorkload<DataType::Float16, DataType::Float32>::ClBaseConstantWorkload;
diff --git a/src/armnn/backends/ClWorkloads/ClConvolution2dFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClConvolution2dFloatWorkload.cpp
similarity index 90%
rename from src/armnn/backends/ClWorkloads/ClConvolution2dFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClConvolution2dFloatWorkload.cpp
index 9ac31df..375ace2 100644
--- a/src/armnn/backends/ClWorkloads/ClConvolution2dFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClConvolution2dFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClConvolution2dFloat32Workload.hpp"
+#include "ClConvolution2dFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
@@ -13,7 +13,7 @@
{
using namespace armcomputetensorutils;
-ClConvolution2dFloat32Workload::ClConvolution2dFloat32Workload(const Convolution2dQueueDescriptor& descriptor,
+ClConvolution2dFloatWorkload::ClConvolution2dFloatWorkload(const Convolution2dQueueDescriptor& descriptor,
const WorkloadInfo& info, std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
: FloatWorkload<Convolution2dQueueDescriptor>(descriptor, info)
, m_ConvolutionLayer(memoryManager)
@@ -63,14 +63,14 @@
FreeUnusedTensors();
}
-void ClConvolution2dFloat32Workload::Execute() const
+void ClConvolution2dFloatWorkload::Execute() const
{
ARMNN_SCOPED_PROFILING_EVENT_CL("ClConvolution2dFloat32Workload_Execute");
m_ConvolutionLayer.run();
}
-void ClConvolution2dFloat32Workload::FreeUnusedTensors()
+void ClConvolution2dFloatWorkload::FreeUnusedTensors()
{
FreeTensorIfUnused(m_KernelTensor);
FreeTensorIfUnused(m_BiasTensor);
diff --git a/src/armnn/backends/ClWorkloads/ClConvolution2dFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClConvolution2dFloatWorkload.hpp
similarity index 65%
rename from src/armnn/backends/ClWorkloads/ClConvolution2dFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClConvolution2dFloatWorkload.hpp
index 51c21ae..b0af095 100644
--- a/src/armnn/backends/ClWorkloads/ClConvolution2dFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClConvolution2dFloatWorkload.hpp
@@ -14,11 +14,11 @@
namespace armnn
{
-class ClConvolution2dFloat32Workload : public FloatWorkload<Convolution2dQueueDescriptor>
+class ClConvolution2dFloatWorkload : public FloatWorkload<Convolution2dQueueDescriptor>
{
public:
- ClConvolution2dFloat32Workload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info,
- std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
+ ClConvolution2dFloatWorkload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info,
+ std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
void Execute() const override;
private:
diff --git a/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloat32Workload.hpp
deleted file mode 100644
index 669fd92..0000000
--- a/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloat32Workload.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#pragma once
-
-#include "ClDepthwiseConvolutionBaseWorkload.hpp"
-
-#include "backends/ClWorkloadUtils.hpp"
-
-namespace armnn
-{
-
-class ClDepthwiseConvolutionFloat32Workload : public ClDepthwiseConvolutionBaseWorkload<DataType::Float16,
- DataType::Float32>
-{
-public:
- ClDepthwiseConvolutionFloat32Workload(const DepthwiseConvolution2dQueueDescriptor& descriptor,
- const WorkloadInfo& info);
- void Execute() const override;
-};
-
-} //namespace armnn
-
-
-
-
diff --git a/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloatWorkload.cpp
similarity index 79%
rename from src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloatWorkload.cpp
index 96d97ad..79aef3e 100644
--- a/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClDepthwiseConvolutionFloat32Workload.hpp"
+#include "ClDepthwiseConvolutionFloatWorkload.hpp"
#include "backends/ClWorkloadUtils.hpp"
#include "backends/CpuTensorHandle.hpp"
@@ -11,7 +11,7 @@
namespace armnn
{
-ClDepthwiseConvolutionFloat32Workload::ClDepthwiseConvolutionFloat32Workload(
+ClDepthwiseConvolutionFloatWorkload::ClDepthwiseConvolutionFloatWorkload(
const DepthwiseConvolution2dQueueDescriptor& descriptor,
const WorkloadInfo& info)
: ClDepthwiseConvolutionBaseWorkload(descriptor, info)
@@ -27,9 +27,9 @@
FreeUnusedTensors();
}
-void ClDepthwiseConvolutionFloat32Workload::Execute() const
+void ClDepthwiseConvolutionFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClDepthwiseConvolutionFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClDepthwiseConvolutionFloatWorkload_Execute");
BOOST_ASSERT(m_DepthwiseConvolutionLayer);
m_DepthwiseConvolutionLayer->run();
diff --git a/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloatWorkload.hpp b/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloatWorkload.hpp
new file mode 100644
index 0000000..2107a7e
--- /dev/null
+++ b/src/armnn/backends/ClWorkloads/ClDepthwiseConvolutionFloatWorkload.hpp
@@ -0,0 +1,28 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#pragma once
+
+#include "ClDepthwiseConvolutionBaseWorkload.hpp"
+
+#include "backends/ClWorkloadUtils.hpp"
+
+namespace armnn
+{
+
+class ClDepthwiseConvolutionFloatWorkload : public ClDepthwiseConvolutionBaseWorkload<DataType::Float16,
+ DataType::Float32>
+{
+public:
+ ClDepthwiseConvolutionFloatWorkload(const DepthwiseConvolution2dQueueDescriptor& descriptor,
+ const WorkloadInfo& info);
+ void Execute() const override;
+};
+
+} //namespace armnn
+
+
+
+
diff --git a/src/armnn/backends/ClWorkloads/ClFloorFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClFloorFloatWorkload.cpp
similarity index 61%
rename from src/armnn/backends/ClWorkloads/ClFloorFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClFloorFloatWorkload.cpp
index da71c50..3ec7e75 100644
--- a/src/armnn/backends/ClWorkloads/ClFloorFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClFloorFloatWorkload.cpp
@@ -3,16 +3,16 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClFloorFloat32Workload.hpp"
+#include "ClFloorFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
namespace armnn
{
-ClFloorFloat32Workload::ClFloorFloat32Workload(const FloorQueueDescriptor& descriptor, const WorkloadInfo& info)
+ClFloorFloatWorkload::ClFloorFloatWorkload(const FloorQueueDescriptor& descriptor, const WorkloadInfo& info)
: FloatWorkload<FloorQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("ClFloorFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("ClFloorFloatWorkload", 1, 1);
arm_compute::ICLTensor& input = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -20,9 +20,9 @@
m_Layer.configure(&input, &output);
}
-void ClFloorFloat32Workload::Execute() const
+void ClFloorFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClFloorFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClFloorFloatWorkload_Execute");
m_Layer.run();
}
diff --git a/src/armnn/backends/ClWorkloads/ClFloorFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClFloorFloatWorkload.hpp
similarity index 66%
rename from src/armnn/backends/ClWorkloads/ClFloorFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClFloorFloatWorkload.hpp
index bd7f303..965ae06 100644
--- a/src/armnn/backends/ClWorkloads/ClFloorFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClFloorFloatWorkload.hpp
@@ -10,10 +10,10 @@
namespace armnn
{
-class ClFloorFloat32Workload : public FloatWorkload<FloorQueueDescriptor>
+class ClFloorFloatWorkload : public FloatWorkload<FloorQueueDescriptor>
{
public:
- ClFloorFloat32Workload(const FloorQueueDescriptor& descriptor, const WorkloadInfo& info);
+ ClFloorFloatWorkload(const FloorQueueDescriptor& descriptor, const WorkloadInfo& info);
void Execute() const override;
diff --git a/src/armnn/backends/ClWorkloads/ClFullyConnectedFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClFullyConnectedFloatWorkload.cpp
similarity index 88%
rename from src/armnn/backends/ClWorkloads/ClFullyConnectedFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClFullyConnectedFloatWorkload.cpp
index 5014dd2..9774368 100644
--- a/src/armnn/backends/ClWorkloads/ClFullyConnectedFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClFullyConnectedFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClFullyConnectedFloat32Workload.hpp"
+#include "ClFullyConnectedFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
@@ -42,7 +42,7 @@
fullyConnectedLayerInfo);
}
-ClFullyConnectedFloat32Workload::ClFullyConnectedFloat32Workload(const FullyConnectedQueueDescriptor& descriptor,
+ClFullyConnectedFloatWorkload::ClFullyConnectedFloatWorkload(const FullyConnectedQueueDescriptor& descriptor,
const WorkloadInfo& info, std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
: FloatWorkload<FullyConnectedQueueDescriptor>(descriptor, info)
, m_FullyConnectedLayer(memoryManager)
@@ -56,7 +56,7 @@
BuildArmComputeTensor(*m_BiasesTensor, m_Data.m_Bias->GetTensorInfo());
}
- m_Data.ValidateInputsOutputs("ClFullyConnectedFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("ClFullyConnectedFloatWorkload", 1, 1);
arm_compute::ICLTensor& input = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -80,13 +80,13 @@
FreeUnusedTensors();
}
-void ClFullyConnectedFloat32Workload::Execute() const
+void ClFullyConnectedFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClFullyConnectedFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClFullyConnectedFloatWorkload_Execute");
m_FullyConnectedLayer.run();
}
-void ClFullyConnectedFloat32Workload::FreeUnusedTensors()
+void ClFullyConnectedFloatWorkload::FreeUnusedTensors()
{
FreeTensorIfUnused(m_WeightsTensor);
FreeTensorIfUnused(m_BiasesTensor);
diff --git a/src/armnn/backends/ClWorkloads/ClFullyConnectedFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClFullyConnectedFloatWorkload.hpp
similarity index 74%
rename from src/armnn/backends/ClWorkloads/ClFullyConnectedFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClFullyConnectedFloatWorkload.hpp
index f580e58..1832e4f 100644
--- a/src/armnn/backends/ClWorkloads/ClFullyConnectedFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClFullyConnectedFloatWorkload.hpp
@@ -20,12 +20,12 @@
const TensorInfo& biases,
const FullyConnectedDescriptor& descriptor);
-class ClFullyConnectedFloat32Workload : public armnn::FloatWorkload<armnn::FullyConnectedQueueDescriptor>
+class ClFullyConnectedFloatWorkload : public armnn::FloatWorkload<armnn::FullyConnectedQueueDescriptor>
{
public:
- ClFullyConnectedFloat32Workload(const armnn::FullyConnectedQueueDescriptor& descriptor,
- const armnn::WorkloadInfo& info,
- std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
+ ClFullyConnectedFloatWorkload(const armnn::FullyConnectedQueueDescriptor& descriptor,
+ const armnn::WorkloadInfo& info,
+ std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
using armnn::FloatWorkload<armnn::FullyConnectedQueueDescriptor>::m_Data;
void Execute() const override;
diff --git a/src/armnn/backends/ClWorkloads/ClL2NormalizationFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClL2NormalizationFloatWorkload.cpp
similarity index 73%
rename from src/armnn/backends/ClWorkloads/ClL2NormalizationFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClL2NormalizationFloatWorkload.cpp
index 628e38d..c79ed97 100644
--- a/src/armnn/backends/ClWorkloads/ClL2NormalizationFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClL2NormalizationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClL2NormalizationFloat32Workload.hpp"
+#include "ClL2NormalizationFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ArmComputeUtils.hpp"
@@ -24,20 +24,20 @@
return arm_compute::CLNormalizationLayer::validate(&aclInput, &aclOutput, normalizationInfo);
}
-ClL2NormalizationFloat32Workload::ClL2NormalizationFloat32Workload(const L2NormalizationQueueDescriptor& descriptor,
- const WorkloadInfo& info)
+ClL2NormalizationFloatWorkload::ClL2NormalizationFloatWorkload(const L2NormalizationQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
: FloatWorkload<L2NormalizationQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("ClL2NormalizationFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("ClL2NormalizationFloatWorkload", 1, 1);
arm_compute::ICLTensor& input = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
m_Layer.configure(&input, &output, CreateAclNormalizationLayerInfoForL2Normalization(info.m_InputTensorInfos[0]));
}
-void ClL2NormalizationFloat32Workload::Execute() const
+void ClL2NormalizationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClL2NormalizationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClL2NormalizationFloatWorkload_Execute");
m_Layer.run();
}
diff --git a/src/armnn/backends/ClWorkloads/ClL2NormalizationFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClL2NormalizationFloatWorkload.hpp
similarity index 73%
rename from src/armnn/backends/ClWorkloads/ClL2NormalizationFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClL2NormalizationFloatWorkload.hpp
index bf898e3..a247c68 100644
--- a/src/armnn/backends/ClWorkloads/ClL2NormalizationFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClL2NormalizationFloatWorkload.hpp
@@ -13,10 +13,10 @@
arm_compute::Status ClL2NormalizationWorkloadValidate(const TensorInfo& input,
const TensorInfo& output);
-class ClL2NormalizationFloat32Workload : public FloatWorkload<L2NormalizationQueueDescriptor>
+class ClL2NormalizationFloatWorkload : public FloatWorkload<L2NormalizationQueueDescriptor>
{
public:
- ClL2NormalizationFloat32Workload(const L2NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info);
+ ClL2NormalizationFloatWorkload(const L2NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info);
void Execute() const override;
diff --git a/src/armnn/backends/ClWorkloads/ClLstmFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClLstmFloat32Workload.hpp
deleted file mode 100644
index e2358ad..0000000
--- a/src/armnn/backends/ClWorkloads/ClLstmFloat32Workload.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#pragma once
-
-#include "backends/ClWorkloadUtils.hpp"
-#include "backends/Workload.hpp"
-#include "backends/WorkloadData.hpp"
-
-namespace armnn
-{
-
-class ClLstmFloat32Workload : public FloatWorkload<LstmQueueDescriptor>
-{
-public:
- ClLstmFloat32Workload(const LstmQueueDescriptor& descriptor, const WorkloadInfo& info);
- void Execute() const override;
-
-private:
- mutable arm_compute::CLLSTMLayer m_LstmLayer;
-
- std::unique_ptr<arm_compute::CLTensor> m_InputToInputWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_InputToForgetWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_InputToCellWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_InputToOutputWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_RecurrentToInputWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_RecurrentToForgetWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_RecurrentToCellWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_RecurrentToOutputWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_CellToInputWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_CellToForgetWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_CellToOutputWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_InputGateBiasTensor;
- std::unique_ptr<arm_compute::CLTensor> m_ForgetGateBiasTensor;
- std::unique_ptr<arm_compute::CLTensor> m_CellBiasTensor;
- std::unique_ptr<arm_compute::CLTensor> m_OutputGateBiasTensor;
- std::unique_ptr<arm_compute::CLTensor> m_ProjectionWeightsTensor;
- std::unique_ptr<arm_compute::CLTensor> m_ProjectionBiasTensor;
-
- std::unique_ptr<arm_compute::CLTensor> m_ScratchBuffer;
-
- void FreeUnusedTensors();
-};
-
-arm_compute::Status ClLstmFloat32WorkloadValidate(const TensorInfo& input, const TensorInfo& outputStateIn,
- const TensorInfo& cellStateIn, const TensorInfo& scratchBuffer,
- const TensorInfo& outputStateOut, const TensorInfo& cellStateOut,
- const TensorInfo& output, const LstmDescriptor &descriptor,
- const TensorInfo& inputToForgetWeights,
- const TensorInfo& inputToCellWeights,
- const TensorInfo& inputToOutputWeights,
- const TensorInfo& recurrentToForgetWeights,
- const TensorInfo& recurrentToCellWeights,
- const TensorInfo& recurrentToOutputWeights,
- const TensorInfo& forgetGateBias, const TensorInfo& cellBias,
- const TensorInfo& outputGateBias,
- const TensorInfo* inputToInputWeights,
- const TensorInfo* recurrentToInputWeights,
- const TensorInfo* cellToInputWeights,
- const TensorInfo* inputGateBias,
- const TensorInfo* projectionWeights,
- const TensorInfo* projectionBias,
- const TensorInfo* cellToForgetWeights,
- const TensorInfo* cellToOutputWeights);
-} //namespace armnn
diff --git a/src/armnn/backends/ClWorkloads/ClLstmFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClLstmFloatWorkload.cpp
similarity index 89%
rename from src/armnn/backends/ClWorkloads/ClLstmFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClLstmFloatWorkload.cpp
index db5c303..bfa439b 100644
--- a/src/armnn/backends/ClWorkloads/ClLstmFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClLstmFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClLstmFloat32Workload.hpp"
+#include "ClLstmFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
@@ -14,7 +14,7 @@
{
using namespace armcomputetensorutils;
-ClLstmFloat32Workload::ClLstmFloat32Workload(const LstmQueueDescriptor &descriptor, const WorkloadInfo &info)
+ClLstmFloatWorkload::ClLstmFloatWorkload(const LstmQueueDescriptor &descriptor, const WorkloadInfo &info)
: FloatWorkload<LstmQueueDescriptor>(descriptor, info)
{
arm_compute::LSTMParams<arm_compute::ICLTensor> lstm_param;
@@ -228,31 +228,31 @@
FreeUnusedTensors();
}
-void ClLstmFloat32Workload::Execute() const
+void ClLstmFloatWorkload::Execute() const
{
m_LstmLayer.run();
}
-arm_compute::Status ClLstmFloat32WorkloadValidate(const TensorInfo& input, const TensorInfo& outputStateIn,
- const TensorInfo& cellStateIn, const TensorInfo& scratchBuffer,
- const TensorInfo& outputStateOut, const TensorInfo& cellStateOut,
- const TensorInfo& output, const LstmDescriptor& descriptor,
- const TensorInfo& inputToForgetWeights,
- const TensorInfo& inputToCellWeights,
- const TensorInfo& inputToOutputWeights,
- const TensorInfo& recurrentToForgetWeights,
- const TensorInfo& recurrentToCellWeights,
- const TensorInfo& recurrentToOutputWeights,
- const TensorInfo& forgetGateBias, const TensorInfo& cellBias,
- const TensorInfo& outputGateBias,
- const TensorInfo* inputToInputWeights,
- const TensorInfo* recurrentToInputWeights,
- const TensorInfo* cellToInputWeights,
- const TensorInfo* inputGateBias,
- const TensorInfo* projectionWeights,
- const TensorInfo* projectionBias,
- const TensorInfo* cellToForgetWeights,
- const TensorInfo* cellToOutputWeights)
+arm_compute::Status ClLstmFloatWorkloadValidate(const TensorInfo& input, const TensorInfo& outputStateIn,
+ const TensorInfo& cellStateIn, const TensorInfo& scratchBuffer,
+ const TensorInfo& outputStateOut, const TensorInfo& cellStateOut,
+ const TensorInfo& output, const LstmDescriptor& descriptor,
+ const TensorInfo& inputToForgetWeights,
+ const TensorInfo& inputToCellWeights,
+ const TensorInfo& inputToOutputWeights,
+ const TensorInfo& recurrentToForgetWeights,
+ const TensorInfo& recurrentToCellWeights,
+ const TensorInfo& recurrentToOutputWeights,
+ const TensorInfo& forgetGateBias, const TensorInfo& cellBias,
+ const TensorInfo& outputGateBias,
+ const TensorInfo* inputToInputWeights,
+ const TensorInfo* recurrentToInputWeights,
+ const TensorInfo* cellToInputWeights,
+ const TensorInfo* inputGateBias,
+ const TensorInfo* projectionWeights,
+ const TensorInfo* projectionBias,
+ const TensorInfo* cellToForgetWeights,
+ const TensorInfo* cellToOutputWeights)
{
arm_compute::LSTMParams<arm_compute::ITensorInfo> lstm_params_info;
@@ -380,7 +380,7 @@
cell_threshold, projection_threshold);
}
-void ClLstmFloat32Workload::FreeUnusedTensors()
+void ClLstmFloatWorkload::FreeUnusedTensors()
{
FreeTensorIfUnused(m_InputToInputWeightsTensor);
FreeTensorIfUnused(m_InputToForgetWeightsTensor);
diff --git a/src/armnn/backends/ClWorkloads/ClLstmFloatWorkload.hpp b/src/armnn/backends/ClWorkloads/ClLstmFloatWorkload.hpp
new file mode 100644
index 0000000..47473b2
--- /dev/null
+++ b/src/armnn/backends/ClWorkloads/ClLstmFloatWorkload.hpp
@@ -0,0 +1,67 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#pragma once
+
+#include "backends/ClWorkloadUtils.hpp"
+#include "backends/Workload.hpp"
+#include "backends/WorkloadData.hpp"
+
+namespace armnn
+{
+
+class ClLstmFloatWorkload : public FloatWorkload<LstmQueueDescriptor>
+{
+public:
+ ClLstmFloatWorkload(const LstmQueueDescriptor& descriptor, const WorkloadInfo& info);
+ void Execute() const override;
+
+private:
+ mutable arm_compute::CLLSTMLayer m_LstmLayer;
+
+ std::unique_ptr<arm_compute::CLTensor> m_InputToInputWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_InputToForgetWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_InputToCellWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_InputToOutputWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_RecurrentToInputWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_RecurrentToForgetWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_RecurrentToCellWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_RecurrentToOutputWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_CellToInputWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_CellToForgetWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_CellToOutputWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_InputGateBiasTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_ForgetGateBiasTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_CellBiasTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_OutputGateBiasTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_ProjectionWeightsTensor;
+ std::unique_ptr<arm_compute::CLTensor> m_ProjectionBiasTensor;
+
+ std::unique_ptr<arm_compute::CLTensor> m_ScratchBuffer;
+
+ void FreeUnusedTensors();
+};
+
+arm_compute::Status ClLstmFloatWorkloadValidate(const TensorInfo& input, const TensorInfo& outputStateIn,
+ const TensorInfo& cellStateIn, const TensorInfo& scratchBuffer,
+ const TensorInfo& outputStateOut, const TensorInfo& cellStateOut,
+ const TensorInfo& output, const LstmDescriptor &descriptor,
+ const TensorInfo& inputToForgetWeights,
+ const TensorInfo& inputToCellWeights,
+ const TensorInfo& inputToOutputWeights,
+ const TensorInfo& recurrentToForgetWeights,
+ const TensorInfo& recurrentToCellWeights,
+ const TensorInfo& recurrentToOutputWeights,
+ const TensorInfo& forgetGateBias, const TensorInfo& cellBias,
+ const TensorInfo& outputGateBias,
+ const TensorInfo* inputToInputWeights,
+ const TensorInfo* recurrentToInputWeights,
+ const TensorInfo* cellToInputWeights,
+ const TensorInfo* inputGateBias,
+ const TensorInfo* projectionWeights,
+ const TensorInfo* projectionBias,
+ const TensorInfo* cellToForgetWeights,
+ const TensorInfo* cellToOutputWeights);
+} //namespace armnn
diff --git a/src/armnn/backends/ClWorkloads/ClMergerFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClMergerFloat32Workload.cpp
deleted file mode 100644
index 89e7690..0000000
--- a/src/armnn/backends/ClWorkloads/ClMergerFloat32Workload.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "ClMergerFloat32Workload.hpp"
-
-
-namespace armnn
-{
-
-void ClMergerFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClMergerFloat32Workload_Execute");
- ClBaseMergerWorkload::Execute();
-}
-
-} //namespace armnn
-
diff --git a/src/armnn/backends/ClWorkloads/ClMergerFloatWorkload.cpp b/src/armnn/backends/ClWorkloads/ClMergerFloatWorkload.cpp
new file mode 100644
index 0000000..3d8a183
--- /dev/null
+++ b/src/armnn/backends/ClWorkloads/ClMergerFloatWorkload.cpp
@@ -0,0 +1,19 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "ClMergerFloatWorkload.hpp"
+
+
+namespace armnn
+{
+
+void ClMergerFloatWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClMergerFloatWorkload_Execute");
+ ClBaseMergerWorkload::Execute();
+}
+
+} //namespace armnn
+
diff --git a/src/armnn/backends/ClWorkloads/ClMergerFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClMergerFloatWorkload.hpp
similarity index 78%
rename from src/armnn/backends/ClWorkloads/ClMergerFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClMergerFloatWorkload.hpp
index 3cafa23..e89f96e 100644
--- a/src/armnn/backends/ClWorkloads/ClMergerFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClMergerFloatWorkload.hpp
@@ -10,7 +10,7 @@
namespace armnn
{
-class ClMergerFloat32Workload : public ClBaseMergerWorkload<DataType::Float16, DataType::Float32>
+class ClMergerFloatWorkload : public ClBaseMergerWorkload<DataType::Float16, DataType::Float32>
{
public:
using ClBaseMergerWorkload<DataType::Float16, DataType::Float32>::ClBaseMergerWorkload;
diff --git a/src/armnn/backends/ClWorkloads/ClMultiplicationFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClMultiplicationFloatWorkload.cpp
similarity index 86%
rename from src/armnn/backends/ClWorkloads/ClMultiplicationFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClMultiplicationFloatWorkload.cpp
index 7aa3314..e161a0a 100644
--- a/src/armnn/backends/ClWorkloads/ClMultiplicationFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClMultiplicationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClMultiplicationFloat32Workload.hpp"
+#include "ClMultiplicationFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
@@ -30,11 +30,11 @@
}
-ClMultiplicationFloat32Workload::ClMultiplicationFloat32Workload(const MultiplicationQueueDescriptor& descriptor,
+ClMultiplicationFloatWorkload::ClMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor,
const WorkloadInfo& info)
: FloatWorkload<MultiplicationQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("ClMultiplicationFloat32Workload", 2, 1);
+ m_Data.ValidateInputsOutputs("ClMultiplicationFloatWorkload", 2, 1);
arm_compute::ICLTensor& input0 = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ICLTensor& input1 = static_cast<IClTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
@@ -48,9 +48,9 @@
arm_compute::RoundingPolicy::TO_NEAREST_EVEN);
}
-void ClMultiplicationFloat32Workload::Execute() const
+void ClMultiplicationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClMultiplicationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClMultiplicationFloatWorkload_Execute");
// Executes the layer.
m_PixelWiseMultiplication.run();
diff --git a/src/armnn/backends/ClWorkloads/ClMultiplicationFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClMultiplicationFloatWorkload.hpp
similarity index 76%
rename from src/armnn/backends/ClWorkloads/ClMultiplicationFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClMultiplicationFloatWorkload.hpp
index 0d61990..0da8451 100644
--- a/src/armnn/backends/ClWorkloads/ClMultiplicationFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClMultiplicationFloatWorkload.hpp
@@ -14,10 +14,10 @@
const TensorInfo& input1,
const TensorInfo& output);
-class ClMultiplicationFloat32Workload : public FloatWorkload<MultiplicationQueueDescriptor>
+class ClMultiplicationFloatWorkload : public FloatWorkload<MultiplicationQueueDescriptor>
{
public:
- ClMultiplicationFloat32Workload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info);
+ ClMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info);
using FloatWorkload<MultiplicationQueueDescriptor>::FloatWorkload;
void Execute() const override;
diff --git a/src/armnn/backends/ClWorkloads/ClNormalizationFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClNormalizationFloatWorkload.cpp
similarity index 76%
rename from src/armnn/backends/ClWorkloads/ClNormalizationFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClNormalizationFloatWorkload.cpp
index d23d6e1..bd486e6 100644
--- a/src/armnn/backends/ClWorkloads/ClNormalizationFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClNormalizationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClNormalizationFloat32Workload.hpp"
+#include "ClNormalizationFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ClLayerSupport.hpp"
@@ -25,11 +25,11 @@
return arm_compute::CLNormalizationLayer::validate(&aclInputInfo, &aclOutputInfo, layerInfo);
}
-ClNormalizationFloat32Workload::ClNormalizationFloat32Workload(const NormalizationQueueDescriptor& descriptor,
- const WorkloadInfo& info)
+ClNormalizationFloatWorkload::ClNormalizationFloatWorkload(const NormalizationQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
: FloatWorkload<NormalizationQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("ClNormalizationFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("ClNormalizationFloatWorkload", 1, 1);
arm_compute::ICLTensor& input = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -40,9 +40,9 @@
m_NormalizationLayer.configure(&input, &output, normalizationInfo);
};
-void ClNormalizationFloat32Workload::Execute() const
+void ClNormalizationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClNormalizationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClNormalizationFloatWorkload_Execute");
m_NormalizationLayer.run();
}
diff --git a/src/armnn/backends/ClWorkloads/ClNormalizationFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClNormalizationFloatWorkload.hpp
similarity index 71%
rename from src/armnn/backends/ClWorkloads/ClNormalizationFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClNormalizationFloatWorkload.hpp
index e8ab0b9..4f49e93 100644
--- a/src/armnn/backends/ClWorkloads/ClNormalizationFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClNormalizationFloatWorkload.hpp
@@ -14,15 +14,14 @@
const TensorInfo& output,
const NormalizationDescriptor& descriptor);
-class ClNormalizationFloat32Workload : public FloatWorkload<NormalizationQueueDescriptor>
+class ClNormalizationFloatWorkload : public FloatWorkload<NormalizationQueueDescriptor>
{
public:
- ClNormalizationFloat32Workload(const NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info);
+ ClNormalizationFloatWorkload(const NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info);
void Execute() const override;
private:
mutable arm_compute::CLNormalizationLayer m_NormalizationLayer;
};
-} //namespace armnn
-
+} //namespace armnn
\ No newline at end of file
diff --git a/src/armnn/backends/ClWorkloads/ClPooling2dFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClPooling2dFloat32Workload.cpp
deleted file mode 100644
index 3a5b8ca..0000000
--- a/src/armnn/backends/ClWorkloads/ClPooling2dFloat32Workload.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "ClPooling2dFloat32Workload.hpp"
-
-namespace armnn
-{
-
-ClPooling2dFloat32Workload::ClPooling2dFloat32Workload(const Pooling2dQueueDescriptor& descriptor,
- const WorkloadInfo& info)
- : ClPooling2dBaseWorkload<DataType::Float16, DataType::Float32>(descriptor, info, "ClPooling2dFloat32Workload")
-{
-}
-
-void ClPooling2dFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClPooling2dFloat32Workload_Execute");
- m_PoolingLayer.run();
-}
-
-} //namespace armnn
-
diff --git a/src/armnn/backends/ClWorkloads/ClPooling2dFloatWorkload.cpp b/src/armnn/backends/ClWorkloads/ClPooling2dFloatWorkload.cpp
new file mode 100644
index 0000000..9979e2f
--- /dev/null
+++ b/src/armnn/backends/ClWorkloads/ClPooling2dFloatWorkload.cpp
@@ -0,0 +1,24 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "ClPooling2dFloatWorkload.hpp"
+
+namespace armnn
+{
+
+ClPooling2dFloatWorkload::ClPooling2dFloatWorkload(const Pooling2dQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
+ : ClPooling2dBaseWorkload<DataType::Float16, DataType::Float32>(descriptor, info, "ClPooling2dFloatWorkload")
+{
+}
+
+void ClPooling2dFloatWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClPooling2dFloatWorkload_Execute");
+ m_PoolingLayer.run();
+}
+
+} //namespace armnn
+
diff --git a/src/armnn/backends/ClWorkloads/ClPooling2dFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClPooling2dFloatWorkload.hpp
similarity index 61%
rename from src/armnn/backends/ClWorkloads/ClPooling2dFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClPooling2dFloatWorkload.hpp
index ad189bd..0b73abb 100644
--- a/src/armnn/backends/ClWorkloads/ClPooling2dFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClPooling2dFloatWorkload.hpp
@@ -10,10 +10,10 @@
namespace armnn
{
-class ClPooling2dFloat32Workload : public ClPooling2dBaseWorkload<DataType::Float16, DataType::Float32>
+class ClPooling2dFloatWorkload : public ClPooling2dBaseWorkload<DataType::Float16, DataType::Float32>
{
public:
- ClPooling2dFloat32Workload(const Pooling2dQueueDescriptor& descriptor, const WorkloadInfo& info);
+ ClPooling2dFloatWorkload(const Pooling2dQueueDescriptor& descriptor, const WorkloadInfo& info);
void Execute() const override;
};
diff --git a/src/armnn/backends/ClWorkloads/ClReshapeFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClReshapeFloatWorkload.cpp
similarity index 62%
rename from src/armnn/backends/ClWorkloads/ClReshapeFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClReshapeFloatWorkload.cpp
index 05fba22..645544b 100644
--- a/src/armnn/backends/ClWorkloads/ClReshapeFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClReshapeFloatWorkload.cpp
@@ -3,17 +3,17 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClReshapeFloat32Workload.hpp"
+#include "ClReshapeFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
namespace armnn
{
-ClReshapeFloat32Workload::ClReshapeFloat32Workload(const ReshapeQueueDescriptor& descriptor, const WorkloadInfo& info)
+ClReshapeFloatWorkload::ClReshapeFloatWorkload(const ReshapeQueueDescriptor& descriptor, const WorkloadInfo& info)
: FloatWorkload<ReshapeQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("ClReshapeFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("ClReshapeFloatWorkload", 1, 1);
arm_compute::ICLTensor& input = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -21,9 +21,9 @@
m_Layer.configure(&input, &output);
}
-void ClReshapeFloat32Workload::Execute() const
+void ClReshapeFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClReshapeFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClReshapeFloatWorkload_Execute");
m_Layer.run();
}
diff --git a/src/armnn/backends/ClWorkloads/ClReshapeFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClReshapeFloatWorkload.hpp
similarity index 65%
rename from src/armnn/backends/ClWorkloads/ClReshapeFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClReshapeFloatWorkload.hpp
index 0eb4d08..18392af 100644
--- a/src/armnn/backends/ClWorkloads/ClReshapeFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClReshapeFloatWorkload.hpp
@@ -10,10 +10,10 @@
namespace armnn
{
-class ClReshapeFloat32Workload : public FloatWorkload<ReshapeQueueDescriptor>
+class ClReshapeFloatWorkload : public FloatWorkload<ReshapeQueueDescriptor>
{
public:
- ClReshapeFloat32Workload(const ReshapeQueueDescriptor& descriptor, const WorkloadInfo& info);
+ ClReshapeFloatWorkload(const ReshapeQueueDescriptor& descriptor, const WorkloadInfo& info);
void Execute() const override;
diff --git a/src/armnn/backends/ClWorkloads/ClResizeBilinearFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClResizeBilinearFloatWorkload.cpp
similarity index 73%
rename from src/armnn/backends/ClWorkloads/ClResizeBilinearFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClResizeBilinearFloatWorkload.cpp
index abef682..e7e2f70 100644
--- a/src/armnn/backends/ClWorkloads/ClResizeBilinearFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClResizeBilinearFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClResizeBilinearFloat32Workload.hpp"
+#include "ClResizeBilinearFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ClLayerSupport.hpp"
@@ -12,11 +12,11 @@
namespace armnn
{
-ClResizeBilinearFloat32Workload::ClResizeBilinearFloat32Workload(const ResizeBilinearQueueDescriptor& descriptor,
+ClResizeBilinearFloatWorkload::ClResizeBilinearFloatWorkload(const ResizeBilinearQueueDescriptor& descriptor,
const WorkloadInfo& info)
: FloatWorkload<ResizeBilinearQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("ClResizeBilinearFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("ClResizeBilinearFloatWorkload", 1, 1);
arm_compute::ICLTensor& input = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -26,9 +26,9 @@
arm_compute::SamplingPolicy::TOP_LEFT);
};
-void ClResizeBilinearFloat32Workload::Execute() const
+void ClResizeBilinearFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClResizeBilinearFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClResizeBilinearFloatWorkload_Execute");
m_ResizeBilinearLayer.run();
}
diff --git a/src/armnn/backends/ClWorkloads/ClResizeBilinearFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClResizeBilinearFloatWorkload.hpp
similarity index 62%
rename from src/armnn/backends/ClWorkloads/ClResizeBilinearFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClResizeBilinearFloatWorkload.hpp
index 81c0566..7527cc6 100644
--- a/src/armnn/backends/ClWorkloads/ClResizeBilinearFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClResizeBilinearFloatWorkload.hpp
@@ -10,10 +10,10 @@
namespace armnn
{
-class ClResizeBilinearFloat32Workload : public FloatWorkload<ResizeBilinearQueueDescriptor>
+class ClResizeBilinearFloatWorkload : public FloatWorkload<ResizeBilinearQueueDescriptor>
{
public:
- ClResizeBilinearFloat32Workload(const ResizeBilinearQueueDescriptor& descriptor, const WorkloadInfo& info);
+ ClResizeBilinearFloatWorkload(const ResizeBilinearQueueDescriptor& descriptor, const WorkloadInfo& info);
void Execute() const override;
private:
diff --git a/src/armnn/backends/ClWorkloads/ClSoftmaxFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClSoftmaxFloatWorkload.cpp
similarity index 69%
rename from src/armnn/backends/ClWorkloads/ClSoftmaxFloat32Workload.cpp
rename to src/armnn/backends/ClWorkloads/ClSoftmaxFloatWorkload.cpp
index 08247bc..2816d80 100644
--- a/src/armnn/backends/ClWorkloads/ClSoftmaxFloat32Workload.cpp
+++ b/src/armnn/backends/ClWorkloads/ClSoftmaxFloatWorkload.cpp
@@ -3,28 +3,28 @@
// See LICENSE file in the project root for full license information.
//
-#include "ClSoftmaxFloat32Workload.hpp"
+#include "ClSoftmaxFloatWorkload.hpp"
#include "backends/ClTensorHandle.hpp"
#include "backends/CpuTensorHandle.hpp"
namespace armnn
{
-ClSoftmaxFloat32Workload::ClSoftmaxFloat32Workload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
+ClSoftmaxFloatWorkload::ClSoftmaxFloatWorkload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
: FloatWorkload<SoftmaxQueueDescriptor>(descriptor, info)
, m_SoftmaxLayer(memoryManager)
{
- m_Data.ValidateInputsOutputs("ClSoftmaxFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("ClSoftmaxFloatWorkload", 1, 1);
arm_compute::ICLTensor& input = static_cast<ClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ICLTensor& output = static_cast<ClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
m_SoftmaxLayer.configure(&input, &output, m_Data.m_Parameters.m_Beta);
}
-void ClSoftmaxFloat32Workload::Execute() const
+void ClSoftmaxFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClSoftmaxFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClSoftmaxFloatWorkload_Execute");
m_SoftmaxLayer.run();
}
diff --git a/src/armnn/backends/ClWorkloads/ClSoftmaxFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClSoftmaxFloatWorkload.hpp
similarity index 74%
rename from src/armnn/backends/ClWorkloads/ClSoftmaxFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClSoftmaxFloatWorkload.hpp
index 6cad598..d50ba6f 100644
--- a/src/armnn/backends/ClWorkloads/ClSoftmaxFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClSoftmaxFloatWorkload.hpp
@@ -14,10 +14,10 @@
namespace armnn
{
-class ClSoftmaxFloat32Workload : public FloatWorkload<SoftmaxQueueDescriptor>
+class ClSoftmaxFloatWorkload : public FloatWorkload<SoftmaxQueueDescriptor>
{
public:
- ClSoftmaxFloat32Workload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
+ ClSoftmaxFloatWorkload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
void Execute() const override;
diff --git a/src/armnn/backends/ClWorkloads/ClSplitterFloat32Workload.cpp b/src/armnn/backends/ClWorkloads/ClSplitterFloat32Workload.cpp
deleted file mode 100644
index 8a622c6..0000000
--- a/src/armnn/backends/ClWorkloads/ClSplitterFloat32Workload.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "ClSplitterFloat32Workload.hpp"
-
-namespace armnn
-{
-
-void ClSplitterFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT_CL("ClSplitterFloat32Workload_Execute");
- ClBaseSplitterWorkload::Execute();
-}
-
-} //namespace armnn
diff --git a/src/armnn/backends/ClWorkloads/ClSplitterFloatWorkload.cpp b/src/armnn/backends/ClWorkloads/ClSplitterFloatWorkload.cpp
new file mode 100644
index 0000000..816cc6a
--- /dev/null
+++ b/src/armnn/backends/ClWorkloads/ClSplitterFloatWorkload.cpp
@@ -0,0 +1,17 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "ClSplitterFloatWorkload.hpp"
+
+namespace armnn
+{
+
+void ClSplitterFloatWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_CL("ClSplitterFloatWorkload_Execute");
+ ClBaseSplitterWorkload::Execute();
+}
+
+} //namespace armnn
diff --git a/src/armnn/backends/ClWorkloads/ClSplitterFloat32Workload.hpp b/src/armnn/backends/ClWorkloads/ClSplitterFloatWorkload.hpp
similarity index 78%
rename from src/armnn/backends/ClWorkloads/ClSplitterFloat32Workload.hpp
rename to src/armnn/backends/ClWorkloads/ClSplitterFloatWorkload.hpp
index affa9f8..f795473 100644
--- a/src/armnn/backends/ClWorkloads/ClSplitterFloat32Workload.hpp
+++ b/src/armnn/backends/ClWorkloads/ClSplitterFloatWorkload.hpp
@@ -10,7 +10,7 @@
namespace armnn
{
-class ClSplitterFloat32Workload : public ClBaseSplitterWorkload<DataType::Float16, DataType::Float32>
+class ClSplitterFloatWorkload : public ClBaseSplitterWorkload<DataType::Float16, DataType::Float32>
{
public:
using ClBaseSplitterWorkload<DataType::Float16, DataType::Float32>::ClBaseSplitterWorkload;
diff --git a/src/armnn/backends/NeonLayerSupport.cpp b/src/armnn/backends/NeonLayerSupport.cpp
index 48b3ccb..fd2372f 100644
--- a/src/armnn/backends/NeonLayerSupport.cpp
+++ b/src/armnn/backends/NeonLayerSupport.cpp
@@ -15,15 +15,15 @@
#include <boost/core/ignore_unused.hpp>
#ifdef ARMCOMPUTENEON_ENABLED
-#include "NeonWorkloads/NeonAdditionFloat32Workload.hpp"
-#include "NeonWorkloads/NeonActivationFloat32Workload.hpp"
-#include "NeonWorkloads/NeonBatchNormalizationFloat32Workload.hpp"
+#include "NeonWorkloads/NeonAdditionFloatWorkload.hpp"
+#include "NeonWorkloads/NeonActivationFloatWorkload.hpp"
+#include "NeonWorkloads/NeonBatchNormalizationFloatWorkload.hpp"
#include "NeonWorkloads/NeonConvolution2dBaseWorkload.hpp"
#include "NeonWorkloads/NeonDepthwiseConvolutionBaseWorkload.hpp"
-#include "NeonWorkloads/NeonL2NormalizationFloat32Workload.hpp"
-#include "NeonWorkloads/NeonMultiplicationFloat32Workload.hpp"
-#include "NeonWorkloads/NeonNormalizationFloat32Workload.hpp"
-#include "NeonWorkloads/NeonFullyConnectedFloat32Workload.hpp"
+#include "NeonWorkloads/NeonL2NormalizationFloatWorkload.hpp"
+#include "NeonWorkloads/NeonMultiplicationFloatWorkload.hpp"
+#include "NeonWorkloads/NeonNormalizationFloatWorkload.hpp"
+#include "NeonWorkloads/NeonFullyConnectedFloatWorkload.hpp"
#include "NeonWorkloads/NeonPermuteWorkload.hpp"
#include "NeonWorkloads/NeonPooling2dBaseWorkload.hpp"
#include "NeonWorkloads/NeonSoftmaxBaseWorkload.hpp"
diff --git a/src/armnn/backends/NeonWorkloadFactory.cpp b/src/armnn/backends/NeonWorkloadFactory.cpp
index 2332b8b..6e99701 100644
--- a/src/armnn/backends/NeonWorkloadFactory.cpp
+++ b/src/armnn/backends/NeonWorkloadFactory.cpp
@@ -82,32 +82,32 @@
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateActivation(const ActivationQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonActivationFloat32Workload, NeonActivationUint8Workload>(descriptor, info);
+ return MakeWorkload<NeonActivationFloatWorkload, NeonActivationUint8Workload>(descriptor, info);
}
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSoftmax(const SoftmaxQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonSoftmaxFloat32Workload, NeonSoftmaxUint8Workload>(descriptor, info,
+ return MakeWorkload<NeonSoftmaxFloatWorkload, NeonSoftmaxUint8Workload>(descriptor, info,
m_MemoryManager.GetIntraLayerManager());
}
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSplitter(const SplitterQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonSplitterFloat32Workload, NeonSplitterUint8Workload>(descriptor, info);
+ return MakeWorkload<NeonSplitterFloatWorkload, NeonSplitterUint8Workload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateMerger(const MergerQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonMergerFloat32Workload, NeonMergerUint8Workload>(descriptor, info);
+ return MakeWorkload<NeonMergerFloatWorkload, NeonMergerUint8Workload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateFullyConnected(
const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<NeonFullyConnectedFloat32Workload, NullWorkload>(descriptor, info,
+ return MakeWorkload<NeonFullyConnectedFloatWorkload, NullWorkload>(descriptor, info,
m_MemoryManager.GetIntraLayerManager());
}
@@ -120,40 +120,40 @@
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreatePooling2d(const Pooling2dQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonPooling2dFloat32Workload, NeonPooling2dUint8Workload>(descriptor, info);
+ return MakeWorkload<NeonPooling2dFloatWorkload, NeonPooling2dUint8Workload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateConvolution2d(
const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<NeonConvolution2dFloat32Workload, NeonConvolution2dUint8Workload>(descriptor, info,
+ return MakeWorkload<NeonConvolution2dFloatWorkload, NeonConvolution2dUint8Workload>(descriptor, info,
m_MemoryManager.GetIntraLayerManager());
}
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateDepthwiseConvolution2d(
const DepthwiseConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<NeonDepthwiseConvolutionFloat32Workload, NeonDepthwiseConvolutionUint8Workload>(
+ return MakeWorkload<NeonDepthwiseConvolutionFloatWorkload, NeonDepthwiseConvolutionUint8Workload>(
descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateNormalization(
const NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<NeonNormalizationFloat32Workload, NullWorkload>(descriptor, info,
+ return MakeWorkload<NeonNormalizationFloatWorkload, NullWorkload>(descriptor, info,
m_MemoryManager.GetIntraLayerManager());
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateAddition(const AdditionQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonAdditionFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<NeonAdditionFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateMultiplication(
const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<NeonMultiplicationFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<NeonMultiplicationFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateDivision(
@@ -165,7 +165,7 @@
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateBatchNormalization(
const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkload<NeonBatchNormalizationFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<NeonBatchNormalizationFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateMemCopy(const MemCopyQueueDescriptor& descriptor,
@@ -196,32 +196,32 @@
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateL2Normalization(const L2NormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonL2NormalizationFloat32Workload, NullWorkload>(descriptor, info,
+ return MakeWorkload<NeonL2NormalizationFloatWorkload, NullWorkload>(descriptor, info,
m_MemoryManager.GetIntraLayerManager());
}
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateConstant(const ConstantQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonConstantFloat32Workload, NeonConstantUint8Workload>(descriptor, info);
+ return MakeWorkload<NeonConstantFloatWorkload, NeonConstantUint8Workload>(descriptor, info);
}
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateReshape(const ReshapeQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonReshapeFloat32Workload, NeonReshapeUint8Workload>(descriptor, info);
+ return MakeWorkload<NeonReshapeFloatWorkload, NeonReshapeUint8Workload>(descriptor, info);
}
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonFloorFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<NeonFloorFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateLstm(const LstmQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return MakeWorkload<NeonLstmFloat32Workload, NullWorkload>(descriptor, info);
+ return MakeWorkload<NeonLstmFloatWorkload, NullWorkload>(descriptor, info);
}
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateConvertFp16ToFp32(
diff --git a/src/armnn/backends/NeonWorkloads.hpp b/src/armnn/backends/NeonWorkloads.hpp
index 9619b4e..1948232 100644
--- a/src/armnn/backends/NeonWorkloads.hpp
+++ b/src/armnn/backends/NeonWorkloads.hpp
@@ -4,37 +4,37 @@
//
#pragma once
-#include "backends/NeonWorkloads/NeonActivationFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonActivationFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonActivationUint8Workload.hpp"
-#include "backends/NeonWorkloads/NeonAdditionFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonAdditionFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonBaseConstantWorkload.hpp"
#include "backends/NeonWorkloads/NeonBaseMergerWorkload.hpp"
#include "backends/NeonWorkloads/NeonBaseSplitterWorkload.hpp"
-#include "backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.hpp"
-#include "backends/NeonWorkloads/NeonConstantFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.hpp"
+#include "backends/NeonWorkloads/NeonConstantFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonConstantUint8Workload.hpp"
#include "backends/NeonWorkloads/NeonConvertFp16ToFp32Workload.hpp"
#include "backends/NeonWorkloads/NeonConvertFp32ToFp16Workload.hpp"
#include "backends/NeonWorkloads/NeonConvolution2dBaseWorkload.hpp"
-#include "backends/NeonWorkloads/NeonConvolution2dFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonConvolution2dFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonConvolution2dUint8Workload.hpp"
-#include "backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonDepthwiseConvolutionUint8Workload.hpp"
-#include "backends/NeonWorkloads/NeonFloorFloat32Workload.hpp"
-#include "backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.hpp"
-#include "backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.hpp"
-#include "backends/NeonWorkloads/NeonLstmFloat32Workload.hpp"
-#include "backends/NeonWorkloads/NeonMergerFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonFloorFloatWorkload.hpp"
+#include "backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.hpp"
+#include "backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.hpp"
+#include "backends/NeonWorkloads/NeonLstmFloatWorkload.hpp"
+#include "backends/NeonWorkloads/NeonMergerFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonMergerUint8Workload.hpp"
-#include "backends/NeonWorkloads/NeonMultiplicationFloat32Workload.hpp"
-#include "backends/NeonWorkloads/NeonNormalizationFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonMultiplicationFloatWorkload.hpp"
+#include "backends/NeonWorkloads/NeonNormalizationFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonPermuteWorkload.hpp"
#include "backends/NeonWorkloads/NeonPooling2dBaseWorkload.hpp"
-#include "backends/NeonWorkloads/NeonPooling2dFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonPooling2dFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonPooling2dUint8Workload.hpp"
-#include "backends/NeonWorkloads/NeonReshapeFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonReshapeFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonReshapeUint8Workload.hpp"
-#include "backends/NeonWorkloads/NeonSoftmaxFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonSoftmaxFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonSoftmaxUint8Workload.hpp"
-#include "backends/NeonWorkloads/NeonSplitterFloat32Workload.hpp"
+#include "backends/NeonWorkloads/NeonSplitterFloatWorkload.hpp"
#include "backends/NeonWorkloads/NeonSplitterUint8Workload.hpp"
diff --git a/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.cpp
similarity index 80%
rename from src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.cpp
index 711bfce..e3524dc 100644
--- a/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonActivationFloat32Workload.hpp"
+#include "NeonActivationFloatWorkload.hpp"
#include "backends/ArmComputeUtils.hpp"
@@ -32,11 +32,11 @@
activationLayerInfo);
}
-NeonActivationFloat32Workload::NeonActivationFloat32Workload(const ActivationQueueDescriptor& descriptor,
- const WorkloadInfo& info)
+NeonActivationFloatWorkload::NeonActivationFloatWorkload(const ActivationQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
: FloatWorkload<ActivationQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("NeonActivationFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("NeonActivationFloatWorkload", 1, 1);
const arm_compute::ActivationLayerInfo activationLayerInfo =
ConvertActivationDescriptorToAclActivationLayerInfo(m_Data.m_Parameters);
@@ -47,9 +47,9 @@
m_ActivationLayer.configure(&input, &output, activationLayerInfo);
}
-void NeonActivationFloat32Workload::Execute() const
+void NeonActivationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonActivationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonActivationFloatWorkload_Execute");
m_ActivationLayer.run();
}
diff --git a/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.hpp
similarity index 75%
rename from src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.hpp
index 0d26b3b..c9f4bab 100644
--- a/src/armnn/backends/NeonWorkloads/NeonActivationFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonActivationFloatWorkload.hpp
@@ -14,10 +14,10 @@
const TensorInfo& output,
const ActivationDescriptor& descriptor);
-class NeonActivationFloat32Workload : public FloatWorkload<ActivationQueueDescriptor>
+class NeonActivationFloatWorkload : public FloatWorkload<ActivationQueueDescriptor>
{
public:
- NeonActivationFloat32Workload(const ActivationQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonActivationFloatWorkload(const ActivationQueueDescriptor& descriptor, const WorkloadInfo& info);
void Execute() const override;
private:
diff --git a/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.cpp
similarity index 79%
rename from src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.cpp
index f26e42a..1c1e65c 100644
--- a/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonAdditionFloat32Workload.hpp"
+#include "NeonAdditionFloatWorkload.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
#include "backends/CpuTensorHandle.hpp"
@@ -25,11 +25,11 @@
}
-NeonAdditionFloat32Workload::NeonAdditionFloat32Workload(const AdditionQueueDescriptor& descriptor,
- const WorkloadInfo& info)
+NeonAdditionFloatWorkload::NeonAdditionFloatWorkload(const AdditionQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
: FloatWorkload<AdditionQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("NeonAdditionFloat32Workload", 2, 1);
+ m_Data.ValidateInputsOutputs("NeonAdditionFloatWorkload", 2, 1);
arm_compute::ITensor& input1 = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ITensor& input2 = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
@@ -38,9 +38,9 @@
m_AddLayer.configure(&input1, &input2, &output, arm_compute::ConvertPolicy::SATURATE);
}
-void NeonAdditionFloat32Workload::Execute() const
+void NeonAdditionFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonAdditionFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonAdditionFloatWorkload_Execute");
m_AddLayer.run();
}
diff --git a/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.hpp
similarity index 75%
rename from src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.hpp
index dae66bb..efab230 100644
--- a/src/armnn/backends/NeonWorkloads/NeonAdditionFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonAdditionFloatWorkload.hpp
@@ -14,10 +14,10 @@
const TensorInfo& input1,
const TensorInfo& output);
-class NeonAdditionFloat32Workload : public FloatWorkload<AdditionQueueDescriptor>
+class NeonAdditionFloatWorkload : public FloatWorkload<AdditionQueueDescriptor>
{
public:
- NeonAdditionFloat32Workload(const AdditionQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonAdditionFloatWorkload(const AdditionQueueDescriptor& descriptor, const WorkloadInfo& info);
virtual void Execute() const override;
private:
diff --git a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.cpp
similarity index 91%
rename from src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.cpp
index ca5c820..f24ff79 100644
--- a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonBatchNormalizationFloat32Workload.hpp"
+#include "NeonBatchNormalizationFloatWorkload.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
#include "../../../../include/armnn/ArmNN.hpp"
@@ -37,11 +37,11 @@
descriptor.m_Eps);
}
-NeonBatchNormalizationFloat32Workload::NeonBatchNormalizationFloat32Workload(
+NeonBatchNormalizationFloatWorkload::NeonBatchNormalizationFloatWorkload(
const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info)
: FloatWorkload<BatchNormalizationQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("NeonBatchNormalizationFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("NeonBatchNormalizationFloatWorkload", 1, 1);
arm_compute::ITensor& input = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ITensor& output = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -77,13 +77,13 @@
FreeUnusedTensors();
}
-void NeonBatchNormalizationFloat32Workload::Execute() const
+void NeonBatchNormalizationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonBatchNormalizationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonBatchNormalizationFloatWorkload_Execute");
m_Layer.run();
}
-void NeonBatchNormalizationFloat32Workload::FreeUnusedTensors()
+void NeonBatchNormalizationFloatWorkload::FreeUnusedTensors()
{
FreeTensorIfUnused(m_Mean);
FreeTensorIfUnused(m_Variance);
diff --git a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.hpp
similarity index 80%
rename from src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.hpp
index 5eb5601..2844c65 100644
--- a/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonBatchNormalizationFloatWorkload.hpp
@@ -18,11 +18,11 @@
const TensorInfo& gamma,
const BatchNormalizationDescriptor& descriptor);
-class NeonBatchNormalizationFloat32Workload : public FloatWorkload<BatchNormalizationQueueDescriptor>
+class NeonBatchNormalizationFloatWorkload : public FloatWorkload<BatchNormalizationQueueDescriptor>
{
public:
- NeonBatchNormalizationFloat32Workload(const BatchNormalizationQueueDescriptor& descriptor,
- const WorkloadInfo& info);
+ NeonBatchNormalizationFloatWorkload(const BatchNormalizationQueueDescriptor& descriptor,
+ const WorkloadInfo& info);
virtual void Execute() const override;
private:
diff --git a/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.cpp
deleted file mode 100644
index 4e5d570..0000000
--- a/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "NeonConstantFloat32Workload.hpp"
-
-namespace armnn
-{
-
-void NeonConstantFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConstantFloat32Workload_Execute");
- NeonBaseConstantWorkload::Execute();
-}
-
-} //namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.cpp
new file mode 100644
index 0000000..49749a8
--- /dev/null
+++ b/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.cpp
@@ -0,0 +1,17 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "NeonConstantFloatWorkload.hpp"
+
+namespace armnn
+{
+
+void NeonConstantFloatWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConstantFloatWorkload_Execute");
+ NeonBaseConstantWorkload::Execute();
+}
+
+} //namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.hpp
similarity index 78%
rename from src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.hpp
index 050954d..8ae0add 100644
--- a/src/armnn/backends/NeonWorkloads/NeonConstantFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonConstantFloatWorkload.hpp
@@ -10,7 +10,7 @@
namespace armnn
{
-class NeonConstantFloat32Workload : public NeonBaseConstantWorkload<DataType::Float16, DataType::Float32>
+class NeonConstantFloatWorkload : public NeonBaseConstantWorkload<DataType::Float16, DataType::Float32>
{
public:
using NeonBaseConstantWorkload<DataType::Float16, DataType::Float32>::NeonBaseConstantWorkload;
diff --git a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.hpp
deleted file mode 100644
index 0bb8d69..0000000
--- a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#pragma once
-
-#include "NeonConvolution2dBaseWorkload.hpp"
-#include <backends/NeonWorkloadUtils.hpp>
-
-#include "arm_compute/runtime/MemoryManagerOnDemand.h"
-
-#include <memory>
-
-namespace armnn
-{
-
-class NeonConvolution2dFloat32Workload : public NeonConvolution2dBaseWorkload<DataType::Float16, DataType::Float32>
-{
-public:
- NeonConvolution2dFloat32Workload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info,
- std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
-
- void Execute() const override;
- void ValidateData() const override;
-};
-
-} //namespace armnn
-
diff --git a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.cpp
similarity index 63%
rename from src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.cpp
index 18ec6ca..8037cb6 100644
--- a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonConvolution2dFloat32Workload.hpp"
+#include "NeonConvolution2dFloatWorkload.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
#include "backends/NeonLayerSupport.hpp"
@@ -12,7 +12,7 @@
{
using namespace armcomputetensorutils;
-NeonConvolution2dFloat32Workload::NeonConvolution2dFloat32Workload(const Convolution2dQueueDescriptor& descriptor,
+NeonConvolution2dFloatWorkload::NeonConvolution2dFloatWorkload(const Convolution2dQueueDescriptor& descriptor,
const WorkloadInfo& info, std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
: NeonConvolution2dBaseWorkload(descriptor, info, memoryManager)
{
@@ -25,15 +25,15 @@
FreeUnusedTensors();
}
-void NeonConvolution2dFloat32Workload::Execute() const
+void NeonConvolution2dFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConvolution2dFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConvolution2dFloatWorkload_Execute");
m_ConvolutionLayer->run();
}
-void NeonConvolution2dFloat32Workload::ValidateData() const
+void NeonConvolution2dFloatWorkload::ValidateData() const
{
- m_Data.ValidateInputsOutputs("NeonConvolution2dFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("NeonConvolution2dFloatWorkload", 1, 1);
}
} //namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.hpp b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.hpp
new file mode 100644
index 0000000..1d08118
--- /dev/null
+++ b/src/armnn/backends/NeonWorkloads/NeonConvolution2dFloatWorkload.hpp
@@ -0,0 +1,29 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#pragma once
+
+#include "NeonConvolution2dBaseWorkload.hpp"
+#include <backends/NeonWorkloadUtils.hpp>
+
+#include "arm_compute/runtime/MemoryManagerOnDemand.h"
+
+#include <memory>
+
+namespace armnn
+{
+
+class NeonConvolution2dFloatWorkload : public NeonConvolution2dBaseWorkload<DataType::Float16, DataType::Float32>
+{
+public:
+ NeonConvolution2dFloatWorkload(const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info,
+ std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
+
+ void Execute() const override;
+ void ValidateData() const override;
+};
+
+} //namespace armnn
+
diff --git a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.cpp
similarity index 89%
rename from src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.cpp
index f94cd90..96ca938 100644
--- a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonDepthwiseConvolutionFloat32Workload.hpp"
+#include "NeonDepthwiseConvolutionFloatWorkload.hpp"
#include "backends/NeonLayerSupport.hpp"
#include "backends/CpuTensorHandle.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
@@ -13,7 +13,7 @@
{
using namespace armcomputetensorutils;
-NeonDepthwiseConvolutionFloat32Workload::NeonDepthwiseConvolutionFloat32Workload(
+NeonDepthwiseConvolutionFloatWorkload::NeonDepthwiseConvolutionFloatWorkload(
const DepthwiseConvolution2dQueueDescriptor& descriptor,
const WorkloadInfo& info)
: FloatWorkload<DepthwiseConvolution2dQueueDescriptor>(descriptor, info)
@@ -37,7 +37,7 @@
m_Data.m_Parameters.m_PadBottom,
arm_compute::DimensionRoundingType::FLOOR);
- m_Data.ValidateInputsOutputs("NeonDepthwiseConvolutionFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("NeonDepthwiseConvolutionFloatWorkload", 1, 1);
arm_compute::ITensor& input = static_cast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ITensor& output = static_cast<INeonTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -77,15 +77,15 @@
FreeUnusedTensors();
}
-void NeonDepthwiseConvolutionFloat32Workload::Execute() const
+void NeonDepthwiseConvolutionFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonDepthwiseConvolutionFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonDepthwiseConvolutionFloatWorkload_Execute");
BOOST_ASSERT(m_pDepthwiseConvolutionLayer);
m_pDepthwiseConvolutionLayer->run();
}
-void NeonDepthwiseConvolutionFloat32Workload::FreeUnusedTensors()
+void NeonDepthwiseConvolutionFloatWorkload::FreeUnusedTensors()
{
FreeTensorIfUnused(m_KernelTensor);
FreeTensorIfUnused(m_BiasTensor);
diff --git a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.hpp
similarity index 65%
rename from src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.hpp
index ece9f18..670182e 100644
--- a/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonDepthwiseConvolutionFloatWorkload.hpp
@@ -10,11 +10,11 @@
namespace armnn
{
-class NeonDepthwiseConvolutionFloat32Workload : public FloatWorkload<DepthwiseConvolution2dQueueDescriptor>
+class NeonDepthwiseConvolutionFloatWorkload : public FloatWorkload<DepthwiseConvolution2dQueueDescriptor>
{
public:
- NeonDepthwiseConvolutionFloat32Workload(const DepthwiseConvolution2dQueueDescriptor& descriptor,
- const WorkloadInfo& info);
+ NeonDepthwiseConvolutionFloatWorkload(const DepthwiseConvolution2dQueueDescriptor& descriptor,
+ const WorkloadInfo& info);
virtual void Execute() const override;
private:
diff --git a/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.cpp
new file mode 100644
index 0000000..4d2cb02
--- /dev/null
+++ b/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.cpp
@@ -0,0 +1,30 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "NeonFloorFloatWorkload.hpp"
+
+namespace armnn
+{
+NeonFloorFloatWorkload::NeonFloorFloatWorkload(const FloorQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
+ : FloatWorkload<FloorQueueDescriptor>(descriptor, info)
+{
+ m_Data.ValidateInputsOutputs("NeonFloorFloatWorkload", 1, 1);
+
+ arm_compute::ITensor& input = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
+ arm_compute::ITensor& output = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
+
+ m_Layer.configure(&input, &output);
+}
+
+void NeonFloorFloatWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFloorFloatWorkload_Execute");
+ m_Layer.run();
+}
+} //namespace armnn
+
+
+
diff --git a/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.hpp
similarity index 66%
rename from src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.hpp
index 56680f1..1443d9a 100644
--- a/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonFloorFloatWorkload.hpp
@@ -10,10 +10,10 @@
namespace armnn
{
-class NeonFloorFloat32Workload : public FloatWorkload<FloorQueueDescriptor>
+class NeonFloorFloatWorkload : public FloatWorkload<FloorQueueDescriptor>
{
public:
- NeonFloorFloat32Workload(const FloorQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonFloorFloatWorkload(const FloorQueueDescriptor& descriptor, const WorkloadInfo& info);
virtual void Execute() const override;
private:
diff --git a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.cpp
similarity index 88%
rename from src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.cpp
index c3af41e..098d84b 100644
--- a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonFullyConnectedFloat32Workload.hpp"
+#include "NeonFullyConnectedFloatWorkload.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
#include "backends/ArmComputeUtils.hpp"
@@ -42,12 +42,12 @@
fullyConnectedLayerInfo);
}
-NeonFullyConnectedFloat32Workload::NeonFullyConnectedFloat32Workload(const FullyConnectedQueueDescriptor& descriptor,
+NeonFullyConnectedFloatWorkload::NeonFullyConnectedFloatWorkload(const FullyConnectedQueueDescriptor& descriptor,
const WorkloadInfo& info, std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
: FloatWorkload<FullyConnectedQueueDescriptor>(descriptor, info)
, m_FullyConnectedLayer(memoryManager)
{
- m_Data.ValidateInputsOutputs("NeonFullyConnectedFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("NeonFullyConnectedFloatWorkload", 1, 1);
arm_compute::ITensor& input = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ITensor& output = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -80,13 +80,13 @@
FreeUnusedTensors();
}
-void NeonFullyConnectedFloat32Workload::Execute() const
+void NeonFullyConnectedFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFullyConnectedFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFullyConnectedFloatWorkload_Execute");
m_FullyConnectedLayer.run();
}
-void NeonFullyConnectedFloat32Workload::FreeUnusedTensors()
+void NeonFullyConnectedFloatWorkload::FreeUnusedTensors()
{
FreeTensorIfUnused(m_WeightsTensor);
FreeTensorIfUnused(m_BiasesTensor);
diff --git a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.hpp
similarity index 76%
rename from src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.hpp
index 684b5e0..1f4464f 100644
--- a/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonFullyConnectedFloatWorkload.hpp
@@ -20,11 +20,11 @@
const TensorInfo& biases,
const FullyConnectedDescriptor& descriptor);
-class NeonFullyConnectedFloat32Workload : public FloatWorkload<FullyConnectedQueueDescriptor>
+class NeonFullyConnectedFloatWorkload : public FloatWorkload<FullyConnectedQueueDescriptor>
{
public:
- NeonFullyConnectedFloat32Workload(const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info,
- std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
+ NeonFullyConnectedFloatWorkload(const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info,
+ std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
virtual void Execute() const override;
private:
diff --git a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.cpp
similarity index 77%
rename from src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.cpp
index a3ae33f..bf0ef01 100644
--- a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonL2NormalizationFloat32Workload.hpp"
+#include "NeonL2NormalizationFloatWorkload.hpp"
#include "backends/ArmComputeUtils.hpp"
namespace armnn
@@ -21,21 +21,21 @@
return arm_compute::NENormalizationLayer::validate(&aclInput, &aclOutput, normalizationInfo);
}
-NeonL2NormalizationFloat32Workload::NeonL2NormalizationFloat32Workload(const L2NormalizationQueueDescriptor& descriptor,
+NeonL2NormalizationFloatWorkload::NeonL2NormalizationFloatWorkload(const L2NormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info, std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
: FloatWorkload<L2NormalizationQueueDescriptor>(descriptor, info)
, m_Layer(memoryManager)
{
- m_Data.ValidateInputsOutputs("NeonL2NormalizationFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("NeonL2NormalizationFloatWorkload", 1, 1);
arm_compute::ITensor& input = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ITensor& output = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
m_Layer.configure(&input, &output, CreateAclNormalizationLayerInfoForL2Normalization(info.m_InputTensorInfos[0]));
}
-void NeonL2NormalizationFloat32Workload::Execute() const
+void NeonL2NormalizationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonL2NormalizationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonL2NormalizationFloatWorkload_Execute");
m_Layer.run();
}
diff --git a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.hpp
similarity index 67%
rename from src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.hpp
index c3fcde5..5edff07 100644
--- a/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonL2NormalizationFloatWorkload.hpp
@@ -17,11 +17,11 @@
arm_compute::Status NeonL2NormalizationWorkloadValidate(const TensorInfo& input,
const TensorInfo& output);
-class NeonL2NormalizationFloat32Workload : public FloatWorkload<L2NormalizationQueueDescriptor>
+class NeonL2NormalizationFloatWorkload : public FloatWorkload<L2NormalizationQueueDescriptor>
{
public:
- NeonL2NormalizationFloat32Workload(const L2NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info,
- std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
+ NeonL2NormalizationFloatWorkload(const L2NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info,
+ std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
virtual void Execute() const override;
private:
diff --git a/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.cpp
deleted file mode 100644
index ba1369e..0000000
--- a/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "NeonLstmFloat32Workload.hpp"
-
-namespace armnn
-{
-NeonLstmFloat32Workload::NeonLstmFloat32Workload(const LstmQueueDescriptor& descriptor,
- const WorkloadInfo& info)
- : FloatWorkload<LstmQueueDescriptor>(descriptor, info)
-{
- m_Data.ValidateInputsOutputs("NeonLstmFloat32Workload", 1, 1);
-}
-
-void NeonLstmFloat32Workload::Execute() const
-{
- throw armnn::Exception("No implementation of Lstm in the Neon backend!");
-}
-
-} // namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.cpp
new file mode 100644
index 0000000..8159e9f
--- /dev/null
+++ b/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.cpp
@@ -0,0 +1,22 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "NeonLstmFloatWorkload.hpp"
+
+namespace armnn
+{
+NeonLstmFloatWorkload::NeonLstmFloatWorkload(const LstmQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
+ : FloatWorkload<LstmQueueDescriptor>(descriptor, info)
+{
+ m_Data.ValidateInputsOutputs("NeonLstmFloatWorkload", 1, 1);
+}
+
+void NeonLstmFloatWorkload::Execute() const
+{
+ throw armnn::Exception("No implementation of Lstm in the Neon backend!");
+}
+
+} // namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.hpp
similarity index 62%
rename from src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.hpp
index 78ee1da..fc06d55 100644
--- a/src/armnn/backends/NeonWorkloads/NeonLstmFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonLstmFloatWorkload.hpp
@@ -10,10 +10,10 @@
namespace armnn
{
-class NeonLstmFloat32Workload : public FloatWorkload<LstmQueueDescriptor>
+class NeonLstmFloatWorkload : public FloatWorkload<LstmQueueDescriptor>
{
public:
- NeonLstmFloat32Workload(const LstmQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonLstmFloatWorkload(const LstmQueueDescriptor& descriptor, const WorkloadInfo& info);
virtual void Execute() const override;
};
diff --git a/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.cpp
deleted file mode 100644
index 30dd283..0000000
--- a/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "NeonMergerFloat32Workload.hpp"
-
-namespace armnn
-{
-
-void NeonMergerFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMergerFloat32Workload_Execute");
- NeonBaseMergerWorkload::Execute();
-}
-
-} // namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.cpp
new file mode 100644
index 0000000..02caca9
--- /dev/null
+++ b/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.cpp
@@ -0,0 +1,17 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "NeonMergerFloatWorkload.hpp"
+
+namespace armnn
+{
+
+void NeonMergerFloatWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMergerFloatWorkload_Execute");
+ NeonBaseMergerWorkload::Execute();
+}
+
+} // namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.hpp
similarity index 78%
rename from src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.hpp
index 7b8ee98..c9f8e66 100644
--- a/src/armnn/backends/NeonWorkloads/NeonMergerFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonMergerFloatWorkload.hpp
@@ -10,7 +10,7 @@
namespace armnn
{
-class NeonMergerFloat32Workload : public NeonBaseMergerWorkload<DataType::Float16, DataType::Float32>
+class NeonMergerFloatWorkload : public NeonBaseMergerWorkload<DataType::Float16, DataType::Float32>
{
public:
using NeonBaseMergerWorkload<DataType::Float16, DataType::Float32>::NeonBaseMergerWorkload;
diff --git a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.cpp
similarity index 86%
rename from src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.cpp
index a8a3cd7..ca38a24 100644
--- a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonMultiplicationFloat32Workload.hpp"
+#include "NeonMultiplicationFloatWorkload.hpp"
namespace armnn
@@ -28,11 +28,11 @@
arm_compute::RoundingPolicy::TO_ZERO);
}
-NeonMultiplicationFloat32Workload::NeonMultiplicationFloat32Workload(const MultiplicationQueueDescriptor& descriptor,
- const WorkloadInfo& info)
+NeonMultiplicationFloatWorkload::NeonMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
: FloatWorkload<MultiplicationQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("NeonMultiplicationFloat32Workload", 2, 1);
+ m_Data.ValidateInputsOutputs("NeonMultiplicationFloatWorkload", 2, 1);
arm_compute::ITensor& input1 = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ITensor& input2 = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
@@ -49,9 +49,9 @@
arm_compute::RoundingPolicy::TO_ZERO);
}
-void NeonMultiplicationFloat32Workload::Execute() const
+void NeonMultiplicationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMultiplicationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMultiplicationFloatWorkload_Execute");
m_PixelWiseMultiplication.run();
}
diff --git a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.hpp
similarity index 74%
rename from src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.hpp
index 62e84a2..eb0f774 100644
--- a/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonMultiplicationFloatWorkload.hpp
@@ -13,10 +13,10 @@
const TensorInfo& input1,
const TensorInfo& output);
-class NeonMultiplicationFloat32Workload : public FloatWorkload<MultiplicationQueueDescriptor>
+class NeonMultiplicationFloatWorkload : public FloatWorkload<MultiplicationQueueDescriptor>
{
public:
- NeonMultiplicationFloat32Workload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info);
virtual void Execute() const override;
private:
diff --git a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.cpp
similarity index 88%
rename from src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.cpp
index 20936a2..8c2a87d 100644
--- a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.cpp
@@ -3,7 +3,7 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonNormalizationFloat32Workload.hpp"
+#include "NeonNormalizationFloatWorkload.hpp"
#include "backends/NeonLayerSupport.hpp"
#include "backends/ArmComputeUtils.hpp"
#include "backends/ArmComputeTensorUtils.hpp"
@@ -24,13 +24,13 @@
return arm_compute::NENormalizationLayer::validate(&aclInput, &aclOutput, normalizationInfo);
}
-NeonNormalizationFloat32Workload::NeonNormalizationFloat32Workload(const NormalizationQueueDescriptor& descriptor,
+NeonNormalizationFloatWorkload::NeonNormalizationFloatWorkload(const NormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info,
std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
: FloatWorkload<NormalizationQueueDescriptor>(descriptor, info)
, m_NormalizationLayer(memoryManager)
{
- m_Data.ValidateInputsOutputs("NeonNormalizationFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("NeonNormalizationFloatWorkload", 1, 1);
std::string reasonIfUnsupported;
if (!IsNeonNormalizationDescParamsSupported(&reasonIfUnsupported, m_Data.m_Parameters))
{
@@ -61,9 +61,9 @@
m_NormalizationLayer.configure(&input, &output, normalizationInfo);
}
-void NeonNormalizationFloat32Workload::Execute() const
+void NeonNormalizationFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonNormalizationFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonNormalizationFloatWorkload_Execute");
m_NormalizationLayer.run();
}
diff --git a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.hpp
similarity index 68%
rename from src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.hpp
index 8f08234..8e8cc40 100644
--- a/src/armnn/backends/NeonWorkloads/NeonNormalizationFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonNormalizationFloatWorkload.hpp
@@ -16,11 +16,11 @@
const TensorInfo& output,
const NormalizationDescriptor& descriptor);
-class NeonNormalizationFloat32Workload : public FloatWorkload<NormalizationQueueDescriptor>
+class NeonNormalizationFloatWorkload : public FloatWorkload<NormalizationQueueDescriptor>
{
public:
- NeonNormalizationFloat32Workload(const NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info,
- std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
+ NeonNormalizationFloatWorkload(const NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info,
+ std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
virtual void Execute() const override;
private:
diff --git a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.cpp
deleted file mode 100644
index cb690c5..0000000
--- a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "NeonPooling2dFloat32Workload.hpp"
-
-
-
-namespace armnn
-{
-
-NeonPooling2dFloat32Workload::NeonPooling2dFloat32Workload(const Pooling2dQueueDescriptor& descriptor,
- const WorkloadInfo& info)
- : NeonPooling2dBaseWorkload<armnn::DataType::Float16, armnn::DataType::Float32>(descriptor, info,
- "NeonPooling2dFloat32Workload")
-{
-}
-
-void NeonPooling2dFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonPooling2dFloat32Workload_Execute");
- m_PoolingLayer.run();
-}
-
-} //namespace armnn
-
diff --git a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.cpp
new file mode 100644
index 0000000..90e09db
--- /dev/null
+++ b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.cpp
@@ -0,0 +1,27 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "NeonPooling2dFloatWorkload.hpp"
+
+
+
+namespace armnn
+{
+
+NeonPooling2dFloatWorkload::NeonPooling2dFloatWorkload(const Pooling2dQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
+ : NeonPooling2dBaseWorkload<armnn::DataType::Float16, armnn::DataType::Float32>(descriptor, info,
+ "NeonPooling2dFloatWorkload")
+{
+}
+
+void NeonPooling2dFloatWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonPooling2dFloatWorkload_Execute");
+ m_PoolingLayer.run();
+}
+
+} //namespace armnn
+
diff --git a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.hpp
similarity index 62%
rename from src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.hpp
index 36c4e7e..ba4e9ca 100644
--- a/src/armnn/backends/NeonWorkloads/NeonPooling2dFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonPooling2dFloatWorkload.hpp
@@ -11,11 +11,11 @@
namespace armnn
{
-class NeonPooling2dFloat32Workload : public NeonPooling2dBaseWorkload<armnn::DataType::Float16,
- armnn::DataType::Float32>
+class NeonPooling2dFloatWorkload : public NeonPooling2dBaseWorkload<armnn::DataType::Float16,
+ armnn::DataType::Float32>
{
public:
- NeonPooling2dFloat32Workload(const Pooling2dQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonPooling2dFloatWorkload(const Pooling2dQueueDescriptor& descriptor, const WorkloadInfo& info);
virtual void Execute() const override;
};
diff --git a/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.cpp
deleted file mode 100644
index 93f6eb8..0000000
--- a/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "NeonReshapeFloat32Workload.hpp"
-
-
-
-namespace armnn
-{
-
-NeonReshapeFloat32Workload::NeonReshapeFloat32Workload(const ReshapeQueueDescriptor& descriptor,
- const WorkloadInfo& info)
- : FloatWorkload<ReshapeQueueDescriptor>(descriptor, info)
-{
- m_Data.ValidateInputsOutputs("NeonReshapeFloat32Workload", 1, 1);
-
- arm_compute::ITensor& input = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
- arm_compute::ITensor& output = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
-
- m_Layer.configure(&input, &output);
-}
-
-void NeonReshapeFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonReshapeFloat32Workload_Execute");
- m_Layer.run();
-}
-
-} //namespace armnn
-
diff --git a/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.cpp
similarity index 60%
rename from src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.cpp
index c43cfa9..ef229b2 100644
--- a/src/armnn/backends/NeonWorkloads/NeonFloorFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.cpp
@@ -3,15 +3,18 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonFloorFloat32Workload.hpp"
+#include "NeonReshapeFloatWorkload.hpp"
+
+
namespace armnn
{
-NeonFloorFloat32Workload::NeonFloorFloat32Workload(const FloorQueueDescriptor& descriptor,
+
+NeonReshapeFloatWorkload::NeonReshapeFloatWorkload(const ReshapeQueueDescriptor& descriptor,
const WorkloadInfo& info)
- : FloatWorkload<FloorQueueDescriptor>(descriptor, info)
+ : FloatWorkload<ReshapeQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("NeonFloorFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("NeonReshapeFloatWorkload", 1, 1);
arm_compute::ITensor& input = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
arm_compute::ITensor& output = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
@@ -19,12 +22,11 @@
m_Layer.configure(&input, &output);
}
-void NeonFloorFloat32Workload::Execute() const
+void NeonReshapeFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonFloorFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonReshapeFloatWorkload_Execute");
m_Layer.run();
}
+
} //namespace armnn
-
-
diff --git a/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.hpp
similarity index 65%
rename from src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.hpp
index 3e5cca1..d32d779 100644
--- a/src/armnn/backends/NeonWorkloads/NeonReshapeFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonReshapeFloatWorkload.hpp
@@ -10,10 +10,10 @@
namespace armnn
{
-class NeonReshapeFloat32Workload : public FloatWorkload<ReshapeQueueDescriptor>
+class NeonReshapeFloatWorkload : public FloatWorkload<ReshapeQueueDescriptor>
{
public:
- NeonReshapeFloat32Workload(const ReshapeQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonReshapeFloatWorkload(const ReshapeQueueDescriptor& descriptor, const WorkloadInfo& info);
virtual void Execute() const override;
diff --git a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.hpp
deleted file mode 100644
index 3656a26..0000000
--- a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#pragma once
-
-#include <backends/NeonWorkloadUtils.hpp>
-
-#include "arm_compute/runtime/MemoryManagerOnDemand.h"
-
-#include <memory>
-
-namespace armnn
-{
-
-class NeonSoftmaxFloat32Workload : public FloatWorkload<SoftmaxQueueDescriptor>
-{
-public:
- NeonSoftmaxFloat32Workload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
- std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
- virtual void Execute() const override;
-
-private:
- mutable arm_compute::NESoftmaxLayer m_SoftmaxLayer;
-};
-
-} //namespace armnn
-
diff --git a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.cpp
similarity index 70%
rename from src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.cpp
rename to src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.cpp
index 027b508..981e63e 100644
--- a/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloat32Workload.cpp
+++ b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.cpp
@@ -3,17 +3,17 @@
// See LICENSE file in the project root for full license information.
//
-#include "NeonSoftmaxFloat32Workload.hpp"
+#include "NeonSoftmaxFloatWorkload.hpp"
namespace armnn
{
-NeonSoftmaxFloat32Workload::NeonSoftmaxFloat32Workload(const SoftmaxQueueDescriptor& descriptor,
+NeonSoftmaxFloatWorkload::NeonSoftmaxFloatWorkload(const SoftmaxQueueDescriptor& descriptor,
const WorkloadInfo& info, std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
: FloatWorkload<SoftmaxQueueDescriptor>(descriptor, info)
, m_SoftmaxLayer(memoryManager)
{
- m_Data.ValidateInputsOutputs("NeonSoftmaxFloat32Workload", 1, 1);
+ m_Data.ValidateInputsOutputs("NeonSoftmaxFloatWorkload", 1, 1);
// The ArmCompute softmax layer uses 2D input/output tensors, so flatten the first three dimensions.
arm_compute::ITensor& input = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
@@ -22,9 +22,9 @@
m_SoftmaxLayer.configure(&input, &output, m_Data.m_Parameters.m_Beta);
}
-void NeonSoftmaxFloat32Workload::Execute() const
+void NeonSoftmaxFloatWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSoftmaxFloat32Workload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSoftmaxFloatWorkload_Execute");
m_SoftmaxLayer.run();
}
diff --git a/src/armnn/backends/ClWorkloads/ClSoftmaxFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.hpp
similarity index 61%
copy from src/armnn/backends/ClWorkloads/ClSoftmaxFloat32Workload.hpp
copy to src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.hpp
index 6cad598..52dbded 100644
--- a/src/armnn/backends/ClWorkloads/ClSoftmaxFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonSoftmaxFloatWorkload.hpp
@@ -5,7 +5,7 @@
#pragma once
-#include "backends/ClWorkloadUtils.hpp"
+#include <backends/NeonWorkloadUtils.hpp>
#include "arm_compute/runtime/MemoryManagerOnDemand.h"
@@ -14,15 +14,15 @@
namespace armnn
{
-class ClSoftmaxFloat32Workload : public FloatWorkload<SoftmaxQueueDescriptor>
+class NeonSoftmaxFloatWorkload : public FloatWorkload<SoftmaxQueueDescriptor>
{
public:
- ClSoftmaxFloat32Workload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
+ NeonSoftmaxFloatWorkload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
- void Execute() const override;
+ virtual void Execute() const override;
private:
- mutable arm_compute::CLSoftmaxLayer m_SoftmaxLayer;
+ mutable arm_compute::NESoftmaxLayer m_SoftmaxLayer;
};
} //namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.cpp b/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.cpp
deleted file mode 100644
index 996fc15..0000000
--- a/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#include "NeonSplitterFloat32Workload.hpp"
-
-namespace armnn
-{
-
-void NeonSplitterFloat32Workload::Execute() const
-{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSplitterFloat32Workload_Execute");
- NeonBaseSplitterWorkload::Execute();
-}
-
-} //namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.cpp b/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.cpp
new file mode 100644
index 0000000..06e300c
--- /dev/null
+++ b/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.cpp
@@ -0,0 +1,17 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "NeonSplitterFloatWorkload.hpp"
+
+namespace armnn
+{
+
+void NeonSplitterFloatWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSplitterFloatWorkload_Execute");
+ NeonBaseSplitterWorkload::Execute();
+}
+
+} //namespace armnn
diff --git a/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.hpp b/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.hpp
similarity index 78%
rename from src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.hpp
rename to src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.hpp
index 9f6dc75..5d6b328 100644
--- a/src/armnn/backends/NeonWorkloads/NeonSplitterFloat32Workload.hpp
+++ b/src/armnn/backends/NeonWorkloads/NeonSplitterFloatWorkload.hpp
@@ -10,7 +10,7 @@
namespace armnn
{
-class NeonSplitterFloat32Workload : public NeonBaseSplitterWorkload<DataType::Float16, DataType::Float32>
+class NeonSplitterFloatWorkload : public NeonBaseSplitterWorkload<DataType::Float16, DataType::Float32>
{
public:
using NeonBaseSplitterWorkload<DataType::Float16, DataType::Float32>::NeonBaseSplitterWorkload;
diff --git a/src/armnn/backends/test/CreateWorkloadCl.cpp b/src/armnn/backends/test/CreateWorkloadCl.cpp
index 5d42659..538d5af 100644
--- a/src/armnn/backends/test/CreateWorkloadCl.cpp
+++ b/src/armnn/backends/test/CreateWorkloadCl.cpp
@@ -37,14 +37,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {1}));
}
-BOOST_AUTO_TEST_CASE(CreateActivationFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateActivationFloatWorkload)
{
- ClCreateActivationWorkloadTest<ClActivationFloat32Workload, armnn::DataType::Float32>();
+ ClCreateActivationWorkloadTest<ClActivationFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateActivationFloat16Workload)
{
- ClCreateActivationWorkloadTest<ClActivationFloat32Workload, armnn::DataType::Float16>();
+ ClCreateActivationWorkloadTest<ClActivationFloatWorkload, armnn::DataType::Float16>();
}
template <typename AdditionWorkloadType, armnn::DataType DataType>
@@ -64,14 +64,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {2, 3}));
}
-BOOST_AUTO_TEST_CASE(CreateAdditionFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateAdditionFloatWorkload)
{
- ClCreateAdditionWorkloadTest<ClAdditionFloat32Workload, armnn::DataType::Float32>();
+ ClCreateAdditionWorkloadTest<ClAdditionFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateAdditionFloat16Workload)
{
- ClCreateAdditionWorkloadTest<ClAdditionFloat32Workload, armnn::DataType::Float16>();
+ ClCreateAdditionWorkloadTest<ClAdditionFloatWorkload, armnn::DataType::Float16>();
}
template <typename BatchNormalizationWorkloadType, armnn::DataType DataType>
@@ -92,14 +92,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {2, 3, 1, 1}));
}
-BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloatWorkload)
{
- ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloat32Workload, armnn::DataType::Float32>();
+ ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat16Workload)
{
- ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloat32Workload, armnn::DataType::Float16>();
+ ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload, armnn::DataType::Float16>();
}
BOOST_AUTO_TEST_CASE(CreateConvertFp16ToFp32Workload)
@@ -150,14 +150,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {2, 2, 2, 10}));
}
-BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatWorkload)
{
- ClConvolution2dWorkloadTest<ClConvolution2dFloat32Workload, armnn::DataType::Float32>();
+ ClConvolution2dWorkloadTest<ClConvolution2dFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16Workload)
{
- ClConvolution2dWorkloadTest<ClConvolution2dFloat32Workload, armnn::DataType::Float16>();
+ ClConvolution2dWorkloadTest<ClConvolution2dFloatWorkload, armnn::DataType::Float16>();
}
@@ -177,14 +177,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {2, 2, 6, 6}));
}
-BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dFloatWorkload)
{
- ClDirectConvolution2dWorkloadTest<ClConvolution2dFloat32Workload, armnn::DataType::Float32>();
+ ClDirectConvolution2dWorkloadTest<ClConvolution2dFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dFloat16Workload)
{
- ClDirectConvolution2dWorkloadTest<ClConvolution2dFloat32Workload, armnn::DataType::Float16>();
+ ClDirectConvolution2dWorkloadTest<ClConvolution2dFloatWorkload, armnn::DataType::Float16>();
}
BOOST_AUTO_TEST_CASE(CreateDirectConvolution2dUint8Workload)
@@ -209,14 +209,14 @@
}
-BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloat32WorkloadTest)
+BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloatWorkloadTest)
{
- ClCreateFullyConnectedWorkloadTest<ClFullyConnectedFloat32Workload, armnn::DataType::Float32>();
+ ClCreateFullyConnectedWorkloadTest<ClFullyConnectedFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloat16WorkloadTest)
{
- ClCreateFullyConnectedWorkloadTest<ClFullyConnectedFloat32Workload, armnn::DataType::Float16>();
+ ClCreateFullyConnectedWorkloadTest<ClFullyConnectedFloatWorkload, armnn::DataType::Float16>();
}
@@ -239,14 +239,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {2, 3}));
}
-BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat32WorkloadTest)
+BOOST_AUTO_TEST_CASE(CreateMultiplicationFloatWorkloadTest)
{
- ClCreateMultiplicationWorkloadTest<ClMultiplicationFloat32Workload, armnn::DataType::Float32>();
+ ClCreateMultiplicationWorkloadTest<ClMultiplicationFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat16WorkloadTest)
{
- ClCreateMultiplicationWorkloadTest<ClMultiplicationFloat32Workload, armnn::DataType::Float16>();
+ ClCreateMultiplicationWorkloadTest<ClMultiplicationFloatWorkload, armnn::DataType::Float16>();
}
template <typename NormalizationWorkloadType, typename armnn::DataType DataType>
@@ -267,14 +267,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {3, 5, 5, 1}));
}
-BOOST_AUTO_TEST_CASE(CreateNormalizationFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateNormalizationFloatWorkload)
{
- ClNormalizationWorkloadTest<ClNormalizationFloat32Workload, armnn::DataType::Float32>();
+ ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateNormalizationFloat16Workload)
{
- ClNormalizationWorkloadTest<ClNormalizationFloat32Workload, armnn::DataType::Float16>();
+ ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>();
}
template <typename Pooling2dWorkloadType, typename armnn::DataType DataType>
@@ -294,14 +294,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {3, 2, 2, 4}));
}
-BOOST_AUTO_TEST_CASE(CreatePooling2dFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreatePooling2dFloatWorkload)
{
- ClPooling2dWorkloadTest<ClPooling2dFloat32Workload, armnn::DataType::Float32>();
+ ClPooling2dWorkloadTest<ClPooling2dFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16Workload)
{
- ClPooling2dWorkloadTest<ClPooling2dFloat32Workload, armnn::DataType::Float16>();
+ ClPooling2dWorkloadTest<ClPooling2dFloatWorkload, armnn::DataType::Float16>();
}
template <typename ReshapeWorkloadType, typename armnn::DataType DataType>
@@ -321,14 +321,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {4})); // Leading size 1 dimensions are collapsed by ACL.
}
-BOOST_AUTO_TEST_CASE(CreateReshapeFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateReshapeFloatWorkload)
{
- ClCreateReshapeWorkloadTest<ClReshapeFloat32Workload, armnn::DataType::Float32>();
+ ClCreateReshapeWorkloadTest<ClReshapeFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateReshapeFloat16Workload)
{
- ClCreateReshapeWorkloadTest<ClReshapeFloat32Workload, armnn::DataType::Float16>();
+ ClCreateReshapeWorkloadTest<ClReshapeFloatWorkload, armnn::DataType::Float16>();
}
BOOST_AUTO_TEST_CASE(CreateReshapeUint8Workload)
@@ -344,7 +344,7 @@
auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
- // Checks that inputs/outputs are as we expect them (see definition of ClSoftmaxFloat32Workload).
+ // Checks that inputs/outputs are as we expect them (see definition of ClSoftmaxFloatWorkload).
SoftmaxQueueDescriptor queueDescriptor = workload->GetData();
auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
@@ -354,14 +354,14 @@
}
-BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat32WorkloadTest)
+BOOST_AUTO_TEST_CASE(CreateSoftmaxFloatWorkloadTest)
{
- ClSoftmaxWorkloadTest<ClSoftmaxFloat32Workload, armnn::DataType::Float32>();
+ ClSoftmaxWorkloadTest<ClSoftmaxFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat16WorkloadTest)
{
- ClSoftmaxWorkloadTest<ClSoftmaxFloat32Workload, armnn::DataType::Float16>();
+ ClSoftmaxWorkloadTest<ClSoftmaxFloatWorkload, armnn::DataType::Float16>();
}
template <typename SplitterWorkloadType, typename armnn::DataType DataType>
@@ -389,14 +389,14 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle0, {7, 7}));
}
-BOOST_AUTO_TEST_CASE(CreateSplitterFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateSplitterFloatWorkload)
{
- ClSplitterWorkloadTest<ClSplitterFloat32Workload, armnn::DataType::Float32>();
+ ClSplitterWorkloadTest<ClSplitterFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateSplitterFloat16Workload)
{
- ClSplitterWorkloadTest<ClSplitterFloat32Workload, armnn::DataType::Float16>();
+ ClSplitterWorkloadTest<ClSplitterFloatWorkload, armnn::DataType::Float16>();
}
template <typename SplitterWorkloadType, typename MergerWorkloadType, typename armnn::DataType DataType>
@@ -441,14 +441,14 @@
BOOST_TEST(validSubTensorParents);
}
-BOOST_AUTO_TEST_CASE(CreateSplitterMergerFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateSplitterMergerFloatWorkload)
{
- ClSplitterMergerTest<ClSplitterFloat32Workload, ClMergerFloat32Workload, armnn::DataType::Float32>();
+ ClSplitterMergerTest<ClSplitterFloatWorkload, ClMergerFloatWorkload, armnn::DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateSplitterMergerFloat16Workload)
{
- ClSplitterMergerTest<ClSplitterFloat32Workload, ClMergerFloat32Workload, armnn::DataType::Float16>();
+ ClSplitterMergerTest<ClSplitterFloatWorkload, ClMergerFloatWorkload, armnn::DataType::Float16>();
}
@@ -459,14 +459,14 @@
Graph graph;
ClWorkloadFactory factory;
- std::unique_ptr<ClSplitterFloat32Workload> wlSplitter;
- std::unique_ptr<ClActivationFloat32Workload> wlActiv0_0;
- std::unique_ptr<ClActivationFloat32Workload> wlActiv0_1;
- std::unique_ptr<ClActivationFloat32Workload> wlActiv1_0;
- std::unique_ptr<ClActivationFloat32Workload> wlActiv1_1;
+ std::unique_ptr<ClSplitterFloatWorkload> wlSplitter;
+ std::unique_ptr<ClActivationFloatWorkload> wlActiv0_0;
+ std::unique_ptr<ClActivationFloatWorkload> wlActiv0_1;
+ std::unique_ptr<ClActivationFloatWorkload> wlActiv1_0;
+ std::unique_ptr<ClActivationFloatWorkload> wlActiv1_1;
- CreateSplitterMultipleInputsOneOutputWorkloadTest<ClSplitterFloat32Workload,
- ClActivationFloat32Workload, armnn::DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
+ CreateSplitterMultipleInputsOneOutputWorkloadTest<ClSplitterFloatWorkload,
+ ClActivationFloatWorkload, armnn::DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
wlActiv1_0, wlActiv1_1);
//Checks that the index of inputs/outputs matches what we declared on InputDescriptor construction.
@@ -502,7 +502,7 @@
Graph graph;
ClWorkloadFactory factory;
- auto workload = CreateL2NormalizationWorkloadTest<ClL2NormalizationFloat32Workload, armnn::DataType::Float32>
+ auto workload = CreateL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>
(factory, graph);
// Checks that inputs/outputs are as we expect them (see definition of CreateNormalizationWorkloadTest).
@@ -528,9 +528,9 @@
BOOST_TEST(CompareIClTensorHandleShape(outputHandle, { 2, 4 }));
}
-BOOST_AUTO_TEST_CASE(CreateLSTMWorkloadFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateLSTMWorkloadFloatWorkload)
{
- ClCreateLstmWorkloadTest<ClLstmFloat32Workload>();
+ ClCreateLstmWorkloadTest<ClLstmFloatWorkload>();
}
diff --git a/src/armnn/backends/test/CreateWorkloadNeon.cpp b/src/armnn/backends/test/CreateWorkloadNeon.cpp
index b2a444a..d84b39b 100644
--- a/src/armnn/backends/test/CreateWorkloadNeon.cpp
+++ b/src/armnn/backends/test/CreateWorkloadNeon.cpp
@@ -69,13 +69,13 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateActivationFloat16Workload)
{
- NeonCreateActivationWorkloadTest<NeonActivationFloat32Workload, DataType::Float16>();
+ NeonCreateActivationWorkloadTest<NeonActivationFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreateActivationFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateActivationFloatWorkload)
{
- NeonCreateActivationWorkloadTest<NeonActivationFloat32Workload, DataType::Float32>();
+ NeonCreateActivationWorkloadTest<NeonActivationFloatWorkload, DataType::Float32>();
}
template <typename AdditionWorkloadType, typename armnn::DataType DataType>
@@ -98,13 +98,13 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateAdditionFloat16Workload)
{
- NeonCreateAdditionWorkloadTest<NeonAdditionFloat32Workload, DataType::Float16>();
+ NeonCreateAdditionWorkloadTest<NeonAdditionFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreateAdditionFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateAdditionFloatWorkload)
{
- NeonCreateAdditionWorkloadTest<NeonAdditionFloat32Workload, DataType::Float32>();
+ NeonCreateAdditionWorkloadTest<NeonAdditionFloatWorkload, DataType::Float32>();
}
template <typename BatchNormalizationWorkloadType, typename armnn::DataType DataType>
@@ -125,13 +125,13 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat16Workload)
{
- NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationFloat32Workload, DataType::Float16>();
+ NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateBatchNormalizationFloatWorkload)
{
- NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationFloat32Workload, DataType::Float32>();
+ NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationFloatWorkload, DataType::Float32>();
}
template <typename Convolution2dWorkloadType, typename armnn::DataType DataType>
@@ -153,13 +153,13 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat16Workload)
{
- NeonCreateConvolution2dWorkloadTest<NeonConvolution2dFloat32Workload, DataType::Float16>();
+ NeonCreateConvolution2dWorkloadTest<NeonConvolution2dFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreateConvolution2dFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateConvolution2dFloatWorkload)
{
- NeonCreateConvolution2dWorkloadTest<NeonConvolution2dFloat32Workload, DataType::Float32>();
+ NeonCreateConvolution2dWorkloadTest<NeonConvolution2dFloatWorkload, DataType::Float32>();
}
template <typename FullyConnectedWorkloadType, typename armnn::DataType DataType>
@@ -181,13 +181,13 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloat16Workload)
{
- NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedFloat32Workload, DataType::Float16>();
+ NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateFullyConnectedFloatWorkload)
{
- NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedFloat32Workload, DataType::Float32>();
+ NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedFloatWorkload, DataType::Float32>();
}
template <typename MultiplicationWorkloadType, typename armnn::DataType DataType>
@@ -211,13 +211,13 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat16Workload)
{
- NeonCreateMultiplicationWorkloadTest<NeonMultiplicationFloat32Workload, DataType::Float16>();
+ NeonCreateMultiplicationWorkloadTest<NeonMultiplicationFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateMultiplicationFloatWorkload)
{
- NeonCreateMultiplicationWorkloadTest<NeonMultiplicationFloat32Workload, DataType::Float32>();
+ NeonCreateMultiplicationWorkloadTest<NeonMultiplicationFloatWorkload, DataType::Float32>();
}
template <typename NormalizationWorkloadType, typename armnn::DataType DataType>
@@ -238,13 +238,13 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateNormalizationFloat16Workload)
{
- NeonCreateNormalizationWorkloadTest<NeonNormalizationFloat32Workload, DataType::Float16>();
+ NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreateNormalizationFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateNormalizationFloatWorkload)
{
- NeonCreateNormalizationWorkloadTest<NeonNormalizationFloat32Workload, DataType::Float32>();
+ NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>();
}
template <typename Pooling2dWorkloadType, typename armnn::DataType DataType>
@@ -266,13 +266,13 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreatePooling2dFloat16Workload)
{
- NeonCreatePooling2dWorkloadTest<NeonPooling2dFloat32Workload, DataType::Float16>();
+ NeonCreatePooling2dWorkloadTest<NeonPooling2dFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreatePooling2dFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreatePooling2dFloatWorkload)
{
- NeonCreatePooling2dWorkloadTest<NeonPooling2dFloat32Workload, DataType::Float32>();
+ NeonCreatePooling2dWorkloadTest<NeonPooling2dFloatWorkload, DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreatePooling2dUint8Workload)
@@ -298,13 +298,13 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateReshapeFloat16Workload)
{
- NeonCreateReshapeWorkloadTest<NeonReshapeFloat32Workload, DataType::Float16>();
+ NeonCreateReshapeWorkloadTest<NeonReshapeFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreateReshapeFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateReshapeFloatWorkload)
{
- NeonCreateReshapeWorkloadTest<NeonReshapeFloat32Workload, DataType::Float32>();
+ NeonCreateReshapeWorkloadTest<NeonReshapeFloatWorkload, DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateReshapeUint8Workload)
@@ -330,20 +330,20 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat16Workload)
{
- NeonCreateSoftmaxWorkloadTest<NeonSoftmaxFloat32Workload, DataType::Float16>();
+ NeonCreateSoftmaxWorkloadTest<NeonSoftmaxFloatWorkload, DataType::Float16>();
}
#endif
-BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat32Workload)
+BOOST_AUTO_TEST_CASE(CreateSoftmaxFloatWorkload)
{
- NeonCreateSoftmaxWorkloadTest<NeonSoftmaxFloat32Workload, DataType::Float32>();
+ NeonCreateSoftmaxWorkloadTest<NeonSoftmaxFloatWorkload, DataType::Float32>();
}
BOOST_AUTO_TEST_CASE(CreateSplitterWorkload)
{
Graph graph;
NeonWorkloadFactory factory;
- auto workload = CreateSplitterWorkloadTest<NeonSplitterFloat32Workload, DataType::Float32>(factory, graph);
+ auto workload = CreateSplitterWorkloadTest<NeonSplitterFloatWorkload, DataType::Float32>(factory, graph);
// Checks that outputs are as we expect them (see definition of CreateSplitterWorkloadTest).
SplitterQueueDescriptor queueDescriptor = workload->GetData();
@@ -372,7 +372,7 @@
NeonWorkloadFactory factory;
auto workloads =
- CreateSplitterMergerWorkloadTest<NeonSplitterFloat32Workload, NeonMergerFloat32Workload,
+ CreateSplitterMergerWorkloadTest<NeonSplitterFloatWorkload, NeonMergerFloatWorkload,
DataType::Float32>(factory, graph);
auto wlSplitter = std::move(workloads.first);
@@ -401,14 +401,14 @@
Graph graph;
NeonWorkloadFactory factory;
- std::unique_ptr<NeonSplitterFloat32Workload> wlSplitter;
- std::unique_ptr<NeonActivationFloat32Workload> wlActiv0_0;
- std::unique_ptr<NeonActivationFloat32Workload> wlActiv0_1;
- std::unique_ptr<NeonActivationFloat32Workload> wlActiv1_0;
- std::unique_ptr<NeonActivationFloat32Workload> wlActiv1_1;
+ std::unique_ptr<NeonSplitterFloatWorkload> wlSplitter;
+ std::unique_ptr<NeonActivationFloatWorkload> wlActiv0_0;
+ std::unique_ptr<NeonActivationFloatWorkload> wlActiv0_1;
+ std::unique_ptr<NeonActivationFloatWorkload> wlActiv1_0;
+ std::unique_ptr<NeonActivationFloatWorkload> wlActiv1_1;
- CreateSplitterMultipleInputsOneOutputWorkloadTest<NeonSplitterFloat32Workload,
- NeonActivationFloat32Workload, DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
+ CreateSplitterMultipleInputsOneOutputWorkloadTest<NeonSplitterFloatWorkload,
+ NeonActivationFloatWorkload, DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
wlActiv1_0, wlActiv1_1);
armnn::INeonTensorHandle* sOut0 = dynamic_cast<armnn::INeonTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);