#include <NeonBackend.hpp>

Inheritance diagram for NeonBackend:

Public Member Functions
	NeonBackend ()=default

	~NeonBackend ()=default

const BackendId &	GetId () const override

IBackendInternal::IMemoryManagerUniquePtr	CreateMemoryManager () const override

IWorkloadFactoryPtr	CreateWorkloadFactory (const IBackendInternal::IMemoryManagerSharedPtr &memoryManager=nullptr) const override

IWorkloadFactoryPtr	CreateWorkloadFactory (class TensorHandleFactoryRegistry &tensorHandleFactoryRegistry) const override

IWorkloadFactoryPtr	CreateWorkloadFactory (const IMemoryManagerSharedPtr &memoryManager, const ModelOptions &modelOptions) const override

IWorkloadFactoryPtr	CreateWorkloadFactory (class TensorHandleFactoryRegistry &tensorHandleFactoryRegistry, const ModelOptions &modelOptions) const override

IBackendInternal::IBackendContextPtr	CreateBackendContext (const IRuntime::CreationOptions &) const override
	Create the runtime context of the backend. More...

IBackendInternal::IBackendProfilingContextPtr	CreateBackendProfilingContext (const IRuntime::CreationOptions &, IBackendProfilingPtr &backendProfiling) override
	Create context specifically used for profiling interaction from backends. More...

IBackendInternal::Optimizations	GetOptimizations () const override

IBackendInternal::ILayerSupportSharedPtr	GetLayerSupport () const override

IBackendInternal::ILayerSupportSharedPtr	GetLayerSupport (const ModelOptions &modelOptions) const override

OptimizationViews	OptimizeSubgraphView (const SubgraphView &subgraph) const override

std::vector< ITensorHandleFactory::FactoryId >	GetHandleFactoryPreferences () const override
	(Optional) Returns a vector of supported TensorHandleFactory ids in preference order. More...

void	RegisterTensorHandleFactories (class TensorHandleFactoryRegistry &registry) override
	(Optional) Register TensorHandleFactories Either this method or CreateMemoryManager() and IWorkloadFactory::CreateTensor()/IWorkloadFactory::CreateSubtensor() methods must be implemented. More...

IBackendInternal::IBackendSpecificModelContextPtr	CreateBackendSpecificModelContext (const ModelOptions &modelOptions) const override

BackendCapabilities	GetCapabilities () const override
	Returns a BackendCapability if the backend lists the capability The BackendCapability must then be inspected to check whether or not that BackendCapability is supported Otherwise returns an EmptyOptional if the BackendCapability is unlisted. More...

Public Member Functions inherited from IBackendInternal
	~IBackendInternal () override=default
	Allow backends created by the factory function to be destroyed through IBackendInternal. More...

virtual ISubGraphConverterPtr	CreateSubGraphConverter (const std::shared_ptr< SubGraph > &subGraph) const

virtual SubGraphUniquePtr	OptimizeSubGraph (const SubGraph &subGraph, bool &optimizationAttempted) const

virtual IWorkloadFactoryPtr	CreateWorkloadFactory (class TensorHandleFactoryRegistry &tensorHandleFactoryRegistry, const ModelOptions &modelOptions, MemorySourceFlags inputFlags, MemorySourceFlags outputFlags) const

virtual OptimizationViews	OptimizeSubgraphView (const SubgraphView &subgraph, const ModelOptions &modelOptions) const

bool	SupportsTensorAllocatorAPI () const

ITensorHandleFactory::FactoryId	GetBackwardCompatibleFavoriteHandleFactory ()

virtual void	RegisterTensorHandleFactories (class TensorHandleFactoryRegistry &registry, MemorySourceFlags inputFlags, MemorySourceFlags outputFlags)
	(Optional) Register TensorHandleFactories Either this method or CreateMemoryManager() and IWorkloadFactory::CreateTensor()/IWorkloadFactory::CreateSubtensor() methods must be implemented. More...

virtual bool	HasCapability (BackendCapability) const
	Returns true if backend support the capability false otherwise. More...

virtual bool	UseCustomMemoryAllocator (std::shared_ptr< ICustomAllocator > allocator, armnn::Optional< std::string &> errMsg)
	Signals the backend to use a custom memory allocator provided by the user. More...

Static Public Member Functions
static const BackendId &	GetIdStatic ()

Static Public Member Functions inherited from IBackendInternal
static constexpr BackendVersion	GetApiVersion ()
	Returns the version of the Backend API. More...

Additional Inherited Members
Public Types inherited from IBackendInternal
using	IWorkloadFactoryPtr = std::unique_ptr< IWorkloadFactory >

using	IBackendContextPtr = std::unique_ptr< IBackendContext >

using	IBackendProfilingContextPtr = std::shared_ptr< armnn::profiling::IBackendProfilingContext >
	This is the bridge between backend and backend profiling we'll keep it in the backend namespace. More...

using	IBackendProfilingPtr = std::unique_ptr< armnn::profiling::IBackendProfiling >

using	OptimizationPtr = std::unique_ptr< Optimization >

using	Optimizations = std::vector< OptimizationPtr >

using	ILayerSupportSharedPtr = std::shared_ptr< ILayerSupport >

using	IBackendSpecificModelContextPtr = std::shared_ptr< IBackendModelContext >

using	IMemoryManagerUniquePtr = std::unique_ptr< IMemoryManager >

using	IMemoryManagerSharedPtr = std::shared_ptr< IMemoryManager >

using	GraphUniquePtr = std::unique_ptr< Graph >

using	SubgraphViewUniquePtr = std::unique_ptr< SubgraphView >

using	supported = std::unique_ptr< ISubGraphConverter >

using	instead = std::unique_ptr< SubGraph >

Protected Member Functions inherited from IBackendInternal
	IBackendInternal ()=default
	Creation must be done through a specific backend interface. More...

Protected Member Functions inherited from IBackend
	IBackend ()

virtual	~IBackend ()

Detailed Description

Definition at line 20 of file NeonBackend.hpp.

Constructor & Destructor Documentation

◆ NeonBackend()

NeonBackend ( )

default

◆ ~NeonBackend()

~NeonBackend ( )

default

Member Function Documentation

◆ CreateBackendContext()

IBackendInternal::IBackendContextPtr CreateBackendContext ( const IRuntime::CreationOptions & ) const

overridevirtual

Create the runtime context of the backend.

Implementations may return a default-constructed IBackendContextPtr if no context is needed at runtime. Implementations must throw BackendUnavailableException if the backend cannot be used (for example, necessary accelerator hardware is not present). The default implementation always returns a default-constructed pointer.

Reimplemented from IBackendInternal.

Definition at line 95 of file NeonBackend.cpp.

Referenced by NeonBackend::GetId().

 {
     return IBackendContextPtr{};
 }

◆ CreateBackendProfilingContext()

IBackendInternal::IBackendProfilingContextPtr CreateBackendProfilingContext	(	const IRuntime::CreationOptions &	creationOptions,
		IBackendProfilingPtr &	backendProfiling
	)

overridevirtual

Create context specifically used for profiling interaction from backends.

Reimplemented from IBackendInternal.

Definition at line 100 of file NeonBackend.cpp.

Referenced by NeonBackend::GetId().

 {
     return IBackendProfilingContextPtr{};
 }

◆ CreateBackendSpecificModelContext()

IBackendInternal::IBackendSpecificModelContextPtr CreateBackendSpecificModelContext ( const ModelOptions & modelOptions ) const

overridevirtual

Reimplemented from IBackendInternal.

Definition at line 111 of file NeonBackend.cpp.

Referenced by NeonBackend::CreateWorkloadFactory(), NeonBackend::GetId(), and NeonBackend::GetLayerSupport().

 {
     return IBackendSpecificModelContextPtr{new NeonBackendModelContext{modelOptions}};
 }

◆ CreateMemoryManager()

IBackendInternal::IMemoryManagerUniquePtr CreateMemoryManager ( ) const

overridevirtual

Reimplemented from IBackendInternal.

Definition at line 49 of file NeonBackend.cpp.

References BaseMemoryManager::Offset.

Referenced by NeonBackend::GetId().

 {
     return std::make_unique<NeonMemoryManager>(std::make_unique<arm_compute::Allocator>(),
                                                BaseMemoryManager::MemoryAffinity::Offset);
 }

◆ CreateWorkloadFactory() [1/4]

IBackendInternal::IWorkloadFactoryPtr CreateWorkloadFactory ( const IBackendInternal::IMemoryManagerSharedPtr & memoryManager = nullptr ) const

overridevirtual

Implements IBackendInternal.

Definition at line 55 of file NeonBackend.cpp.

Referenced by NeonBackend::GetId().

 {
     return std::make_unique<NeonWorkloadFactory>(
         PolymorphicPointerDowncast<NeonMemoryManager>(memoryManager));
 }

◆ CreateWorkloadFactory() [2/4]

IBackendInternal::IWorkloadFactoryPtr CreateWorkloadFactory ( class TensorHandleFactoryRegistry & tensorHandleFactoryRegistry ) const

overridevirtual

Reimplemented from IBackendInternal.

Definition at line 69 of file NeonBackend.cpp.

References BaseMemoryManager::Offset, TensorHandleFactoryRegistry::RegisterFactory(), and TensorHandleFactoryRegistry::RegisterMemoryManager().

 {
     auto memoryManager = std::make_shared<NeonMemoryManager>(std::make_unique<arm_compute::Allocator>(),
                                                              BaseMemoryManager::MemoryAffinity::Offset);
 
     tensorHandleFactoryRegistry.RegisterMemoryManager(memoryManager);
     tensorHandleFactoryRegistry.RegisterFactory(std::make_unique<NeonTensorHandleFactory>(memoryManager));
 
     return std::make_unique<NeonWorkloadFactory>(
         PolymorphicPointerDowncast<NeonMemoryManager>(memoryManager));
 }

◆ CreateWorkloadFactory() [3/4]

IBackendInternal::IWorkloadFactoryPtr CreateWorkloadFactory	(	const IMemoryManagerSharedPtr &	memoryManager,
		const ModelOptions &	modelOptions
	)		const

overridevirtual

Reimplemented from IBackendInternal.

Definition at line 62 of file NeonBackend.cpp.

References NeonBackend::CreateBackendSpecificModelContext().

 {
     return std::make_unique<NeonWorkloadFactory>(
         PolymorphicPointerDowncast<NeonMemoryManager>(memoryManager), CreateBackendSpecificModelContext(modelOptions));
 }

◆ CreateWorkloadFactory() [4/4]

IBackendInternal::IWorkloadFactoryPtr CreateWorkloadFactory	(	class TensorHandleFactoryRegistry &	tensorHandleFactoryRegistry,
		const ModelOptions &	modelOptions
	)		const

overridevirtual

Reimplemented from IBackendInternal.

Definition at line 82 of file NeonBackend.cpp.

References NeonBackend::CreateBackendSpecificModelContext(), BaseMemoryManager::Offset, TensorHandleFactoryRegistry::RegisterFactory(), and TensorHandleFactoryRegistry::RegisterMemoryManager().

 {
     auto memoryManager = std::make_shared<NeonMemoryManager>(std::make_unique<arm_compute::Allocator>(),
                                                              BaseMemoryManager::MemoryAffinity::Offset);
 
     tensorHandleFactoryRegistry.RegisterMemoryManager(memoryManager);
     tensorHandleFactoryRegistry.RegisterFactory(std::make_unique<NeonTensorHandleFactory>(memoryManager));
 
     return std::make_unique<NeonWorkloadFactory>(
         PolymorphicPointerDowncast<NeonMemoryManager>(memoryManager), CreateBackendSpecificModelContext(modelOptions));
 }

◆ GetCapabilities()

BackendCapabilities GetCapabilities ( ) const

inlineoverridevirtual

Returns a BackendCapability if the backend lists the capability The BackendCapability must then be inspected to check whether or not that BackendCapability is supported Otherwise returns an EmptyOptional if the BackendCapability is unlisted.

Reimplemented from IBackendInternal.

Definition at line 59 of file NeonBackend.hpp.

References armnn::cpuAccCapabilities.

     {
         return cpuAccCapabilities;
     };

◆ GetHandleFactoryPreferences()

std::vector< ITensorHandleFactory::FactoryId > GetHandleFactoryPreferences ( ) const

overridevirtual

(Optional) Returns a vector of supported TensorHandleFactory ids in preference order.

Reimplemented from IBackendInternal.

Definition at line 421 of file NeonBackend.cpp.

References NeonTensorHandleFactory::GetIdStatic().

Referenced by NeonBackend::GetId().

 {
     return std::vector<ITensorHandleFactory::FactoryId>() = { NeonTensorHandleFactory::GetIdStatic() };
 }

◆ GetId()

const BackendId& GetId ( ) const

inlineoverridevirtual

Implements IBackend.

Definition at line 27 of file NeonBackend.hpp.

References NeonBackend::CreateBackendContext(), NeonBackend::CreateBackendProfilingContext(), NeonBackend::CreateBackendSpecificModelContext(), NeonBackend::CreateMemoryManager(), NeonBackend::CreateWorkloadFactory(), NeonBackend::GetHandleFactoryPreferences(), NeonBackend::GetIdStatic(), NeonBackend::GetLayerSupport(), NeonBackend::GetOptimizations(), NeonBackend::OptimizeSubgraphView(), and NeonBackend::RegisterTensorHandleFactories().

27 { return GetIdStatic(); }

armnn::NeonBackend::GetIdStatic

static const BackendId & GetIdStatic()

Definition: NeonBackend.cpp:43

◆ GetIdStatic()

const BackendId & GetIdStatic ( )

static

Definition at line 43 of file NeonBackend.cpp.

References armnn::NeonBackendId().

Referenced by NeonBackend::GetId().

 {
     static const BackendId s_Id{NeonBackendId()};
     return s_Id;
 }

◆ GetLayerSupport() [1/2]

IBackendInternal::ILayerSupportSharedPtr GetLayerSupport ( ) const

overridevirtual

Implements IBackendInternal.

Definition at line 117 of file NeonBackend.cpp.

Referenced by NeonBackend::GetId().

 {
     static ILayerSupportSharedPtr layerSupport
         {
             new NeonLayerSupport(IBackendInternal::IBackendSpecificModelContextPtr{})
         };
     return layerSupport;
 }

◆ GetLayerSupport() [2/2]

IBackendInternal::ILayerSupportSharedPtr GetLayerSupport ( const ModelOptions & modelOptions ) const

overridevirtual

Reimplemented from IBackendInternal.

Definition at line 126 of file NeonBackend.cpp.

References NeonBackend::CreateBackendSpecificModelContext().

 {
     static ILayerSupportSharedPtr layerSupport
         {
             new NeonLayerSupport(CreateBackendSpecificModelContext(modelOptions))
         };
     return layerSupport;
 }

◆ GetOptimizations()

IBackendInternal::Optimizations GetOptimizations ( ) const

overridevirtual

Reimplemented from IBackendInternal.

Definition at line 106 of file NeonBackend.cpp.

Referenced by NeonBackend::GetId().

 {
     return Optimizations{};
 }

◆ OptimizeSubgraphView()

OptimizationViews OptimizeSubgraphView ( const SubgraphView & subgraph ) const

overridevirtual

Reimplemented from IBackendInternal.

Definition at line 135 of file NeonBackend.cpp.

References armnn::Activation, armnn::Addition, OptimizationViews::AddUntouchedSubgraph(), armnn::BatchNormalization, SubgraphView::begin(), Layer::BeginOutputSlots(), armnn::Convolution2d, armnn::DepthwiseConvolution2d, armnn::Division, SubgraphView::end(), Layer::EndOutputSlots(), armnn::FullyConnected, Layer::GetAdditionalInformation(), InputSlot::GetConnectedOutputSlot(), Layer::GetGuid(), Layer::GetInputSlot(), Layer::GetName(), LayerWithParameters< Parameters >::GetParameters(), OptimizationViews::GetSubstitutions(), OutputSlot::GetTensorInfo(), Layer::GetType(), BatchNormalizationLayer::m_Beta, DepthwiseConvolution2dLayer::m_Bias, Convolution2dLayer::m_Bias, FullyConnectedLayer::m_Bias, Convolution2dDescriptor::m_BiasEnabled, DepthwiseConvolution2dDescriptor::m_BiasEnabled, BatchNormalizationLayer::m_Gamma, BatchNormalizationLayer::m_Mean, BatchNormalizationLayer::m_Variance, DepthwiseConvolution2dLayer::m_Weight, Convolution2dLayer::m_Weight, FullyConnectedLayer::m_Weight, armnn::Multiplication, armnn::NeonAdditionWorkloadValidate(), armnn::NeonBatchNormalizationValidate(), armnn::NeonConvolution2dWorkloadValidate(), armnn::NeonDepthwiseConvolutionWorkloadValidate(), armnn::NeonDivisionWorkloadValidate(), armnn::NeonFullyConnectedWorkloadValidate(), armnn::NeonMultiplicationWorkloadValidate(), armnn::NeonSubtractionWorkloadValidate(), armnn::Reduce, armnn::ReportUntouchedLayers(), and armnn::Subtraction.

Referenced by NeonBackend::GetId().

 {
     OptimizationViews optimizationViews;
 
     auto it = subgraph.end();
     std::map<LayerGuid, Layer*> untouched;
 
     while (it != subgraph.begin())
     {
         --it;
         Layer& base = **it;
         untouched.insert({base.GetGuid(), &base});
     }
 
     it = subgraph.end();
     while (it != subgraph.begin())
     {
         --it;
         Layer& base = **it;
 
         // Fuse activation into previous layer if supported by backend
         if ((base.GetType() == LayerType::DepthwiseConvolution2d || base.GetType() == LayerType::Convolution2d
              || base.GetType() == LayerType::BatchNormalization || base.GetType() == LayerType::FullyConnected
              || base.GetType() == LayerType::Addition || base.GetType() == LayerType::Multiplication
              || base.GetType() == LayerType::Subtraction || base.GetType() == LayerType::Division)
             && (base.GetAdditionalInformation<ActivationDescriptor>() == nullptr))
         {
             for (auto output = base.BeginOutputSlots(); output != base.EndOutputSlots(); ++output)
             {
                 if (output->GetNumConnections() == 1)
                 {
                     for (auto&& childInput : output->GetConnections())
                     {
                         if ((childInput->GetOwningLayer().GetType() == LayerType::Activation) &&
                             (checkDataTypeInputandOutput(childInput->GetOwningLayer())))
                         {
                             Layer& child = childInput->GetOwningLayer();
 
                             auto* activationLayer = PolymorphicDowncast<ActivationLayer*>(&child);
 
                             const std::string name = std::string("fused-") + child.GetName() + std::string("-into-") +
                                                      base.GetName();
 
                             // Get params from activation layer
                             ActivationDescriptor activationDesc = activationLayer->GetParameters();
 
                             if (base.GetType() == LayerType::Convolution2d)
                             {
                                 Convolution2dLayer* baseLayer = PolymorphicDowncast<Convolution2dLayer*>(&base);
 
                                 Optional<TensorInfo> biases;
 
                                 if (baseLayer->GetParameters().m_BiasEnabled)
                                 {
                                     biases = baseLayer->m_Bias->GetTensorInfo();
                                 }
 
                                 arm_compute::Status status = NeonConvolution2dWorkloadValidate(
                                         baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         baseLayer->GetParameters(),
                                         baseLayer->m_Weight->GetTensorInfo(),
                                         biases,
                                         false,
                                         &activationDesc);
 
                                 if (status)
                                 {
                                     FuseLayerWithWeightsAndBiases<Convolution2dLayer>(optimizationViews,
                                                                                       baseLayer,
                                                                                       activationLayer,
                                                                                       activationDesc,
                                                                                       name);
                                     untouched.erase(baseLayer->GetGuid());
                                     untouched.erase(activationLayer->GetGuid());
                                 }
                             }
                             else if (base.GetType() == LayerType::DepthwiseConvolution2d)
                             {
                                 DepthwiseConvolution2dLayer* baseLayer =
                                         PolymorphicDowncast<DepthwiseConvolution2dLayer*>(&base);
 
                                 Optional<TensorInfo> biases;
 
                                 if (baseLayer->GetParameters().m_BiasEnabled)
                                 {
                                     biases = baseLayer->m_Bias->GetTensorInfo();
                                 }
 
                                 arm_compute::Status status = NeonDepthwiseConvolutionWorkloadValidate(
                                         baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         baseLayer->GetParameters(),
                                         baseLayer->m_Weight->GetTensorInfo(),
                                         biases,
                                         &activationDesc);
 
                                 if (status)
                                 {
                                     FuseLayerWithWeightsAndBiases<DepthwiseConvolution2dLayer>(optimizationViews,
                                                                                                baseLayer,
                                                                                                activationLayer,
                                                                                                activationDesc,
                                                                                                name);
                                     untouched.erase(baseLayer->GetGuid());
                                     untouched.erase(activationLayer->GetGuid());
                                 }
                             }
                             else if (base.GetType() == LayerType::FullyConnected)
                             {
                                 FullyConnectedLayer* baseLayer = PolymorphicDowncast<FullyConnectedLayer*>(&base);
 
                                 arm_compute::Status status = NeonFullyConnectedWorkloadValidate(
                                         baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         baseLayer->m_Weight->GetTensorInfo(),
                                         baseLayer->m_Bias->GetTensorInfo(),
                                         baseLayer->GetParameters(),
                                         &activationDesc);
 
                                 if (status)
                                 {
                                     FuseLayerWithWeightsAndBiases<FullyConnectedLayer>(optimizationViews,
                                                                                        baseLayer,
                                                                                        activationLayer,
                                                                                        activationDesc,
                                                                                        name);
                                     untouched.erase(baseLayer->GetGuid());
                                     untouched.erase(activationLayer->GetGuid());
                                 }
                             }
                             else if (base.GetType() == LayerType::BatchNormalization)
                             {
                                 BatchNormalizationLayer* baseLayer =
                                         PolymorphicDowncast<BatchNormalizationLayer*>(&base);
 
                                 arm_compute::Status status = NeonBatchNormalizationValidate(
                                         baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         baseLayer->m_Mean->GetTensorInfo(),
                                         baseLayer->m_Variance->GetTensorInfo(),
                                         baseLayer->m_Beta->GetTensorInfo(),
                                         baseLayer->m_Gamma->GetTensorInfo(),
                                         baseLayer->GetParameters(),
                                         &activationDesc);
 
                                 if (status)
                                 {
                                     BatchNormalizationLayer* replacementLayer =
                                             FuseLayerWithParameters<BatchNormalizationLayer>(
                                                     optimizationViews,
                                                     baseLayer,
                                                     activationLayer,
                                                     activationDesc,
                                                     name);
 
                                     replacementLayer->m_Beta     = std::move(baseLayer->m_Beta);
                                     replacementLayer->m_Gamma    = std::move(baseLayer->m_Gamma);
                                     replacementLayer->m_Mean     = std::move(baseLayer->m_Mean);
                                     replacementLayer->m_Variance = std::move(baseLayer->m_Variance);
                                     untouched.erase(baseLayer->GetGuid());
                                     untouched.erase(activationLayer->GetGuid());
                                 }
                             }
                             else if (base.GetType() == LayerType::Addition)
                             {
                                 AdditionLayer* baseLayer = PolymorphicDowncast<AdditionLayer*>(&base);
 
                                 arm_compute::Status status = NeonAdditionWorkloadValidate(
                                         baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
                                         activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         &activationDesc);
 
                                 if (status)
                                 {
                                     FuseLayerWithoutParameters<AdditionLayer>(optimizationViews,
                                                                               baseLayer,
                                                                               activationLayer,
                                                                               activationDesc,
                                                                               name);
                                     untouched.erase(baseLayer->GetGuid());
                                     untouched.erase(activationLayer->GetGuid());
                                 }
                             }
                             else if (base.GetType() == LayerType::Division)
                             {
                                 DivisionLayer* baseLayer = PolymorphicDowncast<DivisionLayer*>(&base);
 
                                 arm_compute::Status status = NeonDivisionWorkloadValidate(
                                         baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
                                         activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         &activationDesc);
 
                                 if (status)
                                 {
                                     FuseLayerWithoutParameters<DivisionLayer>(optimizationViews,
                                                                               baseLayer,
                                                                               activationLayer,
                                                                               activationDesc,
                                                                               name);
                                     untouched.erase(baseLayer->GetGuid());
                                     untouched.erase(activationLayer->GetGuid());
                                 }
                             }
                             else if (base.GetType() == LayerType::Multiplication)
                             {
                                 MultiplicationLayer* baseLayer = PolymorphicDowncast<MultiplicationLayer*>(&base);
 
                                 arm_compute::Status status = NeonMultiplicationWorkloadValidate(
                                         baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
                                         activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         &activationDesc);
 
                                 if (status)
                                 {
                                     FuseLayerWithoutParameters<MultiplicationLayer>(optimizationViews,
                                                                                     baseLayer,
                                                                                     activationLayer,
                                                                                     activationDesc,
                                                                                     name);
                                     untouched.erase(baseLayer->GetGuid());
                                     untouched.erase(activationLayer->GetGuid());
                                 }
                             }
                             else if (base.GetType() == LayerType::Subtraction)
                             {
                                 SubtractionLayer* baseLayer = PolymorphicDowncast<SubtractionLayer*>(&base);
 
                                 arm_compute::Status status = NeonSubtractionWorkloadValidate(
                                         baseLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         baseLayer->GetInputSlot(1).GetConnectedOutputSlot()->GetTensorInfo(),
                                         activationLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo(),
                                         &activationDesc);
 
                                 if (status)
                                 {
                                     FuseLayerWithoutParameters<SubtractionLayer>(optimizationViews,
                                                                                  baseLayer,
                                                                                  activationLayer,
                                                                                  activationDesc,
                                                                                  name);
                                     untouched.erase(baseLayer->GetGuid());
                                     untouched.erase(activationLayer->GetGuid());
                                 }
                             }
                         }
                     }
                 }
             }
         }
 
         // Separate reduce layer with multiple axes into multiple reduce layers with 1 axis.
         if (base.GetType() == LayerType::Reduce)
         {
             ReduceLayer* baseLayer            = PolymorphicDowncast<ReduceLayer*>(&base);
             ReduceDescriptor reduceDescriptor = baseLayer->GetParameters();
 
             if (!reduceDescriptor.m_vAxis.empty() && reduceDescriptor.m_vAxis.size() > 1)
             {
                 // Add new layers to the graph and connect them.
                 std::vector<Layer*> layers = ChainReduceLayers<ReduceLayer>(optimizationViews,
                                                                             baseLayer,
                                                                             reduceDescriptor);
 
                 // Replace existing baselayer with new subgraph.
                 ReplaceLayers<ReduceLayer>(optimizationViews, baseLayer, layers);
                 untouched.erase(baseLayer->GetGuid());
             }
         }
     }
 
     if (optimizationViews.GetSubstitutions().empty())
     {
         optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph));
     }
     else
     {
         ReportUntouchedLayers(optimizationViews, untouched);
     }
 
     return optimizationViews;
 }

◆ RegisterTensorHandleFactories()

void RegisterTensorHandleFactories ( class TensorHandleFactoryRegistry & )

overridevirtual

(Optional) Register TensorHandleFactories Either this method or CreateMemoryManager() and IWorkloadFactory::CreateTensor()/IWorkloadFactory::CreateSubtensor() methods must be implemented.

Reimplemented from IBackendInternal.

Definition at line 426 of file NeonBackend.cpp.

References BaseMemoryManager::Offset, TensorHandleFactoryRegistry::RegisterFactory(), and TensorHandleFactoryRegistry::RegisterMemoryManager().

Referenced by NeonBackend::GetId().

 {
     auto memoryManager = std::make_shared<NeonMemoryManager>(std::make_unique<arm_compute::Allocator>(),
                                                              BaseMemoryManager::MemoryAffinity::Offset);
 
     registry.RegisterMemoryManager(memoryManager);
     registry.RegisterFactory(std::make_unique<NeonTensorHandleFactory>(memoryManager));
 }

The documentation for this class was generated from the following files:

src/backends/neon/NeonBackend.hpp
src/backends/neon/NeonBackend.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ NeonBackend()

◆ ~NeonBackend()

Member Function Documentation

◆ CreateBackendContext()

◆ CreateBackendProfilingContext()

◆ CreateBackendSpecificModelContext()

◆ CreateMemoryManager()

◆ CreateWorkloadFactory() [1/4]

◆ CreateWorkloadFactory() [2/4]

◆ CreateWorkloadFactory() [3/4]

◆ CreateWorkloadFactory() [4/4]

◆ GetCapabilities()

◆ GetHandleFactoryPreferences()

◆ GetId()

◆ GetIdStatic()

◆ GetLayerSupport() [1/2]

◆ GetLayerSupport() [2/2]

◆ GetOptimizations()

◆ OptimizeSubgraphView()

◆ RegisterTensorHandleFactories()