#include "workloads/NeonMeanWorkload.hpp"
#include "workloads/NeonMergerWorkload.hpp"
#include "workloads/NeonMinimumWorkload.hpp"
-#include "workloads/NeonMultiplicationFloatWorkload.hpp"
+#include "workloads/NeonMultiplicationWorkload.hpp"
#include "workloads/NeonNormalizationFloatWorkload.hpp"
#include "workloads/NeonFullyConnectedWorkload.hpp"
#include "workloads/NeonPadWorkload.hpp"
#include "workloads/NeonPooling2dWorkload.hpp"
#include "workloads/NeonResizeBilinearWorkload.hpp"
#include "workloads/NeonSoftmaxBaseWorkload.hpp"
-#include "workloads/NeonSubtractionFloatWorkload.hpp"
+#include "workloads/NeonSubtractionWorkload.hpp"
#endif
using namespace boost;
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateMultiplication(
const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkloadHelper<NeonMultiplicationFloatWorkload, NullWorkload>(descriptor, info);
+ return std::make_unique<NeonMultiplicationWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateDivision(
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateSubtraction(
const SubtractionQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
- return MakeWorkloadHelper<NeonSubtractionFloatWorkload, NullWorkload>(descriptor, info);
+ return std::make_unique<NeonSubtractionWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateBatchNormalization(
workloads/NeonMeanWorkload.cpp \
workloads/NeonMergerWorkload.cpp \
workloads/NeonMinimumWorkload.cpp \
- workloads/NeonMultiplicationFloatWorkload.cpp \
+ workloads/NeonMultiplicationWorkload.cpp \
workloads/NeonNormalizationFloatWorkload.cpp \
workloads/NeonPadWorkload.cpp \
workloads/NeonPermuteWorkload.cpp \
workloads/NeonSoftmaxBaseWorkload.cpp \
workloads/NeonSoftmaxFloatWorkload.cpp \
workloads/NeonSoftmaxUint8Workload.cpp \
- workloads/NeonSubtractionFloatWorkload.cpp
+ workloads/NeonSubtractionWorkload.cpp
else
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateSubtractionFloat16Workload)
{
- NeonCreateElementwiseWorkloadTest<NeonSubtractionFloatWorkload,
+ NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
SubtractionQueueDescriptor,
SubtractionLayer,
DataType::Float16>();
BOOST_AUTO_TEST_CASE(CreateSubtractionFloatWorkload)
{
- NeonCreateElementwiseWorkloadTest<NeonSubtractionFloatWorkload,
+ NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
SubtractionQueueDescriptor,
SubtractionLayer,
DataType::Float32>();
}
+BOOST_AUTO_TEST_CASE(CreateSubtractionUint8Workload)
+{
+ NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
+ SubtractionQueueDescriptor,
+ SubtractionLayer,
+ DataType::QuantisedAsymm8>();
+}
+
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
BOOST_AUTO_TEST_CASE(CreateMultiplicationFloat16Workload)
{
- NeonCreateElementwiseWorkloadTest<NeonMultiplicationFloatWorkload,
+ NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
MultiplicationQueueDescriptor,
MultiplicationLayer,
DataType::Float16>();
BOOST_AUTO_TEST_CASE(CreateMultiplicationFloatWorkload)
{
- NeonCreateElementwiseWorkloadTest<NeonMultiplicationFloatWorkload,
+ NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
MultiplicationQueueDescriptor,
MultiplicationLayer,
DataType::Float32>();
}
+BOOST_AUTO_TEST_CASE(CreateMultiplicationUint8Workload)
+{
+ NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
+ MultiplicationQueueDescriptor,
+ MultiplicationLayer,
+ DataType::QuantisedAsymm8>();
+}
+
template <typename BatchNormalizationWorkloadType, typename armnn::DataType DataType>
static void NeonCreateBatchNormalizationWorkloadTest(DataLayout dataLayout)
{
ARMNN_AUTO_TEST_CASE(SimpleSub, SubtractionTest)
ARMNN_AUTO_TEST_CASE(SubBroadcast1Element, SubtractionBroadcast1ElementTest)
ARMNN_AUTO_TEST_CASE(SubBroadcast, SubtractionBroadcastTest)
+ARMNN_AUTO_TEST_CASE(SubtractionUint8, SubtractionUint8Test)
+ARMNN_AUTO_TEST_CASE(SubBroadcastUint8, SubtractionBroadcastUint8Test)
+ARMNN_AUTO_TEST_CASE(SubBroadcast1ElementUint8, SubtractionBroadcast1ElementUint8Test)
// Mul
ARMNN_AUTO_TEST_CASE(SimpleMultiplication, MultiplicationTest)
ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1Element, MultiplicationBroadcast1ElementTest)
ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1DVector, MultiplicationBroadcast1DVectorTest)
+ARMNN_AUTO_TEST_CASE(MultiplicationUint8, MultiplicationUint8Test)
+ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1ElementUint8, MultiplicationBroadcast1ElementUint8Test)
+ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1DVectorUint8, MultiplicationBroadcast1DVectorUint8Test)
// Batch Norm
ARMNN_AUTO_TEST_CASE(BatchNorm, BatchNormTest)
NeonMergerWorkload.hpp
NeonMinimumWorkload.cpp
NeonMinimumWorkload.hpp
- NeonMultiplicationFloatWorkload.cpp
- NeonMultiplicationFloatWorkload.hpp
+ NeonMultiplicationWorkload.cpp
+ NeonMultiplicationWorkload.hpp
NeonNormalizationFloatWorkload.cpp
NeonNormalizationFloatWorkload.hpp
NeonPadWorkload.cpp
NeonSoftmaxUint8Workload.cpp
NeonSoftmaxUint8Workload.hpp
NeonSplitterWorkload.hpp
- NeonSubtractionFloatWorkload.cpp
- NeonSubtractionFloatWorkload.hpp
+ NeonSubtractionWorkload.cpp
+ NeonSubtractionWorkload.hpp
NeonWorkloads.hpp
NeonWorkloadUtils.hpp
)
// SPDX-License-Identifier: MIT
//
-#include "NeonMultiplicationFloatWorkload.hpp"
+#include "NeonMultiplicationWorkload.hpp"
#include "NeonWorkloadUtils.hpp"
arm_compute::RoundingPolicy::TO_ZERO);
}
-NeonMultiplicationFloatWorkload::NeonMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor,
- const WorkloadInfo& info)
- : FloatWorkload<MultiplicationQueueDescriptor>(descriptor, info)
+NeonMultiplicationWorkload::NeonMultiplicationWorkload(const MultiplicationQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
+ : BaseWorkload<MultiplicationQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("NeonMultiplicationFloatWorkload", 2, 1);
+ m_Data.ValidateInputsOutputs("NeonMultiplicationWorkload", 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();
m_PixelWiseMultiplication.reset(layer.release());
}
-void NeonMultiplicationFloatWorkload::Execute() const
+void NeonMultiplicationWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMultiplicationFloatWorkload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMultiplicationWorkload_Execute");
m_PixelWiseMultiplication->run();
}
} //namespace armnn
-
-
const TensorInfo& input1,
const TensorInfo& output);
-class NeonMultiplicationFloatWorkload : public FloatWorkload<MultiplicationQueueDescriptor>
+class NeonMultiplicationWorkload : public BaseWorkload<MultiplicationQueueDescriptor>
{
public:
- NeonMultiplicationFloatWorkload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonMultiplicationWorkload(const MultiplicationQueueDescriptor& descriptor, const WorkloadInfo& info);
virtual void Execute() const override;
private:
};
} //namespace armnn
-
-
-
-
// SPDX-License-Identifier: MIT
//
-#include "NeonSubtractionFloatWorkload.hpp"
+#include "NeonSubtractionWorkload.hpp"
#include "NeonWorkloadUtils.hpp"
#include <aclCommon/ArmComputeTensorUtils.hpp>
arm_compute::ConvertPolicy::SATURATE);
}
-NeonSubtractionFloatWorkload::NeonSubtractionFloatWorkload(const SubtractionQueueDescriptor& descriptor,
- const WorkloadInfo& info)
- : FloatWorkload<SubtractionQueueDescriptor>(descriptor, info)
+NeonSubtractionWorkload::NeonSubtractionWorkload(const SubtractionQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
+ : BaseWorkload<SubtractionQueueDescriptor>(descriptor, info)
{
- m_Data.ValidateInputsOutputs("NeonSubtractionFloatWorkload", 2, 1);
+ m_Data.ValidateInputsOutputs("NeonSubtractionWorkload", 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();
m_SubLayer.reset(layer.release());
}
-void NeonSubtractionFloatWorkload::Execute() const
+void NeonSubtractionWorkload::Execute() const
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSubtractionFloatWorkload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonSubtractionWorkload_Execute");
m_SubLayer->run();
}
const TensorInfo& input1,
const TensorInfo& output);
-class NeonSubtractionFloatWorkload : public FloatWorkload<SubtractionQueueDescriptor>
+class NeonSubtractionWorkload : public BaseWorkload<SubtractionQueueDescriptor>
{
public:
- NeonSubtractionFloatWorkload(const SubtractionQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonSubtractionWorkload(const SubtractionQueueDescriptor& descriptor, const WorkloadInfo& info);
virtual void Execute() const override;
private:
#include "NeonMeanWorkload.hpp"
#include "NeonMergerWorkload.hpp"
#include "NeonMinimumWorkload.hpp"
-#include "NeonMultiplicationFloatWorkload.hpp"
+#include "NeonMultiplicationWorkload.hpp"
#include "NeonNormalizationFloatWorkload.hpp"
#include "NeonPadWorkload.hpp"
#include "NeonPermuteWorkload.hpp"
#include "NeonSoftmaxFloatWorkload.hpp"
#include "NeonSoftmaxUint8Workload.hpp"
#include "NeonSplitterWorkload.hpp"
-#include "NeonSubtractionFloatWorkload.hpp"
+#include "NeonSubtractionWorkload.hpp"