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]);