patch/22.11/_neon_concat_workload_8cpp_source.xhtml

 //
 // Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //

 #include "NeonConcatWorkload.hpp"

 #include "NeonWorkloadUtils.hpp"

 #include <aclCommon/ArmComputeTensorUtils.hpp>
 #include <armnn/utility/PolymorphicDowncast.hpp>
 #include <armnn/backends/TensorHandle.hpp>
 #include <neon/NeonTensorHandle.hpp>

 namespace armnn
 {
 using namespace armcomputetensorutils;

 namespace
 {
 size_t CalcAxis(const armnn::OriginsDescriptor& descriptor)
 {
     return (descriptor.GetNumDimensions() - descriptor.GetConcatAxis()) - 1;
 }
 } //namespace

 arm_compute::Status NeonConcatWorkloadValidate(const std::vector<const TensorInfo*>& inputs,
                                                const TensorInfo& output,
                                                const OriginsDescriptor& descriptor)

 {
     std::vector<arm_compute::TensorInfo> aclInputs;
     for (const TensorInfo* input : inputs)
     {
         arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(*input, armnn::DataLayout::NCHW);
         aclInputs.emplace_back(aclInputInfo);
     }
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
     std::vector<const arm_compute::ITensorInfo*> aclInputPtrs;
     for (arm_compute::ITensorInfo& input : aclInputs)
     {
         aclInputPtrs.emplace_back(&input);
     }

     size_t aclAxis = CalcAxis(descriptor);
     return arm_compute::NEConcatenateLayer::validate(aclInputPtrs, &aclOutputInfo, aclAxis);
 }

 NeonConcatWorkload::NeonConcatWorkload(
 const ConcatQueueDescriptor& descriptor, const WorkloadInfo& info)
         : NeonBaseWorkload<ConcatQueueDescriptor>(descriptor, info)
 {
     // Report Profiling Details
     ARMNN_REPORT_PROFILING_WORKLOAD_DESC("NeonConcatWorkload_Construct",
                                          descriptor.m_Parameters,
                                          info,
                                          this->GetGuid());

     bool allInputsAreSubtensors = true;

     // Check that all inputs are sub-tensors
     for (auto input : descriptor.m_Inputs)
     {
         if (!input->GetParent())
         {
             // Non sub-tensor input found so we need to execute the concat function
             allInputsAreSubtensors = false;
             break;
         }
     }

     if (allInputsAreSubtensors)
     {
         // Can skip configuring the concat function since it's not executed
         return;
     }

     std::vector<const arm_compute::ITensor *> aclInputs;
     for (auto input : m_Data.m_Inputs)
     {
         arm_compute::ITensor& aclInput  = armnn::PolymorphicPointerDowncast<IAclTensorHandle>(input)->GetTensor();
         aclInputs.emplace_back(&aclInput);
     }
     arm_compute::ITensor& output = armnn::PolymorphicPointerDowncast<IAclTensorHandle>(
         m_Data.m_Outputs[0])->GetTensor();

     // Create the layer function
     m_Layer.reset(new arm_compute::NEConcatenateLayer());

     // Configure input and output tensors
     size_t aclAxis = CalcAxis(descriptor.m_Parameters);
     m_Layer->configure(aclInputs, &output, aclAxis);

     // Prepare
     m_Layer->prepare();
 }

 void NeonConcatWorkload::Execute() const
 {
     if (m_Layer)
     {
         ARMNN_SCOPED_PROFILING_EVENT_NEON_GUID("NeonConcatWorkload_Execute", this->GetGuid());
         m_Layer->run();
     }
 }

 } //namespace armnn

TensorHandle.hpp

+armnn::TensorInfo
Definition: Tensor.hpp:152

+NeonConcatWorkload.hpp

+armnn::NeonConcatWorkload::NeonConcatWorkload
NeonConcatWorkload(const ConcatQueueDescriptor &descriptor, const WorkloadInfo &info)
Definition: NeonConcatWorkload.cpp:49

+NeonTensorHandle.hpp

+armnn::BaseWorkload< ConcatQueueDescriptor >::GetGuid
arm::pipe::ProfilingGuid GetGuid() const final
Definition: Workload.hpp:61

+ArmComputeTensorUtils.hpp

+armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6

+armnn::QueueDescriptorWithParameters::m_Parameters
LayerDescriptor m_Parameters
Definition: WorkloadData.hpp:66

+armnn::ConcatQueueDescriptor
Definition: WorkloadData.hpp:130

+PolymorphicDowncast.hpp

+armnn::NeonBaseWorkload
Definition: NeonBaseWorkload.hpp:13

+armnn::BaseWorkload< ConcatQueueDescriptor >::m_Data
ConcatQueueDescriptor m_Data
Definition: Workload.hpp:83

+armnn::OriginsDescriptor
An OriginsDescriptor for the ConcatLayer.
Definition: Descriptors.hpp:174

+armnn::NeonConcatWorkload::Execute
void Execute() const override
Definition: NeonConcatWorkload.cpp:98

+armnn::Status
Status
enumeration
Definition: Types.hpp:42

+armnn::NeonConcatWorkloadValidate
arm_compute::Status NeonConcatWorkloadValidate(const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const OriginsDescriptor &descriptor)
Definition: NeonConcatWorkload.cpp:27

+NeonWorkloadUtils.hpp

+armnn::QueueDescriptor::m_Outputs
std::vector< ITensorHandle * > m_Outputs
Definition: WorkloadData.hpp:27

+armnn::BoostLogSeverityMapping::info

+armnn::OriginsDescriptor::GetNumDimensions
uint32_t GetNumDimensions() const
Get the number of dimensions.
Definition: Descriptors.cpp:192

+ARMNN_REPORT_PROFILING_WORKLOAD_DESC
#define ARMNN_REPORT_PROFILING_WORKLOAD_DESC(name, desc, infos, guid)
Definition: Profiling.hpp:227

+armnn::WorkloadInfo
Contains information about TensorInfos of a layer.
Definition: WorkloadInfo.hpp:16

+armnn::QueueDescriptor::m_Inputs
std::vector< ITensorHandle * > m_Inputs
Definition: WorkloadData.hpp:26

+armnn::DataLayout::NCHW

+armnn::OriginsDescriptor::GetConcatAxis
unsigned int GetConcatAxis() const
Get the concatenation axis value.
Definition: Descriptors.cpp:162

+ARMNN_SCOPED_PROFILING_EVENT_NEON_GUID
#define ARMNN_SCOPED_PROFILING_EVENT_NEON_GUID(name, guid)
Definition: NeonWorkloadUtils.hpp:24

+