#include "workloads/NeonL2NormalizationFloatWorkload.hpp"
#include "workloads/NeonMaximumWorkload.hpp"
#include "workloads/NeonMeanWorkload.hpp"
-#include "workloads/NeonMergerWorkload.hpp"
+#include "workloads/NeonConcatWorkload.hpp"
#include "workloads/NeonMinimumWorkload.hpp"
#include "workloads/NeonMultiplicationWorkload.hpp"
#include "workloads/NeonNormalizationFloatWorkload.hpp"
unsigned int concatInnerAxis = (descriptor.GetNumDimensions() - descriptor.GetConcatAxis()) - 1;
if(concatInnerAxis < 3) // Width, height, or channels
{
- FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMergerWorkloadValidate,
+ FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConcatWorkloadValidate,
reasonIfUnsupported,
inputs,
output,
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateMerger(const MergerQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return std::make_unique<NeonMergerWorkload>(descriptor, info);
+ return std::make_unique<NeonConcatWorkload>(descriptor, info);
}
std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateFullyConnected(
workloads/NeonActivationWorkload.cpp \
workloads/NeonAdditionWorkload.cpp \
workloads/NeonBatchNormalizationWorkload.cpp \
+ workloads/NeonConcatWorkload.cpp \
workloads/NeonConstantWorkload.cpp \
workloads/NeonConvertFp16ToFp32Workload.cpp \
workloads/NeonConvertFp32ToFp16Workload.cpp \
workloads/NeonLstmFloatWorkload.cpp \
workloads/NeonMaximumWorkload.cpp \
workloads/NeonMeanWorkload.cpp \
- workloads/NeonMergerWorkload.cpp \
workloads/NeonMinimumWorkload.cpp \
workloads/NeonMultiplicationWorkload.cpp \
workloads/NeonNormalizationFloatWorkload.cpp \
NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
auto workloads =
- CreateSplitterMergerWorkloadTest<NeonSplitterWorkload, NeonMergerWorkload,
+ CreateSplitterMergerWorkloadTest<NeonSplitterWorkload, NeonConcatWorkload,
DataType::Float32>(factory, graph);
auto wlSplitter = std::move(workloads.first);
BOOST_AUTO_TEST_CASE(CreateMergerDim0Float32Workload)
{
- NeonCreateMergerWorkloadTest<NeonMergerWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
+ NeonCreateMergerWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
}
BOOST_AUTO_TEST_CASE(CreateMergerDim1Float32Workload)
{
- NeonCreateMergerWorkloadTest<NeonMergerWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
+ NeonCreateMergerWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
}
BOOST_AUTO_TEST_CASE(CreateMergerDim3Float32Workload)
{
- NeonCreateMergerWorkloadTest<NeonMergerWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
+ NeonCreateMergerWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
}
BOOST_AUTO_TEST_CASE(CreateMergerDim0Uint8Workload)
{
- NeonCreateMergerWorkloadTest<NeonMergerWorkload, armnn::DataType::QuantisedAsymm8>({ 4, 3, 2, 5 }, 0);
+ NeonCreateMergerWorkloadTest<NeonConcatWorkload, armnn::DataType::QuantisedAsymm8>({ 4, 3, 2, 5 }, 0);
}
BOOST_AUTO_TEST_CASE(CreateMergerDim1Uint8Workload)
{
- NeonCreateMergerWorkloadTest<NeonMergerWorkload, armnn::DataType::QuantisedAsymm8>({ 2, 6, 2, 5 }, 1);
+ NeonCreateMergerWorkloadTest<NeonConcatWorkload, armnn::DataType::QuantisedAsymm8>({ 2, 6, 2, 5 }, 1);
}
BOOST_AUTO_TEST_CASE(CreateMergerDim3Uint8Workload)
{
- NeonCreateMergerWorkloadTest<NeonMergerWorkload, armnn::DataType::QuantisedAsymm8>({ 2, 3, 2, 10 }, 3);
+ NeonCreateMergerWorkloadTest<NeonConcatWorkload, armnn::DataType::QuantisedAsymm8>({ 2, 3, 2, 10 }, 3);
}
BOOST_AUTO_TEST_SUITE_END()
NeonAdditionWorkload.hpp
NeonBatchNormalizationWorkload.cpp
NeonBatchNormalizationWorkload.hpp
+ NeonConcatWorkload.cpp
+ NeonConcatWorkload.hpp
NeonConstantWorkload.cpp
NeonConstantWorkload.hpp
NeonConvertFp16ToFp32Workload.cpp
NeonMaximumWorkload.hpp
NeonMeanWorkload.cpp
NeonMeanWorkload.hpp
- NeonMergerWorkload.cpp
- NeonMergerWorkload.hpp
NeonMinimumWorkload.cpp
NeonMinimumWorkload.hpp
NeonMultiplicationWorkload.cpp
// SPDX-License-Identifier: MIT
//
-#include "NeonMergerWorkload.hpp"
+#include "NeonConcatWorkload.hpp"
#include "NeonWorkloadUtils.hpp"
}
} //namespace
-arm_compute::Status NeonMergerWorkloadValidate(const std::vector<const TensorInfo*>& inputs,
+arm_compute::Status NeonConcatWorkloadValidate(const std::vector<const TensorInfo*>& inputs,
const TensorInfo& output,
const MergerDescriptor& descriptor)
return arm_compute::NEConcatenateLayer::validate(aclInputPtrs, &aclOutputInfo, aclAxis);
}
-NeonMergerWorkload::NeonMergerWorkload(
+NeonConcatWorkload::NeonConcatWorkload(
const MergerQueueDescriptor& descriptor, const WorkloadInfo& info)
: BaseWorkload<MergerQueueDescriptor>(descriptor, info)
{
m_Layer->prepare();
}
-void NeonMergerWorkload::Execute() const
+void NeonConcatWorkload::Execute() const
{
if (m_Layer)
{
- ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonMergerWorkload_Execute");
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonConcatWorkload_Execute");
m_Layer->run();
}
}
namespace armnn
{
-arm_compute::Status NeonMergerWorkloadValidate(const std::vector<const TensorInfo*>& inputs,
+arm_compute::Status NeonConcatWorkloadValidate(const std::vector<const TensorInfo*>& inputs,
const TensorInfo& output,
const MergerDescriptor& descriptor);
-class NeonMergerWorkload : public BaseWorkload<MergerQueueDescriptor>
+class NeonConcatWorkload : public BaseWorkload<MergerQueueDescriptor>
{
public:
- NeonMergerWorkload(const MergerQueueDescriptor& descriptor, const WorkloadInfo& info);
+ NeonConcatWorkload(const MergerQueueDescriptor& descriptor, const WorkloadInfo& info);
using BaseWorkload<MergerQueueDescriptor>::BaseWorkload;
void Execute() const override;
#include "NeonLstmFloatWorkload.hpp"
#include "NeonMaximumWorkload.hpp"
#include "NeonMeanWorkload.hpp"
-#include "NeonMergerWorkload.hpp"
+#include "NeonConcatWorkload.hpp"
#include "NeonMinimumWorkload.hpp"
#include "NeonMultiplicationWorkload.hpp"
#include "NeonNormalizationFloatWorkload.hpp"