armnn Namespace Reference

Copyright (c) 2021 ARM Limited and Contributors. More...

Namespaces
	experimental
	gatordmock
	optimizations
	profiling
	stringUtils
	test
	timelinedecoder
	utility

Classes
struct	abs
class	AbsLayer
struct	AbsQueueDescriptor
struct	ActivationDescriptor
	An ActivationDescriptor for the ActivationLayer. More...
class	ActivationLayer
	This layer represents an activation operation with the specified activation function. More...
struct	ActivationQueueDescriptor
class	AddedLayerObservable
class	AdditionLayer
	This layer represents an addition operation. More...
struct	AdditionQueueDescriptor
struct	ArgMinMaxDescriptor
	An ArgMinMaxDescriptor for ArgMinMaxLayer. More...
class	ArgMinMaxLayer
	This layer represents a ArgMinMax operation. More...
struct	ArgMinMaxQueueDescriptor
class	BackendId
struct	BackendOptions
	Struct for the users to pass backend specific options. More...
class	BackendProfilingException
class	BackendRegistry
struct	BackendSettings
class	BackendUnavailableException
	Class for non-fatal exceptions raised while initialising a backend. More...
struct	BackendVersion
class	BadOptionalAccessException
struct	BaseDescriptor
	Base class for all descriptors. More...
class	BaseIterator
class	BaseMemoryManager
class	BaseTensor
class	BaseWorkload
struct	BatchNormalizationDescriptor
	A BatchNormalizationDescriptor for the BatchNormalizationLayer. More...
class	BatchNormalizationLayer
	This layer represents a batch normalization operation. More...
struct	BatchNormalizationQueueDescriptor
struct	BatchToSpaceNdDescriptor
	A BatchToSpaceNdDescriptor for the BatchToSpaceNdLayer. More...
class	BatchToSpaceNdLayer
	This layer represents a BatchToSpaceNd operation. More...
struct	BatchToSpaceNdQueueDescriptor
class	BFloat16
class	BFloat16Decoder
class	BFloat16Encoder
struct	BiasAndWeightsTypesCompatible
struct	BiasAndWeightsTypesMatch
class	BindableLayer
class	BooleanDecoder
class	BooleanDecoderBool
class	BooleanEncoder
struct	BroadcastLoop
struct	Capability
	Capability of the TensorHandleFactory. More...
class	CastLayer
	This layer represents a cast operation. More...
struct	CastQueueDescriptor
struct	CheckLocation
class	ClAbsWorkload
class	ClActivationWorkload
class	ClAdditionWorkload
class	ClArgMinMaxWorkload
class	ClBackend
class	ClBackendContext
class	ClBackendModelContext
	The ClBackendModelContext is used to pass in CL specific backend ModelOptions. More...
class	ClBatchNormalizationFloatWorkload
class	ClBatchToSpaceNdWorkload
class	ClCastWorkload
class	ClComparisonWorkload
class	ClConcatWorkload
class	ClConstantWorkload
struct	ClContextBuilder
class	ClContextControl
class	ClContextDeserializer
class	ClContextSerializer
class	ClConvertFp16ToFp32Workload
class	ClConvertFp32ToFp16Workload
class	ClConvolution2dWorkload
class	ClDepthToSpaceWorkload
class	ClDepthwiseConvolutionWorkload
class	ClDequantizeWorkload
class	ClDivisionWorkload
class	ClExpWorkload
class	ClFillWorkload
class	ClFloorFloatWorkload
class	ClFullyConnectedWorkload
class	ClGatherWorkload
class	ClImportSubTensorHandle
class	ClImportTensorHandle
class	ClImportTensorHandleFactory
	This factory creates ClImportTensorHandles that refer to imported memory tensors. More...
class	ClInstanceNormalizationWorkload
class	ClL2NormalizationFloatWorkload
class	ClLayerSupport
class	ClLogicalAndWorkload
class	ClLogicalNotWorkload
class	ClLogicalOrWorkload
class	ClLogSoftmaxWorkload
class	ClLstmFloatWorkload
class	ClMaximumWorkload
class	ClMeanWorkload
class	ClMemoryManager
class	ClMinimumWorkload
class	ClMultiplicationWorkload
class	ClNegWorkload
class	ClNormalizationFloatWorkload
class	ClPadWorkload
class	ClPermuteWorkload
class	ClPooling2dWorkload
class	ClPreluWorkload
class	ClQLstmWorkload
class	ClQuantizedLstmWorkload
class	ClQuantizeWorkload
struct	ClRankWorkload
class	ClReduceWorkload
class	ClReshapeWorkload
class	ClResizeWorkload
class	ClRsqrtWorkload
class	ClRuntimeUnavailableException
class	ClSliceWorkload
class	ClSoftmaxWorkload
class	ClSpaceToBatchNdWorkload
class	ClSpaceToDepthWorkload
class	ClSplitterWorkload
class	ClStackWorkload
class	ClStridedSliceWorkload
class	ClSubTensorHandle
class	ClSubtractionWorkload
class	ClTensorHandle
class	ClTensorHandleFactory
class	ClTransposeConvolution2dWorkload
class	ClTransposeWorkload
class	ClTunedParameters
class	ClWorkloadFactory
struct	ComparisonDescriptor
	A ComparisonDescriptor for the ComparisonLayer. More...
class	ComparisonLayer
	This layer represents a comparison operation. More...
struct	ComparisonQueueDescriptor
class	ConcatLayer
	This layer represents a merge operation. More...
struct	ConcatQueueDescriptor
class	ConstantLayer
	A layer that the constant data can be bound to. More...
struct	ConstantQueueDescriptor
class	ConstPassthroughTensorHandle
struct	ConstructInPlace
	Disambiguation tag that can be passed to the constructor to indicate that the contained object should be constructed in-place. More...
class	ConstTensor
	A tensor defined by a TensorInfo (shape and data type) and an immutable backing store. More...
class	ConstTensorHandle
class	ConvertBf16ToFp32Layer
	This layer converts data type BFloat16 to Float32. More...
struct	ConvertBf16ToFp32QueueDescriptor
class	ConvertFp16ToFp32Layer
	This layer converts data type Float 16 to Float 32. More...
struct	ConvertFp16ToFp32QueueDescriptor
class	ConvertFp32ToBf16Layer
	This layer converts data type Float32 to BFloat16. More...
struct	ConvertFp32ToBf16QueueDescriptor
class	ConvertFp32ToFp16Layer
	This layer converts data type Float 32 to Float 16. More...
struct	ConvertFp32ToFp16QueueDescriptor
struct	Convolution2dDescriptor
	A Convolution2dDescriptor for the Convolution2dLayer. More...
class	Convolution2dLayer
	This layer represents a convolution 2d operation. More...
struct	Convolution2dQueueDescriptor
class	CopyMemGenericWorkload
class	DebugLayer
	This layer visualizes the data flowing through the network. More...
struct	DebugQueueDescriptor
class	Decoder
class	DepthToSpaceLayer
	This layer represents a DepthToSpace operation. More...
struct	DepthToSpaceQueueDescriptor
struct	DepthwiseConvolution2dDescriptor
	A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer. More...
class	DepthwiseConvolution2dLayer
	This layer represents a depthwise convolution 2d operation. More...
struct	DepthwiseConvolution2dQueueDescriptor
class	DequantizeLayer
	This layer dequantizes the input tensor. More...
struct	DequantizeQueueDescriptor
struct	DetectionPostProcessDescriptor
class	DetectionPostProcessLayer
	This layer represents a detection postprocess operator. More...
struct	DetectionPostProcessQueueDescriptor
class	DeviceSpec
class	DivisionLayer
	This layer represents a division operation. More...
struct	DivisionQueueDescriptor
class	DotAttributeSet
class	DotBase
class	DotDefaults
class	DotEdge
class	DotGraph
class	DotNode
class	DynamicBackend
class	DynamicBackendUtils
class	ElementwiseBaseLayer
	NOTE: this is an abstract class to encapsulate the element wise operations, it does not implement: std::unique_ptr<IWorkload> Layer::CreateWorkload(const IWorkloadFactory& factory) const = 0; Layer* Clone(Graph& graph) const = 0;. More...
struct	ElementwiseBinaryFunction
struct	ElementwiseUnaryDescriptor
	A ElementwiseUnaryDescriptor for the ElementwiseUnaryLayer. More...
struct	ElementwiseUnaryFunction
class	ElementwiseUnaryLayer
	This layer represents a elementwiseUnary operation. More...
struct	ElementwiseUnaryQueueDescriptor
struct	EmptyOptional
	EmptyOptional is used to initialize the Optional class in case we want to have default value for an Optional in a function declaration. More...
class	Encoder
struct	EqualQueueDescriptor
class	ErasedLayerNamesObservable
class	Event
	Event class records measurements reported by BeginEvent()/EndEvent() and returns measurements when Event::GetMeasurements() is called. More...
class	Exception
	Base class for all ArmNN exceptions so that users can filter to just those. More...
class	ExecutionFrame
struct	exp
struct	FakeQuantizationDescriptor
	A FakeQuantizationDescriptor for the FakeQuantizationLayer. More...
class	FakeQuantizationLayer
	This layer represents a fake quantization operation. More...
struct	FakeQuantizationQueueDescriptor
class	FileNotFoundException
struct	FillDescriptor
	A FillDescriptor for the FillLayer. More...
class	FillLayer
	This layer represents a fill operation. More...
struct	FillQueueDescriptor
class	FirstInputTypedWorkload
struct	FLATBUFFERS_FINAL_CLASS
class	Float16Decoder
class	Float16Encoder
class	Float32Decoder
class	Float32Encoder
class	FloorLayer
	This layer represents a floor operation. More...
struct	FloorQueueDescriptor
struct	FullyConnectedDescriptor
	A FullyConnectedDescriptor for the FullyConnectedLayer. More...
class	FullyConnectedLayer
	This layer represents a fully connected operation. More...
struct	FullyConnectedQueueDescriptor
struct	GatherDescriptor
	A GatherDescriptor for the GatherLayer. More...
class	GatherLayer
	This layer represents a Gather operator. More...
struct	GatherQueueDescriptor
class	Graph
class	GraphObservable
class	GraphValidationException
struct	GreaterQueueDescriptor
class	HtmlBold
class	HtmlFont
class	HtmlSection
class	HtmlSimpleTag
class	IAclTensorHandle
class	IBackend
	Each backend should implement an IBackend. More...
class	IBackendContext
class	IBackendInternal
class	IBackendModelContext
class	IClImportTensorHandle
class	IClTensorHandle
class	IConnectableLayer
	Interface for a layer that is connectable to other layers via InputSlots and OutputSlots. More...
class	IDeviceSpec
	Device specific knowledge to be passed to the optimizer. More...
class	IExecutionFrame
	ExecutionFrame interface to enqueue a workload computation. More...
class	IGpuAccTunedParameters
	Manages a set of GpuAcc parameters which have been tuned for maximum performance. More...
class	IGraphObservable
class	IInputSlot
	An input connection slot for a layer. More...
class	ILayerSupport
class	ILayerVisitor
class	IMemoryManager
class	ImportMemGenericWorkload
class	INetwork
	Main network class which provides the interface for building up a neural network. More...
struct	INetworkProperties
class	InputLayer
	A layer user-provided data can be bound to (e.g. inputs, outputs). More...
class	InputSlot
struct	InstanceNormalizationDescriptor
	An InstanceNormalizationDescriptor for InstanceNormalizationLayer. More...
class	InstanceNormalizationLayer
	This layer represents an instance normalization operation. More...
struct	InstanceNormalizationQueueDescriptor
class	Instrument
class	Int32Decoder
class	Int32Encoder
class	Int32ToInt32tDecoder
class	Int32ToInt32tEncoder
class	InvalidArgumentException
class	IOptimizedNetwork
class	IOutputSlot
	An output connection slot for a layer. More...
class	IProfiler
class	IRuntime
struct	IsHalfType
struct	IsMemorySource
struct	IsMemorySource< MemorySource >
class	IStrategy
class	ISubgraphViewConverter
class	ITensorHandle
class	ITensorHandleFactory
class	IWorkload
	Workload interface to enqueue a layer computation. More...
class	IWorkloadFactory
struct	JsonChildObject
class	JsonPrinter
struct	L2NormalizationDescriptor
	A L2NormalizationDescriptor for the L2NormalizationLayer. More...
class	L2NormalizationLayer
	This layer represents a L2 normalization operation. More...
struct	L2NormalizationQueueDescriptor
class	Layer
class	LayerSupportBase
class	LayerSupportHandle
struct	LayerTypeOfImpl
struct	LayerTypeOfImpl< LayerType::Activation >
struct	LayerTypeOfImpl< LayerType::Addition >
struct	LayerTypeOfImpl< LayerType::ArgMinMax >
struct	LayerTypeOfImpl< LayerType::BatchNormalization >
struct	LayerTypeOfImpl< LayerType::BatchToSpaceNd >
struct	LayerTypeOfImpl< LayerType::Cast >
struct	LayerTypeOfImpl< LayerType::Comparison >
struct	LayerTypeOfImpl< LayerType::Concat >
struct	LayerTypeOfImpl< LayerType::Constant >
struct	LayerTypeOfImpl< LayerType::ConvertBf16ToFp32 >
struct	LayerTypeOfImpl< LayerType::ConvertFp16ToFp32 >
struct	LayerTypeOfImpl< LayerType::ConvertFp32ToBf16 >
struct	LayerTypeOfImpl< LayerType::ConvertFp32ToFp16 >
struct	LayerTypeOfImpl< LayerType::Convolution2d >
struct	LayerTypeOfImpl< LayerType::Debug >
struct	LayerTypeOfImpl< LayerType::DepthToSpace >
struct	LayerTypeOfImpl< LayerType::DepthwiseConvolution2d >
struct	LayerTypeOfImpl< LayerType::Dequantize >
struct	LayerTypeOfImpl< LayerType::DetectionPostProcess >
struct	LayerTypeOfImpl< LayerType::Division >
struct	LayerTypeOfImpl< LayerType::ElementwiseUnary >
struct	LayerTypeOfImpl< LayerType::FakeQuantization >
struct	LayerTypeOfImpl< LayerType::Fill >
struct	LayerTypeOfImpl< LayerType::Floor >
struct	LayerTypeOfImpl< LayerType::FullyConnected >
struct	LayerTypeOfImpl< LayerType::Gather >
struct	LayerTypeOfImpl< LayerType::Input >
struct	LayerTypeOfImpl< LayerType::InstanceNormalization >
struct	LayerTypeOfImpl< LayerType::L2Normalization >
struct	LayerTypeOfImpl< LayerType::LogicalBinary >
struct	LayerTypeOfImpl< LayerType::LogSoftmax >
struct	LayerTypeOfImpl< LayerType::Lstm >
struct	LayerTypeOfImpl< LayerType::Map >
struct	LayerTypeOfImpl< LayerType::Maximum >
struct	LayerTypeOfImpl< LayerType::Mean >
struct	LayerTypeOfImpl< LayerType::MemCopy >
struct	LayerTypeOfImpl< LayerType::MemImport >
struct	LayerTypeOfImpl< LayerType::Merge >
struct	LayerTypeOfImpl< LayerType::Minimum >
struct	LayerTypeOfImpl< LayerType::Multiplication >
struct	LayerTypeOfImpl< LayerType::Normalization >
struct	LayerTypeOfImpl< LayerType::Output >
struct	LayerTypeOfImpl< LayerType::Pad >
struct	LayerTypeOfImpl< LayerType::Permute >
struct	LayerTypeOfImpl< LayerType::Pooling2d >
struct	LayerTypeOfImpl< LayerType::PreCompiled >
struct	LayerTypeOfImpl< LayerType::Prelu >
struct	LayerTypeOfImpl< LayerType::QLstm >
struct	LayerTypeOfImpl< LayerType::Quantize >
struct	LayerTypeOfImpl< LayerType::QuantizedLstm >
struct	LayerTypeOfImpl< LayerType::Rank >
struct	LayerTypeOfImpl< LayerType::Reduce >
struct	LayerTypeOfImpl< LayerType::Reshape >
struct	LayerTypeOfImpl< LayerType::Resize >
struct	LayerTypeOfImpl< LayerType::Slice >
struct	LayerTypeOfImpl< LayerType::Softmax >
struct	LayerTypeOfImpl< LayerType::SpaceToBatchNd >
struct	LayerTypeOfImpl< LayerType::SpaceToDepth >
struct	LayerTypeOfImpl< LayerType::Splitter >
struct	LayerTypeOfImpl< LayerType::Stack >
struct	LayerTypeOfImpl< LayerType::StandIn >
struct	LayerTypeOfImpl< LayerType::StridedSlice >
struct	LayerTypeOfImpl< LayerType::Subtraction >
struct	LayerTypeOfImpl< LayerType::Switch >
struct	LayerTypeOfImpl< LayerType::Transpose >
struct	LayerTypeOfImpl< LayerType::TransposeConvolution2d >
struct	LayerTypeOfImpl< LayerType::Unmap >
class	LayerValidationException
class	LayerVisitorBase
	Visitor base class with empty implementations. More...
class	LayerWithParameters
class	LoadedNetwork
struct	LogicalBinaryDescriptor
	A LogicalBinaryDescriptor for the LogicalBinaryLayer. More...
struct	LogicalBinaryFunction
class	LogicalBinaryLayer
	This layer represents a Logical Binary operation. More...
struct	LogicalBinaryQueueDescriptor
struct	LogicalUnaryFunction
class	LogSink
class	LogSoftmaxLayer
	This layer represents a log softmax operation. More...
struct	LogSoftmaxQueueDescriptor
struct	LstmBasicParameters
struct	LstmDescriptor
	An LstmDescriptor for the LstmLayer. More...
struct	LstmInputParams
struct	LstmInputParamsInfo
class	LstmLayer
	This layer represents a LSTM operation. More...
struct	LstmOptCifgParameters
struct	LstmOptLayerNormParameters
struct	LstmOptPeepholeParameters
struct	LstmOptProjectionParameters
struct	LstmQueueDescriptor
class	ManagedConstTensorHandle
class	MapLayer
	This layer represents a memory copy operation. More...
struct	MapQueueDescriptor
class	MapWorkload
struct	maximum
class	MaximumLayer
	This layer represents a maximum operation. More...
struct	MaximumQueueDescriptor
struct	MeanDescriptor
	A MeanDescriptor for the MeanLayer. More...
class	MeanLayer
	This layer represents a mean operation. More...
struct	MeanQueueDescriptor
struct	Measurement
class	MemCopyLayer
	This layer represents a memory copy operation. More...
struct	MemCopyQueueDescriptor
class	MemImportLayer
	This layer represents a memory import operation. More...
struct	MemImportQueueDescriptor
class	MemoryExportException
class	MemoryImportException
struct	MemSyncQueueDescriptor
class	MergeLayer
	This layer dequantizes the input tensor. More...
struct	MergeQueueDescriptor
struct	minimum
class	MinimumLayer
	This layer represents a minimum operation. More...
struct	MinimumQueueDescriptor
class	MockBackend
class	MockBackendInitialiser
class	MockBackendProfilingContext
class	MockBackendProfilingService
class	MockImportBackend
class	MockImportBackendInitialiser
class	MockImportLayerSupport
class	MockLayerSupport
class	MultiplicationLayer
	This layer represents a multiplication operation. More...
struct	MultiplicationQueueDescriptor
class	MultiTypedWorkload
class	NeonAbsWorkload
class	NeonActivationWorkload
class	NeonAdditionWorkload
class	NeonArgMinMaxWorkload
class	NeonBackend
class	NeonBackendModelContext
	The NeonBackendModelContext is used to pass in Neon specific backend ModelOptions. More...
class	NeonBatchNormalizationWorkload
class	NeonBatchToSpaceNdWorkload
class	NeonCastWorkload
class	NeonComparisonWorkload
class	NeonConcatWorkload
class	NeonConstantWorkload
class	NeonConvertBf16ToFp32Workload
class	NeonConvertFp16ToFp32Workload
class	NeonConvertFp32ToBf16Workload
class	NeonConvertFp32ToFp16Workload
class	NeonConvolution2dWorkload
class	NeonDepthToSpaceWorkload
class	NeonDepthwiseConvolutionWorkload
class	NeonDequantizeWorkload
class	NeonDetectionPostProcessWorkload
class	NeonDivisionWorkload
class	NeonExpWorkload
class	NeonFillWorkload
class	NeonFloorFloatWorkload
class	NeonFullyConnectedWorkload
class	NeonGatherWorkload
class	NeonInstanceNormalizationWorkload
class	NeonInterceptorScheduler
class	NeonL2NormalizationFloatWorkload
class	NeonLayerSupport
class	NeonLogicalAndWorkload
class	NeonLogicalNotWorkload
class	NeonLogicalOrWorkload
class	NeonLogSoftmaxWorkload
class	NeonLstmFloatWorkload
class	NeonMaximumWorkload
class	NeonMeanWorkload
class	NeonMemoryManager
class	NeonMinimumWorkload
class	NeonMultiplicationWorkload
class	NeonNegWorkload
class	NeonNormalizationFloatWorkload
class	NeonPadWorkload
class	NeonPermuteWorkload
class	NeonPooling2dWorkload
class	NeonPreluWorkload
class	NeonQLstmWorkload
class	NeonQuantizedLstmWorkload
class	NeonQuantizeWorkload
struct	NeonRankWorkload
class	NeonReduceWorkload
class	NeonReshapeWorkload
class	NeonResizeWorkload
class	NeonRsqrtWorkload
class	NeonSliceWorkload
class	NeonSoftmaxWorkload
class	NeonSpaceToBatchNdWorkload
class	NeonSpaceToDepthWorkload
class	NeonSplitterWorkload
class	NeonStackWorkload
class	NeonStridedSliceWorkload
class	NeonSubTensorHandle
class	NeonSubtractionWorkload
class	NeonTensorHandle
class	NeonTensorHandleFactory
class	NeonTimer
class	NeonTransposeConvolution2dWorkload
class	NeonTransposeWorkload
class	NeonWorkloadFactory
class	NetworkImpl
	Private implementation of INetwork. More...
class	NodeContent
struct	NormalizationDescriptor
	A NormalizationDescriptor for the NormalizationLayer. More...
class	NormalizationLayer
	This layer represents a normalization operation. More...
struct	NormalizationQueueDescriptor
class	NullPointerException
class	NullWorkload
class	OpenClTimer
	OpenClTimer instrument that times all OpenCl kernels executed between calls to Start() and Stop(). More...
class	Optimization
struct	OptimizationResult
class	OptimizationViews
class	OptimizedNetworkImpl
class	OptimizeForConnection
class	OptimizeForConnectionImpl
	Wrapper Optimization class that calls Wrapped::Run for every connection BaseType -> ChildType. More...
class	OptimizeForExclusiveConnection
class	OptimizeForExclusiveConnectionImpl
	Wrapper Optimization class that calls Wrapped::Run for every connection BaseType -> ChildType. More...
class	OptimizeForType
class	OptimizeForTypeImpl
	Wrapper Optimization base class that calls Wrapped::Run() for every layer of type BaseType. More...
class	OptimizeForTypeImpl< Layer, Wrapped >
	Specialization that calls Wrapped::Run() for any layer type. More...
class	Optimizer
struct	OptimizerOptions
class	Optional
class	OptionalBase
	OptionalBase is the common functionality between reference and non-reference optional types. More...
class	OptionalReferenceSwitch
	The default implementation is the non-reference case. More...
class	OptionalReferenceSwitch< true, T >
	This is the special case for reference types. More...
struct	OriginsDescriptor
	An OriginsDescriptor for the ConcatLayer. More...
class	OutputHandler
class	OutputLayer
	A layer user-provided data can be bound to (e.g. inputs, outputs). More...
class	OutputSlot
struct	PadDescriptor
	A PadDescriptor for the PadLayer. More...
class	PadLayer
	This layer represents a pad operation. More...
struct	PadQueueDescriptor
class	ParseException
class	PassthroughTensorHandle
class	PerAxisIterator
class	PermutationVector
struct	PermuteDescriptor
	A PermuteDescriptor for the PermuteLayer. More...
class	PermuteLayer
	This layer represents a permutation operation. More...
struct	PermuteQueueDescriptor
class	PolymorphicDowncastException
struct	Pooling2dDescriptor
	A Pooling2dDescriptor for the Pooling2dLayer. More...
class	Pooling2dLayer
	This layer represents a pooling 2d operation. More...
struct	Pooling2dQueueDescriptor
struct	PreCompiledDescriptor
	A PreCompiledDescriptor for the PreCompiledLayer. More...
class	PreCompiledLayer
struct	PreCompiledQueueDescriptor
class	PreluLayer
struct	PreluQueueDescriptor
class	ProfilerImpl
class	ProfilerManager
struct	ProgramBuilder
class	QASymm8Decoder
class	QASymm8Encoder
class	QASymmS8Decoder
class	QASymmS8Encoder
struct	QLstmBasicParameters
struct	QLstmDescriptor
	A QLstmDescriptor for the QLstmLayer. More...
class	QLstmLayer
	This layer represents a QLstm operation. More...
struct	QLstmOptCifgParameters
struct	QLstmOptLayerNormParameters
struct	QLstmOptPeepholeParameters
struct	QLstmOptProjectionParameters
struct	QLstmQueueDescriptor
class	QSymm16Decoder
class	QSymm16Encoder
class	QSymm8PerAxisDecoder
class	QSymm8PerAxisEncoder
class	QSymmS8Decoder
class	QSymmS8Encoder
struct	QuantizationParametersAreEqual
struct	QuantizedLstmInputParams
struct	QuantizedLstmInputParamsInfo
class	QuantizedLstmLayer
	This layer represents a QuantizedLstm operation. More...
struct	QuantizedLstmParameters
struct	QuantizedLstmQueueDescriptor
struct	QuantizedMultiplierSmallerThanOne
	Performs multiplication of an integer with a multiplier which is less than one, using quantized integer arithmetic which is consistent with AndroidNN's CPU executor. More...
class	QuantizeLayer
struct	QuantizeQueueDescriptor
struct	QueueDescriptor
struct	QueueDescriptorWithParameters
class	RangeTracker
class	RankLayer
struct	RankQueueDescriptor
struct	ReduceDescriptor
	A ReduceDescriptor for the REDUCE operators. More...
class	ReduceLayer
	This layer represents a reduction operation. More...
struct	ReduceQueueDescriptor
class	RefActivationWorkload
class	RefArgMinMaxWorkload
class	RefBackend
class	RefBatchNormalizationWorkload
class	RefBatchToSpaceNdWorkload
class	RefCastWorkload
class	RefComparisonWorkload
class	RefConcatWorkload
class	RefConstantWorkload
class	RefConvertBf16ToFp32Workload
class	RefConvertFp16ToFp32Workload
class	RefConvertFp32ToBf16Workload
class	RefConvertFp32ToFp16Workload
class	RefConvolution2dWorkload
class	RefDebugWorkload
class	RefDepthToSpaceWorkload
class	RefDepthwiseConvolution2dWorkload
class	RefDequantizeWorkload
class	RefDetectionPostProcessWorkload
class	RefElementwiseUnaryWorkload
class	RefElementwiseWorkload
class	RefFakeQuantizationFloat32Workload
class	RefFillWorkload
class	RefFloorWorkload
class	RefFullyConnectedWorkload
class	RefGatherWorkload
class	RefInstanceNormalizationWorkload
class	RefL2NormalizationWorkload
class	RefLayerSupport
class	RefLogicalBinaryWorkload
class	RefLogicalUnaryWorkload
class	RefLogSoftmaxWorkload
class	RefLstmWorkload
class	RefMeanWorkload
class	RefMemoryManager
class	RefNormalizationWorkload
class	RefPadWorkload
class	RefPermuteWorkload
class	RefPooling2dWorkload
class	RefPreluWorkload
class	RefQLstmWorkload
class	RefQuantizeWorkload
struct	RefRankWorkload
class	RefReduceWorkload
class	RefReshapeWorkload
class	RefResizeBilinearWorkload
class	RefResizeWorkload
class	RefSliceWorkload
class	RefSoftmaxWorkload
class	RefSpaceToBatchNdWorkload
class	RefSpaceToDepthWorkload
class	RefSplitterWorkload
class	RefStackWorkload
class	RefStridedSliceWorkload
class	RefTensorHandle
class	RefTensorHandleFactory
class	RefTransposeConvolution2dWorkload
class	RefTransposeWorkload
class	RefWorkloadFactory
struct	ReshapeDescriptor
	A ReshapeDescriptor for the ReshapeLayer. More...
class	ReshapeLayer
	This layer represents a reshape operation. More...
struct	ReshapeQueueDescriptor
struct	ResizeBilinearDescriptor
	A ResizeBilinearDescriptor for the ResizeBilinearLayer. More...
struct	ResizeBilinearQueueDescriptor
struct	ResizeDescriptor
	A ResizeDescriptor for the ResizeLayer. More...
class	ResizeLayer
	This layer represents a resize operation. More...
struct	ResizeQueueDescriptor
struct	ResolveTypeImpl
struct	ResolveTypeImpl< DataType::BFloat16 >
struct	ResolveTypeImpl< DataType::Boolean >
struct	ResolveTypeImpl< DataType::Float16 >
struct	ResolveTypeImpl< DataType::Float32 >
struct	ResolveTypeImpl< DataType::QAsymmS8 >
struct	ResolveTypeImpl< DataType::QAsymmU8 >
struct	ResolveTypeImpl< DataType::QSymmS16 >
struct	ResolveTypeImpl< DataType::QSymmS8 >
struct	ResolveTypeImpl< DataType::Signed32 >
struct	ResolveTypeImpl< DataType::Signed64 >
struct	rsqrt
class	RsqrtLayer
struct	RsqrtQueueDescriptor
struct	Rule
class	RuntimeException
struct	RuntimeImpl
class	ScaledInt32Decoder
class	ScaledInt32PerAxisDecoder
class	ScopedProfilingEvent
struct	ScopedRecord
class	ScopedTensorHandle
struct	ShapesAreBroadcastCompatible
struct	ShapesAreSameRank
struct	ShapesAreSameTotalSize
class	SimpleLogger
struct	SliceDescriptor
	A SliceDescriptor for the SliceLayer. More...
class	SliceLayer
struct	SliceQueueDescriptor
struct	SoftmaxDescriptor
	A SoftmaxDescriptor for the SoftmaxLayer. More...
class	SoftmaxLayer
	This layer represents a softmax operation. More...
struct	SoftmaxQueueDescriptor
struct	SpaceToBatchNdDescriptor
	A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer. More...
class	SpaceToBatchNdLayer
	This layer represents a SpaceToBatchNd operation. More...
struct	SpaceToBatchNdQueueDescriptor
struct	SpaceToDepthDescriptor
	A SpaceToDepthDescriptor for the SpaceToDepthLayer. More...
class	SpaceToDepthLayer
	This layer represents a SpaceToDepth operation. More...
struct	SpaceToDepthQueueDescriptor
class	SplitterLayer
	This layer represents a split operation. More...
struct	SplitterQueueDescriptor
struct	sqrt
struct	StackDescriptor
	A StackDescriptor for the StackLayer. More...
class	StackLayer
	This layer represents a stack operation. More...
struct	StackQueueDescriptor
class	StandardOutputSink
struct	StandInDescriptor
	A StandInDescriptor for the StandIn layer. More...
class	StandInLayer
	This layer represents an unknown operation in the input graph. More...
struct	StridedSliceDescriptor
	A StridedSliceDescriptor for the StridedSliceLayer. More...
class	StridedSliceLayer
	This layer represents a strided slice operation. More...
struct	StridedSliceQueueDescriptor
struct	StringifyLayerParameters
	StringifyLayerParameters allows serializing layer parameters to string. More...
struct	StringifyLayerParameters< ActivationDescriptor >
struct	StringifyLayerParameters< BatchNormalizationDescriptor >
struct	StringifyLayerParameters< BatchToSpaceNdDescriptor >
struct	StringifyLayerParameters< Convolution2dDescriptor >
struct	StringifyLayerParameters< DepthwiseConvolution2dDescriptor >
struct	StringifyLayerParameters< DetectionPostProcessDescriptor >
struct	StringifyLayerParameters< FakeQuantizationDescriptor >
struct	StringifyLayerParameters< FullyConnectedDescriptor >
struct	StringifyLayerParameters< L2NormalizationDescriptor >
struct	StringifyLayerParameters< LstmDescriptor >
struct	StringifyLayerParameters< MeanDescriptor >
struct	StringifyLayerParameters< NormalizationDescriptor >
struct	StringifyLayerParameters< OriginsDescriptor >
struct	StringifyLayerParameters< PadDescriptor >
struct	StringifyLayerParameters< PermuteDescriptor >
struct	StringifyLayerParameters< Pooling2dDescriptor >
struct	StringifyLayerParameters< PreCompiledDescriptor >
struct	StringifyLayerParameters< ReduceDescriptor >
struct	StringifyLayerParameters< ReshapeDescriptor >
struct	StringifyLayerParameters< ResizeBilinearDescriptor >
struct	StringifyLayerParameters< ResizeDescriptor >
struct	StringifyLayerParameters< SoftmaxDescriptor >
struct	StringifyLayerParameters< SpaceToBatchNdDescriptor >
struct	StringifyLayerParameters< SpaceToDepthDescriptor >
struct	StringifyLayerParameters< StackDescriptor >
struct	StringifyLayerParameters< StridedSliceDescriptor >
struct	StringifyLayerParameters< TransposeConvolution2dDescriptor >
struct	StringifyLayerParameters< TransposeDescriptor >
struct	StringifyLayerParameters< ViewsDescriptor >
struct	StringMapping
	StringMapping is helper class to be able to use strings as template parameters, so this allows simplifying code which only differs in a string, such as a debug string literal. More...
class	SubgraphView
	The SubgraphView class represents a subgraph of a Graph. More...
class	SubgraphViewSelector
	Algorithm that splits a Graph into Subgraphs based on a filtering of layers (e.g. More...
class	SubtractionLayer
	This layer represents a subtraction operation. More...
struct	SubtractionQueueDescriptor
class	SwitchLayer
	This layer calculates both true and false outputs for input. More...
struct	SwitchQueueDescriptor
class	SyncMemGenericWorkload
class	Tensor
	A tensor defined by a TensorInfo (shape and data type) and a mutable backing store. More...
class	TensorBufferArrayView
class	TensorHandle
class	TensorHandleFactoryRegistry
class	TensorInfo
struct	TensorNumDimensionsAreCorrect
class	TensorShape
class	TestBatchNormalizationLayerVisitor
class	TestConstantLayerVisitor
class	TestConvolution2dLayerVisitor
class	TestDepthwiseConvolution2dLayerVisitor
class	TestFullyConnectedLayerVistor
class	TestInputLayerVisitor
class	TestLayerVisitor
class	TestLstmLayerVisitor
class	TestOutputLayerVisitor
class	TestQLstmLayerVisitor
class	TestQuantizedLstmLayerVisitor
class	TimeoutException
class	TransformIterator
struct	TransposeConvolution2dDescriptor
	A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer. More...
class	TransposeConvolution2dLayer
	This layer represents a 2D transpose convolution operation. More...
struct	TransposeConvolution2dQueueDescriptor
struct	TransposeDescriptor
	A TransposeDescriptor for the TransposeLayer. More...
class	TransposeLayer
	This layer represents a transpose operation. More...
struct	TransposeQueueDescriptor
struct	TypeAnyOf
class	TypedIterator
class	TypedWorkload
struct	TypeIs
struct	TypeNotPerAxisQuantized
struct	TypesAreEqual
class	UnimplementedException
class	UnmapLayer
	This layer represents a memory copy operation. More...
struct	UnmapQueueDescriptor
class	UnmapWorkload
struct	ViewsDescriptor
	A ViewsDescriptor for the SplitterLayer. More...
struct	VisitorNoThrowPolicy
struct	VisitorThrowingPolicy
class	WallClockTimer
class	WorkloadDataCollector
class	WorkloadFactoryBase
struct	WorkloadInfo
	Contains information about inputs and outputs to a layer. More...

Typedefs
using	BackendIdVector = std::vector< BackendId >
using	BackendIdSet = std::unordered_set< BackendId >
using	NetworkOptions = std::vector< BackendOptions >
using	ModelOptions = std::vector< BackendOptions >
using	IBackendInternalUniquePtr = std::unique_ptr< IBackendInternal >
using	DynamicBackendPtr = std::unique_ptr< DynamicBackend >
using	IBackendContextUniquePtr = std::unique_ptr< IBackendContext >
using	ILayerSupportSharedPtr = std::shared_ptr< ILayerSupport >
using	IMemoryManagerUniquePtr = std::unique_ptr< IMemoryManager >
using	LogSoftmaxDescriptor = SoftmaxDescriptor
	A LogSoftmaxDescriptor for the LogSoftmaxLayer. More...
using	DepthToSpaceDescriptor = SpaceToDepthDescriptor
	A DepthToSpaceDescriptor for the DepthToSpaceLayer. More...
using	ConcatDescriptor = OriginsDescriptor
using	MergerDescriptor = OriginsDescriptor
	MergerDescriptor is deprecated, use ConcatDescriptor instead. More...
using	SplitterDescriptor = ViewsDescriptor
using	INetworkPtr = std::unique_ptr< INetwork, void(*)(INetwork *network)>
using	IOptimizedNetworkPtr = std::unique_ptr< IOptimizedNetwork, void(*)(IOptimizedNetwork *network)>
using	NetworkId = int
using	IRuntimePtr = std::unique_ptr< IRuntime, void(*)(IRuntime *runtime)>
using	IGpuAccTunedParametersPtr = std::shared_ptr< IGpuAccTunedParameters >
	The following API is replaced by the backend options API. More...
using	MemorySourceFlags = unsigned int
using	BindingPointInfo = std::pair< armnn::LayerBindingId, armnn::TensorInfo >
using	InputTensors = std::vector< std::pair< LayerBindingId, class ConstTensor > >
using	OutputTensors = std::vector< std::pair< LayerBindingId, class Tensor > >
using	IBackendSharedPtr = std::shared_ptr< IBackend >
using	IBackendUniquePtr = std::unique_ptr< IBackend, void(*)(IBackend *backend)>
using	LayerBindingId = int
	Type of identifiers for bindable layers (inputs, outputs). More...
using	LayerGuid = profiling::ProfilingGuid
	Define LayerGuid type. More...
using	DebugCallbackFunction = std::function< void(LayerGuid guid, unsigned int slotIndex, ITensorHandle *tensorHandle)>
	Define the type of callback for the Debug layer to call. More...
using	HighResolutionClock = std::chrono::high_resolution_clock::time_point
	Define a timer and associated inference ID for recording execution times. More...
using	InferenceTimingPair = std::pair< HighResolutionClock, HighResolutionClock >
using	WorkloadQueue = std::vector< std::unique_ptr< IWorkload > >
using	Coordinates = std::array< unsigned int, MaxNumOfTensorDimensions >
using	Dimensions = std::array< unsigned int, MaxNumOfTensorDimensions >
using	CompiledBlobDeleter = std::function< void(const void *)>
using	CompiledBlobPtr = std::unique_ptr< void, CompiledBlobDeleter >
using	supported = ISubgraphViewConverter
using	LayerPriority = unsigned int
using	AdditionalInfoObjectPtr = std::shared_ptr< void >
using	PreCompiledObjectDeleter = std::function< void(const void *)>
using	PreCompiledObjectPtr = std::unique_ptr< void, PreCompiledObjectDeleter >
template<LayerType Type>
using	LayerTypeOf = typename LayerTypeOfImpl< Type >::Type
using	NetworkImplPtr = std::unique_ptr< NetworkImpl, void(*)(NetworkImpl *network)>
using	BackendsMap = std::map< BackendId, std::unique_ptr< class IBackendInternal > >
template<DataType DT>
using	ResolveType = typename ResolveTypeImpl< DT >::Type
using	LoadedNetworks = std::unordered_map< NetworkId, std::unique_ptr< LoadedNetwork > >
using	IReportStructure = profiling::IReportStructure
using	ParameterStringifyFunction = std::function< void(const std::string &name, const std::string &value)>
using	instead = SubgraphView
using	Half = half_float::half
template<typename QueueDescriptor >
using	FloatWorkload = TypedWorkload< QueueDescriptor, armnn::DataType::Float16, armnn::DataType::Float32 >
template<typename QueueDescriptor >
using	Float32Workload = TypedWorkload< QueueDescriptor, armnn::DataType::Float32 >
template<typename QueueDescriptor >
using	Uint8Workload = TypedWorkload< QueueDescriptor, armnn::DataType::QAsymmU8 >
template<typename QueueDescriptor >
using	Int32Workload = TypedWorkload< QueueDescriptor, armnn::DataType::Signed32 >
template<typename QueueDescriptor >
using	BooleanWorkload = TypedWorkload< QueueDescriptor, armnn::DataType::Boolean >
template<typename QueueDescriptor >
using	BaseFloat32ComparisonWorkload = MultiTypedWorkload< QueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean >
template<typename QueueDescriptor >
using	BaseUint8ComparisonWorkload = MultiTypedWorkload< QueueDescriptor, armnn::DataType::QAsymmU8, armnn::DataType::Boolean >
template<typename QueueDescriptor >
using	BFloat16ToFloat32Workload = MultiTypedWorkload< QueueDescriptor, armnn::DataType::BFloat16, armnn::DataType::Float32 >
template<typename QueueDescriptor >
using	Float32ToBFloat16Workload = MultiTypedWorkload< QueueDescriptor, armnn::DataType::Float32, armnn::DataType::BFloat16 >
template<typename QueueDescriptor >
using	Float16ToFloat32Workload = MultiTypedWorkload< QueueDescriptor, armnn::DataType::Float16, armnn::DataType::Float32 >
template<typename QueueDescriptor >
using	Float32ToFloat16Workload = MultiTypedWorkload< QueueDescriptor, armnn::DataType::Float32, armnn::DataType::Float16 >
template<typename QueueDescriptor >
using	Uint8ToFloat32Workload = MultiTypedWorkload< QueueDescriptor, armnn::DataType::QAsymmU8, armnn::DataType::Float32 >
using	InputQueueDescriptor = MemCopyQueueDescriptor
using	OutputQueueDescriptor = MemCopyQueueDescriptor
using	MergerQueueDescriptor = ConcatQueueDescriptor
using	FactoryId = ITensorHandleFactory::FactoryId
using	RefDebugBFloat16Workload = RefDebugWorkload< DataType::BFloat16 >
using	RefDebugFloat16Workload = RefDebugWorkload< DataType::Float16 >
using	RefDebugFloat32Workload = RefDebugWorkload< DataType::Float32 >
using	RefDebugQAsymmU8Workload = RefDebugWorkload< DataType::QAsymmU8 >
using	RefDebugQAsymmS8Workload = RefDebugWorkload< DataType::QAsymmS8 >
using	RefDebugQSymmS16Workload = RefDebugWorkload< DataType::QSymmS16 >
using	RefDebugQSymmS8Workload = RefDebugWorkload< DataType::QSymmS8 >
using	RefDebugSigned32Workload = RefDebugWorkload< DataType::Signed32 >
template<typename DataType = float>
using	RefAdditionWorkload = RefElementwiseWorkload< std::plus< DataType >, AdditionQueueDescriptor, StringMapping::RefAdditionWorkload_Execute >
template<typename DataType = float>
using	RefSubtractionWorkload = RefElementwiseWorkload< std::minus< DataType >, SubtractionQueueDescriptor, StringMapping::RefSubtractionWorkload_Execute >
template<typename DataType = float>
using	RefMultiplicationWorkload = RefElementwiseWorkload< std::multiplies< DataType >, MultiplicationQueueDescriptor, StringMapping::RefMultiplicationWorkload_Execute >
template<typename DataType = float>
using	RefDivisionWorkload = RefElementwiseWorkload< std::divides< DataType >, DivisionQueueDescriptor, StringMapping::RefDivisionWorkload_Execute >
template<typename DataType = float>
using	RefMaximumWorkload = RefElementwiseWorkload< armnn::maximum< DataType >, MaximumQueueDescriptor, StringMapping::RefMaximumWorkload_Execute >
template<typename DataType = float>
using	RefMinimumWorkload = RefElementwiseWorkload< armnn::minimum< DataType >, MinimumQueueDescriptor, StringMapping::RefMinimumWorkload_Execute >
using	RefPermuteBFloat16Workload = RefPermuteWorkload< DataType::BFloat16 >
using	RefPermuteFloat16Workload = RefPermuteWorkload< DataType::Float16 >
using	RefPermuteFloat32Workload = RefPermuteWorkload< DataType::Float32 >
using	RefPermuteQAsymmS8Workload = RefPermuteWorkload< DataType::QAsymmS8 >
using	RefPermuteQAsymm8Workload = RefPermuteWorkload< DataType::QAsymmU8 >
using	RefPermuteQSymm16Workload = RefPermuteWorkload< DataType::QSymmS16 >
using	RefTransposeBFloat16Workload = RefTransposeWorkload< DataType::BFloat16 >
using	RefTransposeFloat16Workload = RefTransposeWorkload< DataType::Float16 >
using	RefTransposeFloat32Workload = RefTransposeWorkload< DataType::Float32 >
using	RefTransposeQAsymmS8Workload = RefTransposeWorkload< DataType::QAsymmS8 >
using	RefTransposeQAsymm8Workload = RefTransposeWorkload< DataType::QAsymmU8 >
using	RefTransposeQSymm16Workload = RefTransposeWorkload< DataType::QSymmS16 >

Enumerations
enum	Compute { Undefined = 0, CpuRef = 1, CpuAcc = 2, GpuAcc = 3 }
	The Compute enum is now deprecated and it is now being replaced by BackendId. More...
enum	CapabilityClass { PaddingRequired = 1, FallbackImportDisabled = 2, CapabilityClassMax = 254 }
	Capability class to calculate in the GetCapabilities function so that only the capability in the scope can be choose to calculate. More...
enum	EdgeStrategy { Undefined, DirectCompatibility, ExportToTarget, CopyToTarget }
enum	BoostLogSeverityMapping {   trace, debug, info, warning,   error, fatal }
enum	Status { Success = 0, Failure = 1 }
	enumeration More...
enum	DataType {   Float16 = 0, Float32 = 1, QAsymmU8 = 2, Signed32 = 3,   Boolean = 4, QSymmS16 = 5, QuantizedSymm8PerAxis = 6, QSymmS8 = 7,   QAsymmS8 = 8, BFloat16 = 9, Signed64 = 10, QuantisedAsymm8 = QAsymmU8,   QuantisedSymm16 = QSymmS16 }
enum	DataLayout { NCHW = 1, NHWC = 2 }
enum	QosExecPriority { Low = 0, Medium = 1, High = 2 }
enum	ActivationFunction {   Sigmoid = 0, TanH = 1, Linear = 2, ReLu = 3,   BoundedReLu = 4, SoftReLu = 5, LeakyReLu = 6, Abs = 7,   Sqrt = 8, Square = 9, Elu = 10, HardSwish = 11 }
enum	ArgMinMaxFunction { Min = 0, Max = 1 }
enum	ComparisonOperation {   Equal = 0, Greater = 1, GreaterOrEqual = 2, Less = 3,   LessOrEqual = 4, NotEqual = 5 }
enum	LogicalBinaryOperation { LogicalAnd = 0, LogicalOr = 1 }
enum	UnaryOperation {   Abs = 0, Exp = 1, Sqrt = 2, Rsqrt = 3,   Neg = 4, LogicalNot = 5 }
enum	PoolingAlgorithm { Max = 0, Average = 1, L2 = 2 }
enum	ReduceOperation { Sum = 0, Max = 1, Mean = 2, Min = 3 }
enum	ResizeMethod { Bilinear = 0, NearestNeighbor = 1 }
enum	Dimensionality { NotSpecified = 0, Specified = 1, Scalar = 2 }
enum	PaddingMethod { IgnoreValue = 0, Exclude = 1 }
	The padding method modifies the output of pooling layers. More...
enum	NormalizationAlgorithmChannel { Across = 0, Within = 1 }
enum	NormalizationAlgorithmMethod { LocalBrightness = 0, LocalContrast = 1 }
enum	OutputShapeRounding { Floor = 0, Ceiling = 1 }
enum	ShapeInferenceMethod { ValidateOnly = 0, InferAndValidate = 1 }
	The ShapeInferenceMethod modify how the output shapes are treated. More...
enum	MemorySource : uint32_t { Undefined = 0, Malloc = 1, DmaBuf = 2, DmaBufProtected = 4 }
	Define the Memory Source to reduce copies. More...
enum	BackendCapability : uint32_t { NonConstWeights, AsyncExecution }
	BackendCapability class. More...
enum	LayerType {   X, Activation, Addition, ArgMinMax,   BatchNormalization, BatchToSpaceNd, Comparison, Concat,   Constant, ConvertBf16ToFp32, ConvertFp16ToFp32, ConvertFp32ToBf16,   ConvertFp32ToFp16, Convolution2d, Debug, DepthToSpace,   DepthwiseConvolution2d, Dequantize, DetectionPostProcess, Division,   ElementwiseUnary, FakeQuantization, Fill, Floor,   FullyConnected, Gather, Input, InstanceNormalization,   L2Normalization, LogicalBinary, LogSoftmax, Lstm,   QLstm, Map, Maximum, Mean,   MemCopy, MemImport, Merge, Minimum,   Multiplication, Normalization, Output, Pad,   Permute, Pooling2d, PreCompiled, Prelu,   Quantize, QuantizedLstm, Reshape, Rank,   Resize, Reduce, Slice, Softmax,   SpaceToBatchNd, SpaceToDepth, Splitter, Stack,   StandIn, StridedSlice, Subtraction, Switch,   Transpose, TransposeConvolution2d, Unmap, Cast,   FirstLayer = Activation, LastLayer = Cast }
	When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below. More...
enum	LogSeverity {   Trace, Debug, Info, Warning,   Error, Fatal }
enum	GraphEvent { LayerAdded, LayerErased }
enum	JsonObjectType { Measurement, Event }
enum	TuningLevel { None, Rapid, Normal, Exhaustive }

Functions
LayerSupportHandle	GetILayerSupportByBackendId (const armnn::BackendId &backend)
	Convenience function to retrieve the ILayerSupportHandle for a backend. More...
bool	IsCapabilitySupported (const armnn::BackendId &backend, armnn::BackendCapability capability)
	Convenience function to check a capability on a backend. More...
constexpr char const *	GetComputeDeviceAsCString (Compute compute)
	Deprecated function that will be removed together with the Compute enum. More...
std::ostream &	operator<< (std::ostream &os, const std::vector< Compute > &compute)
	Deprecated function that will be removed together with the Compute enum. More...
std::ostream &	operator<< (std::ostream &os, const std::set< Compute > &compute)
	Deprecated function that will be removed together with the Compute enum. More...
std::ostream &	operator<< (std::ostream &os, const Compute &compute)
	Deprecated function that will be removed together with the Compute enum. More...
std::ostream &	operator<< (std::ostream &os, const BackendId &id)
template<template< typename... > class TContainer, typename... TContainerTemplateArgs>
std::ostream &	operator<< (std::ostream &os, const TContainer< BackendId, TContainerTemplateArgs... > &ids)
template<typename F >
void	ParseOptions (const std::vector< BackendOptions > &options, BackendId backend, F f)
BackendRegistry &	BackendRegistryInstance ()
std::ostream &	operator<< (std::ostream &os, const BackendVersion &backendVersion)
template<typename TensorShapeIt >
OriginsDescriptor	CreateMergerDescriptorForConcatenation (TensorShapeIt first, TensorShapeIt last, unsigned int concatenationDimension)
template<typename TensorShapeIt >
OriginsDescriptor	CreateDescriptorForConcatenation (TensorShapeIt first, TensorShapeIt last, unsigned int concatenationDimension)
	Convenience template to create an OriginsDescriptor to use when creating a ConcatLayer for performing concatenation of a number of input tensors. More...
template<typename ExceptionType >
void	ConditionalThrow (bool condition, const std::string &message)
template<typename ExceptionType >
void	ConditionalThrow (bool condition)
template<typename ExceptionType , typename ComparedType >
void	ConditionalThrowIfNotEqual (const std::string &message, const ComparedType &leftHandSide, const ComparedType &rightHandSide)
	ComparedType must support: operator==(const ComparedType&) operator<<(ostream&, const ComparedType&) More...
IOptimizedNetworkPtr	Optimize (const INetwork &network, const std::vector< BackendId > &backendPreferences, const IDeviceSpec &deviceSpec, const OptimizerOptions &options=OptimizerOptions(), Optional< std::vector< std::string > &> messages=EmptyOptional())
	Create an optimized version of the network. More...
bool	IsActivationSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsAdditionSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsBatchNormalizationSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsBatchToSpaceNdSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsConcatSupported (const BackendId &backend, const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsConstantSupported (const BackendId &backend, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsConvertFp16ToFp32Supported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsConvertFp32ToFp16Supported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsConvolution2dSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsDebugSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsDepthwiseConvolutionSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsDequantizeSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsDivisionSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsEqualSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsFakeQuantizationSupported (const BackendId &backend, const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsFloorSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsFullyConnectedSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsGreaterSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsInputSupported (const BackendId &backend, const TensorInfo &input, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsL2NormalizationSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsLstmSupported (const BackendId &backend, 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 LstmInputParamsInfo &paramsInfo, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsMaximumSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnSupported=nullptr, size_t reasonIfUnSupportedMaxLength=0)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsMeanSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsMemCopySupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsMergeSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsMergerSupported (const BackendId &backend, const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsMinimumSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsMultiplicationSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsNormalizationSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsOutputSupported (const BackendId &backend, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsPadSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsPermuteSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsPreCompiledSupported (const BackendId &backend, const TensorInfo &input, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsPreluSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsPooling2dSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsQuantizedLstmSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsReduceSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsReshapeSupported (const BackendId &backend, const TensorInfo &input, const ReshapeDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsResizeBilinearSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsResizeSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsRsqrtSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsSoftmaxSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsSpaceToBatchNdSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsSpaceToDepthSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsSplitterSupported (const BackendId &backend, const TensorInfo &input, const ViewsDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
bool	IsSplitterSupported (const BackendId &backend, const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsStackSupported (const BackendId &backend, const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const StackDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsStridedSliceSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsSubtractionSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsSwitchSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output0, const TensorInfo &output1, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
bool	IsTransposeConvolution2dSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
	Deprecated in favor of IBackend and ILayerSupport interfaces. More...
std::string	LevelToString (LogSeverity level)
LogSeverity	StringToLogLevel (std::string level)
void	SetLogFilter (LogSeverity level)
void	SetAllLoggingSinks (bool standardOut, bool debugOut, bool coloured)
constexpr LogSeverity	ConvertLogSeverity (BoostLogSeverityMapping severity)
template<typename Arg , typename std::enable_if< IsMemorySource< Arg >::value >::type * = nullptr>
MemorySourceFlags	Combine (Arg sourceA, Arg sourceB)
template<typename Arg , typename ... Args, typename std::enable_if< IsMemorySource< Arg >::value >::type * = nullptr>
MemorySourceFlags	Combine (Arg source, Args... rest)
bool	CheckFlag (MemorySourceFlags flags, MemorySource source)
template<typename T , class... Args>
Optional< T >	MakeOptional (Args &&... args)
	Utility template that constructs an object of type T in-place and wraps it inside an Optional<T> object. More...
const char *	GetLayerTypeAsCString (LayerType type)
constexpr char const *	GetStatusAsCString (Status status)
constexpr char const *	GetActivationFunctionAsCString (ActivationFunction activation)
constexpr char const *	GetArgMinMaxFunctionAsCString (ArgMinMaxFunction function)
constexpr char const *	GetComparisonOperationAsCString (ComparisonOperation operation)
constexpr char const *	GetUnaryOperationAsCString (UnaryOperation operation)
constexpr char const *	GetLogicalBinaryOperationAsCString (LogicalBinaryOperation operation)
constexpr char const *	GetPoolingAlgorithmAsCString (PoolingAlgorithm pooling)
constexpr char const *	GetOutputShapeRoundingAsCString (OutputShapeRounding rounding)
constexpr char const *	GetPaddingMethodAsCString (PaddingMethod method)
constexpr char const *	GetReduceOperationAsCString (ReduceOperation reduce_operation)
constexpr unsigned int	GetDataTypeSize (DataType dataType)
template<unsigned N>
constexpr bool	StrEqual (const char *strA, const char(&strB)[N])
constexpr armnn::Compute	ParseComputeDevice (const char *str)
	Deprecated function that will be removed together with the Compute enum. More...
constexpr const char *	GetDataTypeName (DataType dataType)
constexpr const char *	GetDataLayoutName (DataLayout dataLayout)
constexpr const char *	GetNormalizationAlgorithmChannelAsCString (NormalizationAlgorithmChannel channel)
constexpr const char *	GetNormalizationAlgorithmMethodAsCString (NormalizationAlgorithmMethod method)
constexpr const char *	GetResizeMethodAsCString (ResizeMethod method)
template<typename T >
constexpr bool	IsQuantizedType ()
constexpr bool	IsQuantized8BitType (DataType dataType)
constexpr bool	IsQuantizedType (DataType dataType)
std::ostream &	operator<< (std::ostream &os, Status stat)
std::ostream &	operator<< (std::ostream &os, const armnn::TensorShape &shape)
template<typename QuantizedType >
QuantizedType	Quantize (float value, float scale, int32_t offset)
	Quantize a floating point data type into an 8-bit data type. More...
template<typename QuantizedType >
float	Dequantize (QuantizedType value, float scale, int32_t offset)
	Dequantize an 8-bit data type into a floating point data type. More...
void	VerifyTensorInfoDataType (const armnn::TensorInfo &info, armnn::DataType dataType)
template<typename ... Ts>
void	IgnoreUnused (Ts &&...)
template<typename Dest , typename Source >
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest >	numeric_cast (Source source)
template<typename Dest , typename Source >
std::enable_if_t< std::is_signed< Source >::value &&std::is_integral< Source >::value &&std::is_signed< Dest >::value &&std::is_integral< Dest >::value, Dest >	numeric_cast (Source source)
template<typename Dest , typename Source >
std::enable_if_t< std::is_floating_point< Source >::value &&std::is_floating_point< Dest >::value, Dest >	numeric_cast (Source source)
template<typename Dest , typename Source >
std::enable_if_t< std::is_floating_point< Source >::value &&std::is_signed< Dest >::value &&std::is_integral< Dest >::value, Dest >	numeric_cast (Source source)
template<typename Dest , typename Source >
std::enable_if_t< std::is_signed< Source >::value &&std::is_integral< Source >::value &&std::is_floating_point< Dest >::value, Dest >	numeric_cast (Source source)
template<typename Dest , typename Source >
std::enable_if_t< std::is_signed< Dest >::value &&std::is_integral< Dest >::value &&std::is_unsigned< Source >::value, Dest >	numeric_cast (Source sValue)
template<typename Dest , typename Source >
std::enable_if_t< std::is_floating_point< Dest >::value &&std::is_unsigned< Source >::value, Dest >	numeric_cast (Source sValue)
template<typename Dest , typename Source >
std::enable_if_t< std::is_unsigned< Dest >::value &&std::is_signed< Source >::value &&std::is_integral< Source >::value, Dest >	numeric_cast (Source sValue)
template<typename Dest , typename Source >
std::enable_if_t< std::is_unsigned< Dest >::value &&std::is_floating_point< Source >::value, Dest >	numeric_cast (Source sValue)
template<typename DestType , typename SourceType >
DestType	PolymorphicDowncast (SourceType value)
	Polymorphic downcast for build in pointers only. More...
template<typename DestType , typename SourceType >
auto	PolymorphicPointerDowncast (const SourceType &value)
	Polymorphic downcast for shared pointers and build in pointers. More...
std::chrono::high_resolution_clock::time_point	GetTimeNow ()
std::chrono::duration< double, std::milli >	GetTimeDuration (std::chrono::high_resolution_clock::time_point start_time)
template<typename Function , typename Iterator >
constexpr TransformIterator< Function, Iterator >	MakeTransformIterator (Iterator i, Function f)
void	ConfigureLogging (bool printToStandardOutput, bool printToDebugOutput, LogSeverity severity)
	Configures the logging behaviour of the ARMNN library. More...
bool	NeonDetected ()
const std::string	GetVersion ()
template<typename T >
bool	CompatibleTypes (DataType)
template<>
bool	CompatibleTypes< float > (DataType dataType)
template<>
bool	CompatibleTypes< Half > (DataType dataType)
template<>
bool	CompatibleTypes< BFloat16 > (DataType dataType)
template<>
bool	CompatibleTypes< uint8_t > (DataType dataType)
template<>
bool	CompatibleTypes< int8_t > (DataType dataType)
template<>
bool	CompatibleTypes< int16_t > (DataType dataType)
template<>
bool	CompatibleTypes< int32_t > (DataType dataType)
void	swap (OriginsDescriptor &first, OriginsDescriptor &second)
void	swap (ViewsDescriptor &first, ViewsDescriptor &second)
template<typename T >
constexpr LayerType	LayerEnumOf (const T *=nullptr)
template<>
constexpr LayerType	LayerEnumOf (const ActivationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const AdditionLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ArgMinMaxLayer *)
template<>
constexpr LayerType	LayerEnumOf (const BatchNormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const BatchToSpaceNdLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ComparisonLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ConcatLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ConstantLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertBf16ToFp32Layer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertFp16ToFp32Layer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertFp32ToBf16Layer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertFp32ToFp16Layer *)
template<>
constexpr LayerType	LayerEnumOf (const Convolution2dLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DebugLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DepthToSpaceLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DepthwiseConvolution2dLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DequantizeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DetectionPostProcessLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DivisionLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ElementwiseUnaryLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FakeQuantizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FillLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FloorLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FullyConnectedLayer *)
template<>
constexpr LayerType	LayerEnumOf (const GatherLayer *)
template<>
constexpr LayerType	LayerEnumOf (const InputLayer *)
template<>
constexpr LayerType	LayerEnumOf (const InstanceNormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const L2NormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const LogicalBinaryLayer *)
template<>
constexpr LayerType	LayerEnumOf (const LogSoftmaxLayer *)
template<>
constexpr LayerType	LayerEnumOf (const LstmLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MapLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MaximumLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MeanLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MemCopyLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MemImportLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MergeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MinimumLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MultiplicationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const NormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const OutputLayer *)
template<>
constexpr LayerType	LayerEnumOf (const PadLayer *)
template<>
constexpr LayerType	LayerEnumOf (const PermuteLayer *)
template<>
constexpr LayerType	LayerEnumOf (const Pooling2dLayer *)
template<>
constexpr LayerType	LayerEnumOf (const PreCompiledLayer *)
template<>
constexpr LayerType	LayerEnumOf (const PreluLayer *)
template<>
constexpr LayerType	LayerEnumOf (const QuantizeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const QLstmLayer *)
template<>
constexpr LayerType	LayerEnumOf (const QuantizedLstmLayer *)
template<>
constexpr LayerType	LayerEnumOf (const RankLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ReduceLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ReshapeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ResizeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SliceLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SoftmaxLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SpaceToBatchNdLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SpaceToDepthLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SplitterLayer *)
template<>
constexpr LayerType	LayerEnumOf (const StackLayer *)
template<>
constexpr LayerType	LayerEnumOf (const StandInLayer *)
template<>
constexpr LayerType	LayerEnumOf (const StridedSliceLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SubtractionLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SwitchLayer *)
template<>
constexpr LayerType	LayerEnumOf (const TransposeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const TransposeConvolution2dLayer *)
template<>
constexpr LayerType	LayerEnumOf (const UnmapLayer *)
template<>
constexpr LayerType	LayerEnumOf (const CastLayer *)
bool	CheckTensorDataTypesEqual (const TensorInfo &input0, const TensorInfo &input1)
bool	IsArgMinMaxSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
bool	IsConcatSupported (const BackendId &backend, std::vector< const TensorInfo *> inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
bool	IsDetectionPostProcessSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const DetectionPostProcessDescriptor &descriptor, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
bool	IsGatherSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
bool	IsGatherSupported (const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
bool	IsMemImportSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
bool	IsMergerSupported (const BackendId &backend, std::vector< const TensorInfo *> inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
bool	IsQuantizeSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
bool	IsQLstmSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &previousOutputIn, const TensorInfo &previousCellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
bool	IsReshapeSupported (const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, char *reasonIfUnsupported, size_t reasonIfUnsupportedMaxLength)
template<typename T , typename V >
void	SetValueChecked (Optional< T &> optionalRef, V &&val)
template<typename Float16Func , typename Float32Func , typename Uint8Func , typename Int32Func , typename BooleanFunc , typename ... Params>
bool	IsSupportedForDataTypeGeneric (Optional< std::string &> reasonIfUnsupported, DataType dataType, Float16Func float16FuncPtr, Float32Func float32FuncPtr, Uint8Func uint8FuncPtr, Int32Func int32FuncPtr, BooleanFunc booleanFuncPtr, Params &&... params)
template<typename ... Params>
bool	TrueFunc (Optional< std::string &> reasonIfUnsupported, Params &&... params)
template<typename ... Params>
bool	FalseFunc (Optional< std::string &> reasonIfUnsupported, Params &&... params)
template<typename ... Params>
bool	FalseFuncF16 (Optional< std::string &> reasonIfUnsupported, Params &&... params)
template<typename ... Params>
bool	FalseFuncF32 (Optional< std::string &> reasonIfUnsupported, Params &&... params)
template<typename ... Params>
bool	FalseFuncU8 (Optional< std::string &> reasonIfUnsupported, Params &&... params)
template<typename ... Params>
bool	FalseFuncI32 (Optional< std::string &> reasonIfUnsupported, Params &&... params)
template<typename ... Params>
bool	FalseInputFuncF32 (Optional< std::string &> reasonIfUnsupported, Params &&... params)
template<typename ... Params>
bool	FalseInputFuncF16 (Optional< std::string &> reasonIfUnsupported, Params &&... params)
template<typename ... Params>
bool	FalseOutputFuncF32 (Optional< std::string &> reasonIfUnsupported, Params &&... params)
template<typename ... Params>
bool	FalseOutputFuncF16 (Optional< std::string &> reasonIfUnsupported, Params &&... params)
const armnn::ConstTensor	GetInputTensor (const LayerBindingId layerId, const InputTensors &inputTensors)
const armnn::Tensor	GetOutputTensor (const LayerBindingId layerId, const OutputTensors &outputTensors)
template<LogSeverity Level>
void	SetLoggingSinks (bool standardOut, bool debugOut, bool coloured)
void	ReportError (const std::string &errorMessage, Optional< std::vector< std::string > &> errorMessages)
void	ReportWarning (const std::string &warningMessage, Optional< std::vector< std::string > &> warningMessages)
OptimizationResult	ReturnWithError (OptimizationResult res, const Layer *layer, const BackendSettings &backendSettings, Optional< std::vector< std::string > &> errMessages)
bool	CheckScaleSetOnQuantizedType (Layer *layer, Optional< std::vector< std::string > &> errMessages)
template<typename LayerT >
LayerT *	ConvertBf16ToFp32Weight (Layer *l)
OptimizationResult	AttemptBackendAssignment (BackendSettings &backendSettings, Graph &graph, Layer *layer, BackendId backend, DataType dataTypeIn, DataType dataTypeOut, const std::vector< BackendId > &availablePreferredBackends, std::string &reasonIfUnsupported, Optional< std::vector< std::string > &> errMessages)
OptimizationResult	AssignBackends (OptimizedNetworkImpl *optNetObjPtr, BackendSettings &backendSettings, Graph::Iterator &firstLayer, Graph::Iterator &lastLayer, Optional< std::vector< std::string > &> errMessages)
OptimizationResult	AssignBackends (OptimizedNetworkImpl *optNetObjPtr, BackendSettings &backendSettings, SubgraphView &subgraph, Optional< std::vector< std::string > &> errMessages)
BackendsMap	CreateSupportedBackends (TensorHandleFactoryRegistry &handleFactoryRegistry, BackendSettings &backendSettings)
OptimizationResult	ApplyBackendOptimizations (OptimizedNetworkImpl *optNetObjPtr, BackendSettings &backendSettings, BackendsMap &backends, const ModelOptions &modelOptions, Optional< std::vector< std::string > &> errMessages)
bool	RequiresCopy (ITensorHandleFactory::FactoryId src, ITensorHandleFactory::FactoryId dst, TensorHandleFactoryRegistry &registry)
ITensorHandleFactory::FactoryId	CalculateSlotOptionForInput (BackendsMap &backends, OutputSlot &slot, TensorHandleFactoryRegistry &registry, bool importEnabled)
ITensorHandleFactory::FactoryId	CalculateSlotOptionForOutput (BackendsMap &backends, OutputSlot &slot, TensorHandleFactoryRegistry &registry)
ITensorHandleFactory::FactoryId	CalculateSlotOption (BackendsMap &backends, OutputSlot &outputSlot, TensorHandleFactoryRegistry &registry, bool importEnabled)
EdgeStrategy	CalculateEdgeStrategy (BackendsMap &backends, ITensorHandleFactory::FactoryId srcFactoryId, const Layer &layer, const Layer &connectedLayer, TensorHandleFactoryRegistry &registry, bool importEnabled)
OptimizationResult	SelectTensorHandleStrategy (Graph &optGraph, BackendsMap &backends, TensorHandleFactoryRegistry &registry, bool importEnabled, Optional< std::vector< std::string > &> errMessages)
std::vector< ConvertBf16ToFp32Layer * >	InsertConvertBf16ToFp32LayersBefore (Graph &graph, Layer &layer, bool expectCorrectInputType)
std::vector< ConvertFp32ToBf16Layer * >	InsertConvertFp32ToBf16LayersBefore (Graph &graph, Layer &layer, bool expectCorrectInputType)
std::vector< ConvertFp16ToFp32Layer * >	InsertConvertFp16ToFp32LayersBefore (Graph &graph, Layer &layer, bool expectCorrectInputType)
std::vector< ConvertFp32ToBf16Layer * >	InsertConvertFp32ToBf16LayersAfter (Graph &graph, Layer &layer)
std::vector< ConvertFp32ToFp16Layer * >	InsertConvertFp32ToFp16LayersAfter (Graph &graph, Layer &layer)
std::vector< DebugLayer * >	InsertDebugLayerAfter (Graph &graph, Layer &layer)
template<typename T >
void	Append (Optimizer::Optimizations &optimizations, T &&optimization)
template<typename Front , typename... Others>
void	Append (Optimizer::Optimizations &optimizations, Front &&front, Others &&... others)
template<typename... Args>
Optimizer::Optimizations	MakeOptimizations (Args &&... args)
Measurement	FindMeasurement (const std::string &name, const Event *event)
std::vector< Measurement >	FindKernelMeasurements (const Event *event)
const Event *	GetEventPtr (const Event *ptr)
const Event *	GetEventPtr (const std::unique_ptr< Event > &ptr)
int	CalcLevel (const Event *eventPtr)
void	ExtractJsonObjects (unsigned int inferenceIndex, const Event *parentEvent, JsonChildObject &parentObject, std::map< const Event *, std::vector< const Event *>> descendantsMap)
template<typename Delegate >
void	ForEachLayerInput (LayerSelectionInfo::LayerInfoContainer &layerInfos, LayerSelectionInfo &layerInfo, Delegate function)
template<typename Delegate >
void	ForEachLayerOutput (LayerSelectionInfo::LayerInfoContainer &layerInfos, LayerSelectionInfo &layerInfo, Delegate function)
void	AssignSplitId (LayerSelectionInfo::LayerInfoContainer &layerInfos, LayerSelectionInfo &layerInfo)
bool	IsReadyForSplitAssignment (LayerSelectionInfo::LayerInfoContainer &layerInfos, LayerSelectionInfo &layerInfo)
	BOOST_AUTO_TEST_CASE (CheckConvolution2dLayer)
	BOOST_AUTO_TEST_CASE (CheckNamedConvolution2dLayer)
	BOOST_AUTO_TEST_CASE (CheckConvolution2dLayerWithBiases)
	BOOST_AUTO_TEST_CASE (CheckNamedConvolution2dLayerWithBiases)
	BOOST_AUTO_TEST_CASE (CheckDepthwiseConvolution2dLayer)
	BOOST_AUTO_TEST_CASE (CheckNamedDepthwiseConvolution2dLayer)
	BOOST_AUTO_TEST_CASE (CheckDepthwiseConvolution2dLayerWithBiases)
	BOOST_AUTO_TEST_CASE (CheckNamedDepthwiseConvolution2dLayerWithBiases)
	BOOST_AUTO_TEST_CASE (CheckFullyConnectedLayer)
	BOOST_AUTO_TEST_CASE (CheckNamedFullyConnectedLayer)
	BOOST_AUTO_TEST_CASE (CheckFullyConnectedLayerWithBiases)
	BOOST_AUTO_TEST_CASE (CheckNamedFullyConnectedLayerWithBiases)
	BOOST_AUTO_TEST_CASE (CheckBatchNormalizationLayer)
	BOOST_AUTO_TEST_CASE (CheckNamedBatchNormalizationLayer)
	BOOST_AUTO_TEST_CASE (CheckConstLayer)
	BOOST_AUTO_TEST_CASE (CheckNamedConstLayer)
	BOOST_AUTO_TEST_CASE (CheckLstmLayerBasic)
	BOOST_AUTO_TEST_CASE (CheckNamedLstmLayerBasic)
	BOOST_AUTO_TEST_CASE (CheckLstmLayerCifgDisabled)
	BOOST_AUTO_TEST_CASE (CheckNamedLstmLayerCifgDisabled)
	BOOST_AUTO_TEST_CASE (CheckLstmLayerPeephole)
	BOOST_AUTO_TEST_CASE (CheckLstmLayerPeepholeCifgDisabled)
	BOOST_AUTO_TEST_CASE (CheckNamedLstmLayerPeephole)
	BOOST_AUTO_TEST_CASE (CheckLstmLayerProjection)
	BOOST_AUTO_TEST_CASE (CheckNamedLstmLayerProjection)
	BOOST_AUTO_TEST_CASE (CheckQLstmLayerBasic)
	BOOST_AUTO_TEST_CASE (CheckNamedQLstmLayerBasic)
	BOOST_AUTO_TEST_CASE (CheckQLstmLayerCifgDisabled)
	BOOST_AUTO_TEST_CASE (CheckQLstmLayerCifgDisabledPeepholeEnabled)
	BOOST_AUTO_TEST_CASE (CheckQLstmLayerCifgEnabledPeepholeEnabled)
	BOOST_AUTO_TEST_CASE (CheckQLstmLayerProjectionEnabled)
	BOOST_AUTO_TEST_CASE (CheckQLstmLayerCifgDisabledLayerNormEnabled)
	BOOST_AUTO_TEST_CASE (CheckQuantizedLstmLayer)
	BOOST_AUTO_TEST_CASE (CheckNamedQuantizedLstmLayer)
template<typename T >
std::vector< T >	GetVector (unsigned int size, float initial, float increment)
template<typename LayerTest , DataType ArmnnType>
INetworkPtr	CreatNetwork (ActivationDescriptor activationDescriptor, bool preventFusing, float scale, int32_t offset)
template<typename LayerTest , DataType ArmnnType, typename LayerType = typename LayerTest::LayerType, typename T = ResolveType<ArmnnType>>
void	FuseActivationIntoPreviousLayerTest (ActivationDescriptor activationDescriptor, float tolerance, Compute backendId, float scale=1.f, int32_t offset=0)
template<typename LayerTest , DataType ArmnnType, typename LayerType = typename LayerTest::LayerType, typename T = ResolveType<ArmnnType>>
bool	FuseActivationSimpleTest (ActivationDescriptor activationDescriptor, Compute backendId, float scale=1.f, int32_t offset=0)
size_t	GetProfilerEventSequenceSize (armnn::IProfiler *profiler)
void	RuntimeLoadedNetworksReserve (armnn::RuntimeImpl *runtime)
std::ostream &	boost_test_print_type (std::ostream &ostr, const TensorInfo &right)
std::ostream &	boost_test_print_type (std::ostream &ostr, const TensorShape &shape)
	BOOST_AUTO_TEST_CASE (CheckInputLayerVisitorBindingIdAndName)
	BOOST_AUTO_TEST_CASE (CheckInputLayerVisitorBindingIdAndNameNull)
	BOOST_AUTO_TEST_CASE (CheckOutputLayerVisitorBindingIdAndName)
	BOOST_AUTO_TEST_CASE (CheckOutputLayerVisitorBindingIdAndNameNull)
void	CheckLayerBindingId (LayerBindingId visitorId, LayerBindingId id)
Graph &	GetGraphForTesting (IOptimizedNetwork *optNet)
ModelOptions &	GetModelOptionsForTesting (IOptimizedNetwork *optNet)
profiling::ProfilingService &	GetProfilingService (armnn::RuntimeImpl *runtime)
std::ostream &	operator<< (std::ostream &os, const BFloat16 &b)
void	ReportUntouchedLayers (OptimizationViews &optimizationViews, std::map< LayerGuid, Layer *> untouched)
template<typename LayerType >
LayerType *	FuseLayerWithoutParameters (OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
template<typename LayerType >
LayerType *	FuseLayerWithParameters (OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
template<typename LayerType >
LayerType *	FuseLayerWithWeightsAndBiases (OptimizationViews &optimizationViews, LayerType *baseLayer, ActivationLayer *activationLayer, ActivationDescriptor &activationDesc, std::string name)
arm_compute::NormalizationLayerInfo	CreateAclNormalizationLayerInfoForL2Normalization (const armnn::TensorInfo &tensorInfo, armnn::DataLayout dataLayout)
arm_compute::ActivationLayerInfo::ActivationFunction	ConvertActivationFunctionToAclActivationFunction (ActivationFunction armnnFunction)
arm_compute::ActivationLayerInfo	ConvertActivationDescriptorToAclActivationLayerInfo (const ActivationDescriptor &actDesc)
arm_compute::ActivationLayerInfo	ConvertActivationDescriptorToAclActivationLayerInfo (const ActivationDescriptor *activationDescPtr)
arm_compute::ActivationLayerInfo	ConvertAdditionalInfoToAclActivationLayerInfo (const QueueDescriptor &queueDescriptor)
arm_compute::ComparisonOperation	ConvertComparisonOperationToAcl (const ComparisonDescriptor &descriptor)
arm_compute::PoolingType	ConvertPoolingAlgorithmToAclPoolingType (PoolingAlgorithm poolingAlgorithm)
arm_compute::DimensionRoundingType	ConvertOutputShapeRoundingToAclDimensionRoundingType (OutputShapeRounding rounding)
arm_compute::NormType	ConvertNormalizationAlgorithmChannelToAclNormType (NormalizationAlgorithmChannel channelType)
arm_compute::FullyConnectedLayerInfo	ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo (const FullyConnectedDescriptor &fullyConnectedDesc, const ActivationDescriptor *activationDesc)
arm_compute::FullyConnectedLayerInfo	ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo (const FullyConnectedDescriptor &fullyConnectedDesc, arm_compute::ActivationLayerInfo activationLayerInfo)
arm_compute::InterpolationPolicy	ConvertResizeMethodToAclInterpolationPolicy (ResizeMethod resizeMethod)
template<typename T >
T	ComputeSoftmaxAclAxis (const SoftmaxDescriptor &softmaxDesc, const armnn::TensorInfo &tensor)
std::set< unsigned int >	ComputeSplitAxis (const armnn::SplitterDescriptor &desc, const TensorShape &input)
int	ComputeAclAxis (const int &armnnAxis, const armnn::TensorInfo &tensor)
	Function to convert ArmNN axis (left to right) to ACL axis (right to left) ranging from [-rank, rank) More...
unsigned int	ComputePositiveAxis (const int &axis, const armnn::TensorInfo &tensor)
	Function to convert axis to its positive equivalent value. More...
arm_compute::ReductionOperation	ConvertReductionOperationToAcl (const ReduceDescriptor &descriptor)
armnn::Optional< armnn::DataType >	GetBiasTypeFromWeightsType (armnn::Optional< armnn::DataType > weightsType)
template<typename F >
bool	CheckSupportRule (F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
template<typename T >
bool	AllTypesAreEqualImpl (T)
template<typename T , typename... Rest>
bool	AllTypesAreEqualImpl (T t1, T t2, Rest... rest)
TensorShape	GetUnpaddedTensorStrides (const TensorInfo &tensorInfo)
constexpr const char *	MockImportBackendId ()
constexpr const char *	MockBackendId ()
DataType	GetBiasDataType (DataType inputDataType)
armnn::ConstTensor	PermuteTensor (const ConstTensorHandle *tensor, const PermutationVector &permutationVector, void *permuteBuffer)
void	ReshapeWeightsForAcl (TensorInfo &weightInfo, DataLayout dataLayout)
template<typename DataType >
ConstTensor	ReorderWeightChannelsForAcl (const ConstTensor &weightHandle, DataLayout dataLayout, void *permuteBuffer)
TensorInfo	ConvertWeightTensorInfoFromArmnnToAcl (const TensorInfo &weightInfo, DataLayout dataLayout)
armnn::ConstTensor	ConvertWeightTensorFromArmnnToAcl (const ConstTensorHandle *weightTensor, DataLayout dataLayout, void *permuteBuffer)
int32_t	ConvertMaskToACLFormat (int32_t mask, int32_t numDim)
template<typename CopyFunc >
void	CopyTensorContentsGeneric (const ITensorHandle *srcTensor, ITensorHandle *dstTensor, CopyFunc copy)
template<typename SrcTensorHandleType , typename DstTensorHandleType , typename DescriptorType >
void	GatherTensorHandlePairs (const DescriptorType &descriptor, std::vector< std::pair< SrcTensorHandleType *, DstTensorHandleType *>> &tensorHandlePairs)
std::string	LowerString (std::string value)
TuningLevel	ParseTuningLevel (const BackendOptions::Var &value, TuningLevel defaultValue)
bool	ParseBoolean (const BackendOptions::Var &value, bool defaultValue)
std::string	ParseFile (const BackendOptions::Var &value, std::string defaultValue)
void	ConfigureTuner (arm_compute::CLTuner &tuner, TuningLevel level)
constexpr const char *	ClBackendId ()
flatbuffers::Offset< ClContext >	CreateClContext (flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< armnn::Program >>> programs=0)
flatbuffers::Offset< ClContext >	CreateClContextDirect (flatbuffers::FlatBufferBuilder &_fbb, const std::vector< flatbuffers::Offset< armnn::Program >> *programs=nullptr)
flatbuffers::Offset< Program >	CreateProgram (flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::String > name=0, flatbuffers::Offset< flatbuffers::Vector< uint8_t >> binary=0)
flatbuffers::Offset< Program >	CreateProgramDirect (flatbuffers::FlatBufferBuilder &_fbb, const char *name=nullptr, const std::vector< uint8_t > *binary=nullptr)
const armnn::ClContext *	GetClContext (const void *buf)
const armnn::ClContext *	GetSizePrefixedClContext (const void *buf)
const char *	ClContextIdentifier ()
bool	ClContextBufferHasIdentifier (const void *buf)
bool	VerifyClContextBuffer (flatbuffers::Verifier &verifier)
bool	VerifySizePrefixedClContextBuffer (flatbuffers::Verifier &verifier)
const char *	ClContextExtension ()
void	FinishClContextBuffer (flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< armnn::ClContext > root)
void	FinishSizePrefixedClContextBuffer (flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< armnn::ClContext > root)
constexpr const char *	ClImportTensorHandleFactoryId ()
constexpr const char *	ClTensorHandleFactoryId ()
arm_compute::Status	ClAbsWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClActivationWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor)
arm_compute::Status	ClAdditionValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	ClArgMinMaxWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor)
arm_compute::Status	ClBatchNormalizationValidate (const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &desc, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	ClBatchToSpaceNdWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &desc)
arm_compute::Status	ClCastValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClComparisonWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor)
arm_compute::Status	ClConcatWorkloadValidate (const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const OriginsDescriptor &descriptor)
arm_compute::Status	ClConstantWorkloadValidate (const TensorInfo &output)
arm_compute::Status	ClConvertFp16ToFp32WorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClConvertFp32ToFp16WorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClConvolution2dWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, bool isFastMathEnabled, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	ClDepthToSpaceWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &desc)
arm_compute::Status	ClDepthwiseConvolutionWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	ClDequantizeWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClDivisionWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	ClExpWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClFloorWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClFullyConnectedWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	ClGatherWorkloadValidate (const TensorInfo &input, const TensorInfo &indices, const TensorInfo &output, const GatherDescriptor &descriptor)
arm_compute::Status	ClInstanceNormalizationWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor)
arm_compute::Status	ClL2NormalizationWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor)
arm_compute::Status	ClLogicalAndWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
arm_compute::Status	ClLogicalNotWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClLogicalOrWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
arm_compute::Status	ClLogSoftmaxWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor)
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 LstmInputParamsInfo &paramsInfo)
arm_compute::Status	ClMaximumWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
arm_compute::Status	ClMeanValidate (const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &desc)
arm_compute::Status	ClMinimumWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
arm_compute::Status	ClMultiplicationWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	ClNegWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClNormalizationWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor)
arm_compute::Status	ClPadValidate (const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor)
arm_compute::Status	ClPermuteWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor)
arm_compute::Status	ClPooling2dWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor)
arm_compute::Status	ClPreluWorkloadValidate (const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output)
arm_compute::Status	ClQLstmWorkloadValidate (const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
arm_compute::Status	ClQuantizedLstmWorkloadValidate (const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo)
arm_compute::Status	ClQuantizeWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClReduceWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &desc)
arm_compute::Status	ClReshapeWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClResizeWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor)
arm_compute::Status	ClRsqrtWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	ClSliceWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor)
arm_compute::Status	ClSoftmaxWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor)
arm_compute::Status	ClSpaceToBatchNdWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor)
arm_compute::Status	ClSpaceToDepthWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &desc)
arm_compute::Status	ClSplitterWorkloadValidate (const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, unsigned int splitAxis)
arm_compute::Status	ClStackWorkloadValidate (const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const StackDescriptor &descriptor)
arm_compute::Status	ClStridedSliceWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor)
arm_compute::Status	ClSubtractionValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	ClTransposeConvolution2dWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases)
arm_compute::Status	ClTransposeWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor)
template<typename T >
void	CopyArmComputeClTensorData (arm_compute::CLTensor &dstTensor, const T *srcData)
auto	SetClStridedSliceData (const std::vector< int > &m_begin, const std::vector< int > &m_end, const std::vector< int > &m_stride)
auto	SetClSliceData (const std::vector< unsigned int > &m_begin, const std::vector< unsigned int > &m_size)
void	InitializeArmComputeClTensorData (arm_compute::CLTensor &clTensor, const ConstTensorHandle *handle)
RuntimeException	WrapClError (const cl::Error &clError, const CheckLocation &location)
void	RunClFunction (arm_compute::IFunction &function, const CheckLocation &location)
template<typename DataType , typename PayloadType >
DataType *	GetOutputTensorData (unsigned int idx, const PayloadType &data)
constexpr const char *	NeonBackendId ()
constexpr const char *	NeonTensorHandleFactoryId ()
arm_compute::Status	NeonAbsWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	NeonActivationWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor)
arm_compute::Status	NeonAdditionWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	NeonArgMinMaxWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor)
arm_compute::Status	NeonBatchNormalizationValidate (const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	NeonBatchToSpaceNdWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &desc)
arm_compute::Status	NeonCastValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	NeonComparisonWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor)
arm_compute::Status	NeonConcatWorkloadValidate (const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const OriginsDescriptor &descriptor)
arm_compute::Status	NeonConstantWorkloadValidate (const TensorInfo &output)
arm_compute::Status	NeonConvolution2dWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, bool isFastMathEnabled, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	NeonDepthToSpaceWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor)
arm_compute::Status	NeonDepthwiseConvolutionWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	NeonDequantizeWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::DetectionPostProcessLayerInfo	MakeInfo (const DetectionPostProcessDescriptor &desc)
arm_compute::Status	NeonDetectionPostProcessValidate (const TensorInfo &boxEncodings, const TensorInfo &scores, const TensorInfo &anchors, const TensorInfo &detectionBoxes, const TensorInfo &detectionClasses, const TensorInfo &detectionScores, const TensorInfo &numDetections, const DetectionPostProcessDescriptor &desc)
arm_compute::Status	NeonDivisionWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	NeonExpWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	NeonFullyConnectedWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	NeonGatherWorkloadValidate (const TensorInfo &input, const TensorInfo &indices, const TensorInfo &output, const GatherDescriptor &descriptor)
arm_compute::Status	NeonInstanceNormalizationWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor)
arm_compute::Status	NeonL2NormalizationWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor)
arm_compute::Status	NeonLogicalAndWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
arm_compute::Status	NeonLogicalNotWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	NeonLogicalOrWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
arm_compute::Status	NeonLogSoftmaxWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor)
arm_compute::Status	NeonLstmFloatWorkloadValidate (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 LstmInputParamsInfo &paramsInfo)
arm_compute::Status	NeonMaximumWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
arm_compute::Status	NeonMeanWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &desc)
arm_compute::Status	NeonMinimumWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
	Validate function for validating the inputs and output. More...
arm_compute::Status	NeonMultiplicationWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	NeonNegWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	NeonNormalizationWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor)
arm_compute::Status	NeonPadWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor)
arm_compute::Status	NeonPermuteWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor)
arm_compute::Status	NeonPooling2dWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor)
arm_compute::Status	NeonPreluWorkloadValidate (const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output)
arm_compute::Status	NeonQLstmWorkloadValidate (const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
arm_compute::Status	NeonQuantizedLstmWorkloadValidate (const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const QuantizedLstmInputParamsInfo &paramsInfo)
arm_compute::Status	NeonQuantizeWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	NeonReduceWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &desc)
arm_compute::Status	NeonReshapeWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	NeonResizeWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor)
arm_compute::Status	NeonRsqrtWorkloadValidate (const TensorInfo &input, const TensorInfo &output)
arm_compute::Status	NeonSliceWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor)
arm_compute::Status	NeonSoftmaxWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor)
arm_compute::Status	NeonSpaceToBatchNdWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor)
arm_compute::Status	NeonSpaceToDepthWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor)
arm_compute::Status	NeonSplitterWorkloadValidate (const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, unsigned int splitAxis)
arm_compute::Status	NeonStackWorkloadValidate (const std::vector< const TensorInfo *> &inputs, const TensorInfo &output, const StackDescriptor &descriptor)
arm_compute::Status	NeonStridedSliceWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor)
arm_compute::Status	NeonSubtractionWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
arm_compute::Status	NeonTransposeConvolution2dWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases)
arm_compute::Status	NeonTransposeWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor)
template<typename T >
void	CopyArmComputeTensorData (arm_compute::Tensor &dstTensor, const T *srcData)
void	InitializeArmComputeTensorData (arm_compute::Tensor &tensor, const ConstTensorHandle *handle)
auto	SetNeonStridedSliceData (const std::vector< int > &m_begin, const std::vector< int > &m_end, const std::vector< int > &m_stride)
auto	SetNeonSliceData (const std::vector< unsigned int > &m_begin, const std::vector< unsigned int > &m_size)
constexpr const char *	RefBackendId ()
constexpr const char *	RefTensorHandleFactoryId ()
template<DataType ArmnnType>
bool	IsDataType (const WorkloadInfo &info)
bool	IsSigned32 (const WorkloadInfo &info)
bool	IsBFloat16 (const WorkloadInfo &info)
bool	IsFloat16 (const WorkloadInfo &info)
bool	IsQSymmS16 (const WorkloadInfo &info)
bool	IsQSymmS8 (const WorkloadInfo &info)
bool	IsQAsymmS8 (const WorkloadInfo &info)
bool	IsQAsymmU8 (const WorkloadInfo &info)
template<typename QueueDescriptorType >
constexpr bool	IsOperationQueueDescriptor (const QueueDescriptorType &)
template<>
constexpr bool	IsOperationQueueDescriptor (const MemCopyQueueDescriptor &)
template<>
constexpr bool	IsOperationQueueDescriptor (const ConstantQueueDescriptor &)
template<>
constexpr bool	IsOperationQueueDescriptor (const PermuteQueueDescriptor &)
float	Activation (float in, ActivationFunction function, float a, float b)
void	Activation (Decoder< float > &in, Encoder< float > &out, const TensorInfo &tensorInfo, ActivationFunction function, float a, float b)
template<typename OUT >
void	ArgMinMax (Decoder< float > &in, OUT *out, const TensorInfo &inputTensorInfo, const TensorInfo &outputTensorInfo, ArgMinMaxFunction function, int axis)
template void	ArgMinMax (Decoder< float > &in, int32_t *out, const TensorInfo &inputTensorInfo, const TensorInfo &outputTensorInfo, ArgMinMaxFunction function, int axis)
template void	ArgMinMax (Decoder< float > &in, int64_t *out, const TensorInfo &inputTensorInfo, const TensorInfo &outputTensorInfo, ArgMinMaxFunction function, int axis)
void	BatchNormImpl (const BatchNormalizationQueueDescriptor &data, Decoder< float > &meanDecoder, Decoder< float > &varianceDecoder, Decoder< float > &betaDecoder, Decoder< float > &gammaDecoder, Decoder< float > &inputDecoder, Encoder< float > &outputEncoder)
unsigned int	Offset (const TensorShape &shape, unsigned int batch, unsigned int height, unsigned int width, unsigned int channels, const DataLayoutIndexed &dataLayout)
void	BatchToSpaceNd (const DataLayoutIndexed &dataLayout, const TensorInfo &inputTensorInfo, const TensorInfo &outputTensorInfo, const std::vector< unsigned int > &blockShape, const std::vector< std::pair< unsigned int, unsigned int >> &cropsData, Decoder< float > &inputDecoder, Encoder< float > &outputEncoder)
void	Concatenate (const ConcatQueueDescriptor &data, std::vector< ITensorHandle *> inputs, std::vector< ITensorHandle *> outputs)
void	Convolve (const TensorShape &rInputShape, Decoder< float > &rInputDecoder, const TensorShape &rOutputShape, Encoder< float > &rOutputEncoder, const TensorShape &rFilterShape, Decoder< float > &rFilterDecoder, bool biasEnabled, Decoder< float > *pBiasDecoder, DataLayout dataLayout, unsigned int paddingTop, unsigned int paddingLeft, unsigned int xStride, unsigned int yStride, unsigned int xDilation, unsigned int yDilation, bool depthwise)
template<typename T >
void	Debug (const TensorInfo &inputInfo, const T *inputData, LayerGuid guid, const std::string &layerName, unsigned int slotIndex)
template void	Debug< BFloat16 > (const TensorInfo &inputInfo, const BFloat16 *inputData, LayerGuid guid, const std::string &layerName, unsigned int slotIndex)
template void	Debug< Half > (const TensorInfo &inputInfo, const Half *inputData, LayerGuid guid, const std::string &layerName, unsigned int slotIndex)
template void	Debug< float > (const TensorInfo &inputInfo, const float *inputData, LayerGuid guid, const std::string &layerName, unsigned int slotIndex)
template void	Debug< uint8_t > (const TensorInfo &inputInfo, const uint8_t *inputData, LayerGuid guid, const std::string &layerName, unsigned int slotIndex)
template void	Debug< int8_t > (const TensorInfo &inputInfo, const int8_t *inputData, LayerGuid guid, const std::string &layerName, unsigned int slotIndex)
template void	Debug< int16_t > (const TensorInfo &inputInfo, const int16_t *inputData, LayerGuid guid, const std::string &layerName, unsigned int slotIndex)
template void	Debug< int32_t > (const TensorInfo &inputInfo, const int32_t *inputData, LayerGuid guid, const std::string &layerName, unsigned int slotIndex)
template<typename T >
std::unique_ptr< Decoder< T > >	MakeDecoder (const TensorInfo &info, const void *data=nullptr)
template<>
std::unique_ptr< Decoder< float > >	MakeDecoder (const TensorInfo &info, const void *data)
template<>
std::unique_ptr< Decoder< bool > >	MakeDecoder (const TensorInfo &info, const void *data)
template<>
std::unique_ptr< Decoder< int32_t > >	MakeDecoder (const TensorInfo &info, const void *data)
void	DepthToSpace (const TensorInfo &inputInfo, const DepthToSpaceDescriptor &descriptor, const void *inputData, void *outputData, unsigned int dataTypeSize)
void	Dequantize (Decoder< float > &inputDecoder, Encoder< float > &outputEncoder, const TensorInfo &inputInfo, const TensorInfo &outputInfo)
std::vector< unsigned int >	GenerateRangeK (unsigned int k)
void	TopKSort (unsigned int k, unsigned int *indices, const float *values, unsigned int numElement)
float	IntersectionOverUnion (const float *boxI, const float *boxJ)
std::vector< unsigned int >	NonMaxSuppression (unsigned int numBoxes, const std::vector< float > &boxCorners, const std::vector< float > &scores, float nmsScoreThreshold, unsigned int maxDetection, float nmsIouThreshold)
void	AllocateOutputData (unsigned int numOutput, unsigned int numSelected, const std::vector< float > &boxCorners, const std::vector< unsigned int > &outputIndices, const std::vector< unsigned int > &selectedBoxes, const std::vector< unsigned int > &selectedClasses, const std::vector< float > &selectedScores, float *detectionBoxes, float *detectionScores, float *detectionClasses, float *numDetections)
void	DetectionPostProcess (const TensorInfo &boxEncodingsInfo, const TensorInfo &scoresInfo, const TensorInfo &anchorsInfo, const TensorInfo &detectionBoxesInfo, const TensorInfo &detectionClassesInfo, const TensorInfo &detectionScoresInfo, const TensorInfo &numDetectionsInfo, const DetectionPostProcessDescriptor &desc, Decoder< float > &boxEncodings, Decoder< float > &scores, Decoder< float > &anchors, float *detectionBoxes, float *detectionClasses, float *detectionScores, float *numDetections)
template<typename T >
std::unique_ptr< Encoder< T > >	MakeEncoder (const TensorInfo &info, void *data=nullptr)
template<>
std::unique_ptr< Encoder< float > >	MakeEncoder (const TensorInfo &info, void *data)
template<>
std::unique_ptr< Encoder< bool > >	MakeEncoder (const TensorInfo &info, void *data)
template<>
std::unique_ptr< Encoder< int32_t > >	MakeEncoder (const TensorInfo &info, void *data)
void	Fill (Encoder< float > &output, const TensorShape &desiredOutputShape, const float value)
	Creates a tensor and fills it with a scalar value. More...
void	FullyConnected (const TensorShape &rInputShape, Decoder< float > &rInputDecoder, const TensorShape &rOutputShape, Encoder< float > &rOutputEncoder, const TensorShape &rWeightsShape, Decoder< float > &rWeightDecoder, Decoder< float > &rBiasDecoder, bool biasEnabled, unsigned int K, bool transposeWeights)
	Performs a matrix multiplication and optionally adds a bias. More...
void	Gather (const TensorInfo &paramsInfo, const TensorInfo &indicesInfo, const TensorInfo &outputInfo, Decoder< float > &params, const int32_t *indices, Encoder< float > &output, const int32_t axis)
void	InstanceNorm (const InstanceNormalizationQueueDescriptor &data, const TensorInfo &inputInfo, Decoder< float > &inputDecoder, Encoder< float > &outputEncoder)
void	LogSoftmax (Decoder< float > &input, Encoder< float > &output, const TensorInfo &inputInfo, const LogSoftmaxDescriptor &descriptor)
void	Pad (const TensorInfo &inputInfo, const TensorInfo &outputInfo, const ITensorHandle *inputHandle, ITensorHandle *outputHandle, const PadQueueDescriptor &data)
void	Pooling2d (Decoder< float > &rInputDecoder, Encoder< float > &rOutputEncoder, const TensorInfo &inputInfo, const TensorInfo &outputInfo, const Pooling2dDescriptor &params)
	Computes the Pooling2d operation. More...
void	PreluImpl (const TensorInfo &inputInfo, const TensorInfo &alphaInfo, const TensorInfo &outputInfo, Decoder< float > &inputData, Decoder< float > &alphaData, Encoder< float > &outputData)
bool	NextIndex (const unsigned int numDims, const armnn::TensorShape &dims, std::vector< unsigned int > &current)
unsigned int	ReducedOutputOffset (const unsigned int numDims, const armnn::TensorShape &dims, std::vector< unsigned int > &index, const unsigned int numAxis, const std::vector< unsigned int > &axis)
void	Reduce (const TensorInfo &inputInfo, const TensorInfo &outputInfo, Decoder< float > &input, Encoder< float > &output, const std::vector< uint32_t > axis, const ReduceOperation reduceOperation)
void	FakeQuantization (const float *inputData, float *outputData, uint32_t numElements, float min, float max)
const TensorInfo &	GetTensorInfo (const ITensorHandle *tensorHandle)
	float32 helpers More...
template<typename DataType , typename PayloadType >
const DataType *	GetInputTensorData (unsigned int idx, const PayloadType &data)
template<typename DataType >
DataType *	GetOutputTensorData (ITensorHandle *tensorHandle)
template<typename PayloadType >
const float *	GetInputTensorDataFloat (unsigned int idx, const PayloadType &data)
template<typename PayloadType >
float *	GetOutputTensorDataFloat (unsigned int idx, const PayloadType &data)
template<typename PayloadType >
const Half *	GetInputTensorDataHalf (unsigned int idx, const PayloadType &data)
template<typename PayloadType >
Half *	GetOutputTensorDataHalf (unsigned int idx, const PayloadType &data)
template<typename PayloadType >
const BFloat16 *	GetInputTensorDataBFloat16 (unsigned int idx, const PayloadType &data)
template<typename PayloadType >
BFloat16 *	GetOutputTensorDataBFloat16 (unsigned int idx, const PayloadType &data)
template<typename T >
std::vector< float >	Dequantize (const T *quant, const TensorInfo &info)
	u8 helpers More...
template<typename T >
void	Dequantize (const T *inputData, float *outputData, const TensorInfo &info)
void	Quantize (uint8_t *quant, const float *dequant, const TensorInfo &info)
void	Resize (Decoder< float > &in, const TensorInfo &inputInfo, Encoder< float > &out, const TensorInfo &outputInfo, DataLayoutIndexed dataLayout, armnn::ResizeMethod resizeMethod, bool alignCorners, bool halfPixelCenters)
void	Slice (const TensorInfo &inputInfo, const SliceDescriptor &descriptor, const void *inputData, void *outputData, unsigned int dataTypeSize)
void	Softmax (Decoder< float > &in, Encoder< float > &out, const TensorInfo &inputTensorInfo, float beta, int axis)
	Computes the softmax function on some inputs, into outputs, with a shape given by tensorInfo. More...
unsigned int	GetOffset (const TensorShape &shape, unsigned int b, unsigned int h, unsigned int w, unsigned int c, const DataLayoutIndexed &dataLayout)
void	SpaceToBatchNd (const TensorInfo &inputInfo, const TensorInfo &outputInfo, const SpaceToBatchNdDescriptor &params, Decoder< float > &inputData, Encoder< float > &outputData)
void	SpaceToDepth (const TensorInfo &inputInfo, const TensorInfo &outputInfo, const SpaceToDepthDescriptor &params, Decoder< float > &inputData, Encoder< float > &outputData)
void	Split (const SplitterQueueDescriptor &data, std::vector< ITensorHandle *> inputs, std::vector< ITensorHandle *> outputs)
template<typename DataType >
void	Splitter (const SplitterQueueDescriptor &data, std::vector< ITensorHandle *> inputs, std::vector< ITensorHandle *> outputs)
void	Stack (const StackQueueDescriptor &data, std::vector< std::unique_ptr< Decoder< float >>> &inputs, Encoder< float > &output, const TensorInfo &inputInfo, const TensorInfo &outputInfo)
void	StridedSlice (const TensorInfo &inputInfo, const StridedSliceDescriptor &params, const void *inputData, void *outputData, unsigned int dataTypeSize)
void	TransposeConvolution2dImpl (const TransposeConvolution2dDescriptor &descriptor, const TensorShape &inputShape, Decoder< float > &inputDecoder, const TensorShape &outputShape, Encoder< float > &outputEncoder, const TensorShape &weightsShape, Decoder< float > &weightsDecoder, Decoder< float > *biasesDecoder)
std::istream &	operator>> (std::istream &in, armnn::Compute &compute)
std::istream &	operator>> (std::istream &in, armnn::BackendId &backend)

Variables
constexpr unsigned int	MaxNumOfTensorDimensions = 5U
constexpr unsigned int	LOWEST_CAPTURE_PERIOD = 10000u
	The lowest performance data capture interval we support is 10 miliseconds. More...
constexpr unsigned int	EXPIRE_RATE = 3U
	Variable to control expire rate of priority queue. More...
constexpr std::size_t	g_ProfilingEventCountHint = 1024
constexpr bool	g_WriteProfilingEventSequence = true
constexpr bool	g_AggregateProfilingEventsByInference = true
constexpr bool	g_WriteReportToStdOutOnProfilerDestruction = false
thread_local IProfiler *	tl_Profiler = nullptr
const std::set< armnn::BackendCapability >	gpuAccCapabilities
const std::set< armnn::BackendCapability >	cpuAccCapabilities
const std::set< armnn::LayerType >	paddingRequiredLayers
const std::set< armnn::BackendCapability >	cpuRefCapabilities

Detailed Description

Copyright (c) 2021 ARM Limited and Contributors.

Optional is a drop in replacement for std::optional until we migrate to c++-17.

Create pages for each tool so they appear nicely in the doxygen tree-view.

All rights reserved.

SPDX-License-Identifier: MIT

Subpages are not listed there.

Note: The parser, serializer and deserializer pages are created in 01_parsers.dox or 02_deserializer_serializer.dox

Subpages are not listed there. Also we can overwrite the page name this way.

Only a subset of the optional features are implemented that we intend to use in ArmNN. There are two distinct implementations here:

1, for normal constructable/destructable types and reference types 2, for reference types The std::optional features we support are:

• has_value() and operator bool() to tell if the optional has a value
• value() returns a reference to the held object

Typedef Documentation

AdditionalInfoObjectPtr

using AdditionalInfoObjectPtr = std::shared_ptr<void>

Definition at line 208 of file Layer.hpp.

BackendIdSet

using BackendIdSet = std::unordered_set<BackendId>

Definition at line 191 of file BackendId.hpp.

BackendIdVector

using BackendIdVector = std::vector<BackendId>

Definition at line 190 of file BackendId.hpp.

BackendsMap

using BackendsMap = std::map<BackendId, std::unique_ptr<class IBackendInternal> >

Definition at line 317 of file Network.hpp.

BaseFloat32ComparisonWorkload

using BaseFloat32ComparisonWorkload = MultiTypedWorkload<QueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>

Definition at line 187 of file Workload.hpp.

BaseUint8ComparisonWorkload

using BaseUint8ComparisonWorkload = MultiTypedWorkload<QueueDescriptor, armnn::DataType::QAsymmU8, armnn::DataType::Boolean>

Definition at line 192 of file Workload.hpp.

BFloat16ToFloat32Workload

using BFloat16ToFloat32Workload = MultiTypedWorkload<QueueDescriptor, armnn::DataType::BFloat16, armnn::DataType::Float32>

Definition at line 197 of file Workload.hpp.

BindingPointInfo

using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>

Definition at line 261 of file Tensor.hpp.

BooleanWorkload

using BooleanWorkload = TypedWorkload<QueueDescriptor, armnn::DataType::Boolean>

Definition at line 182 of file Workload.hpp.

CompiledBlobDeleter

using CompiledBlobDeleter = std::function<void(const void*)>

Definition at line 17 of file ISubgraphViewConverter.hpp.

CompiledBlobPtr

using CompiledBlobPtr = std::unique_ptr<void, CompiledBlobDeleter>

Definition at line 18 of file ISubgraphViewConverter.hpp.

ConcatDescriptor

using ConcatDescriptor = OriginsDescriptor

Definition at line 52 of file DescriptorsFwd.hpp.

Coordinates

using Coordinates = std::array<unsigned int, MaxNumOfTensorDimensions>

Definition at line 14 of file InternalTypes.hpp.

DebugCallbackFunction

using DebugCallbackFunction = std::function<void(LayerGuid guid, unsigned int slotIndex, ITensorHandle* tensorHandle)>

Define the type of callback for the Debug layer to call.

Parameters

guid	- guid of layer connected to the input of the Debug layer
slotIndex	- index of the output slot connected to the input of the Debug layer
tensorHandle	- TensorHandle for the input tensor to the Debug layer

Definition at line 316 of file Types.hpp.

DepthToSpaceDescriptor

typedef SpaceToDepthDescriptor DepthToSpaceDescriptor

A DepthToSpaceDescriptor for the DepthToSpaceLayer.

Definition at line 916 of file Descriptors.hpp.

Dimensions

using Dimensions = std::array<unsigned int, MaxNumOfTensorDimensions>

Definition at line 15 of file InternalTypes.hpp.

DynamicBackendPtr

using DynamicBackendPtr = std::unique_ptr<DynamicBackend>

Definition at line 52 of file DynamicBackend.hpp.

FactoryId

typedef ITensorHandleFactory::FactoryId FactoryId

Definition at line 18 of file ClImportTensorHandleFactory.cpp.

Float16ToFloat32Workload

using Float16ToFloat32Workload = MultiTypedWorkload<QueueDescriptor, armnn::DataType::Float16, armnn::DataType::Float32>

Definition at line 207 of file Workload.hpp.

Float32ToBFloat16Workload

using Float32ToBFloat16Workload = MultiTypedWorkload<QueueDescriptor, armnn::DataType::Float32, armnn::DataType::BFloat16>

Definition at line 202 of file Workload.hpp.

Float32ToFloat16Workload

using Float32ToFloat16Workload = MultiTypedWorkload<QueueDescriptor, armnn::DataType::Float32, armnn::DataType::Float16>

Definition at line 212 of file Workload.hpp.

Float32Workload

using Float32Workload = TypedWorkload<QueueDescriptor, armnn::DataType::Float32>

Definition at line 173 of file Workload.hpp.

FloatWorkload

using FloatWorkload = TypedWorkload<QueueDescriptor, armnn::DataType::Float16, armnn::DataType::Float32>

Definition at line 170 of file Workload.hpp.

Half

using Half = half_float::half

Definition at line 16 of file Half.hpp.

HighResolutionClock

using HighResolutionClock = std::chrono::high_resolution_clock::time_point

Define a timer and associated inference ID for recording execution times.

Definition at line 319 of file Types.hpp.

IBackendContextUniquePtr

using IBackendContextUniquePtr = std::unique_ptr<IBackendContext>

Definition at line 31 of file IBackendContext.hpp.

IBackendInternalUniquePtr

typedef std::unique_ptr< IBackendInternal > IBackendInternalUniquePtr

Definition at line 23 of file BackendRegistry.hpp.

IBackendSharedPtr

using IBackendSharedPtr = std::shared_ptr<IBackend>

Definition at line 216 of file Types.hpp.

IBackendUniquePtr

using IBackendUniquePtr = std::unique_ptr<IBackend, void(*)(IBackend* backend)>

Definition at line 217 of file Types.hpp.

IGpuAccTunedParametersPtr

using IGpuAccTunedParametersPtr = std::shared_ptr<IGpuAccTunedParameters>

The following API is replaced by the backend options API.

Definition at line 237 of file IRuntime.hpp.

ILayerSupportSharedPtr

using ILayerSupportSharedPtr = std::shared_ptr<ILayerSupport>

Definition at line 425 of file ILayerSupport.hpp.

IMemoryManagerUniquePtr

using IMemoryManagerUniquePtr = std::unique_ptr<IMemoryManager>

Definition at line 24 of file IMemoryManager.hpp.

INetworkPtr

using INetworkPtr = std::unique_ptr<INetwork, void(*)(INetwork* network)>

Definition at line 173 of file INetwork.hpp.

InferenceTimingPair

using InferenceTimingPair = std::pair<HighResolutionClock, HighResolutionClock>

Definition at line 320 of file Types.hpp.

InputQueueDescriptor

using InputQueueDescriptor = MemCopyQueueDescriptor

Definition at line 81 of file WorkloadData.hpp.

InputTensors

using InputTensors = std::vector<std::pair<LayerBindingId, class ConstTensor> >

Definition at line 340 of file Tensor.hpp.

instead

typedef ConstPassthroughTensorHandle instead

Definition at line 105 of file SubgraphView.hpp.

Int32Workload

using Int32Workload = TypedWorkload<QueueDescriptor, armnn::DataType::Signed32>

Definition at line 179 of file Workload.hpp.

IOptimizedNetworkPtr

using IOptimizedNetworkPtr = std::unique_ptr<IOptimizedNetwork, void(*)(IOptimizedNetwork* network)>

Definition at line 174 of file INetwork.hpp.

IReportStructure

using IReportStructure = profiling::IReportStructure

Definition at line 28 of file Runtime.hpp.

IRuntimePtr

using IRuntimePtr = std::unique_ptr<IRuntime, void(*)(IRuntime* runtime)>

Definition at line 28 of file IRuntime.hpp.

LayerBindingId

using LayerBindingId = int

Type of identifiers for bindable layers (inputs, outputs).

Definition at line 243 of file Types.hpp.

LayerGuid

using LayerGuid = profiling::ProfilingGuid

Define LayerGuid type.

Definition at line 308 of file Types.hpp.

LayerPriority

using LayerPriority = unsigned int

Definition at line 207 of file Layer.hpp.

LayerTypeOf

using LayerTypeOf = typename LayerTypeOfImpl<Type>::Type

Definition at line 84 of file LayersFwd.hpp.

LoadedNetworks

using LoadedNetworks = std::unordered_map<NetworkId, std::unique_ptr<LoadedNetwork> >

Definition at line 27 of file Runtime.hpp.

LogSoftmaxDescriptor

typedef SoftmaxDescriptor LogSoftmaxDescriptor

A LogSoftmaxDescriptor for the LogSoftmaxLayer.

Definition at line 158 of file Descriptors.hpp.

MemorySourceFlags

using MemorySourceFlags = unsigned int

Definition at line 15 of file MemorySources.hpp.

MergerDescriptor

using MergerDescriptor = OriginsDescriptor

MergerDescriptor is deprecated, use ConcatDescriptor instead.

Definition at line 56 of file DescriptorsFwd.hpp.

MergerQueueDescriptor

using MergerQueueDescriptor = ConcatQueueDescriptor

Definition at line 139 of file WorkloadData.hpp.

ModelOptions

using ModelOptions = std::vector<BackendOptions>

Definition at line 17 of file BackendOptions.hpp.

NetworkId

typedef int NetworkId

Definition at line 22 of file IRuntime.hpp.

NetworkImplPtr

using NetworkImplPtr = std::unique_ptr<NetworkImpl, void(*)(NetworkImpl* network)>

Definition at line 28 of file Network.hpp.

NetworkOptions

using NetworkOptions = std::vector<BackendOptions>

Definition at line 15 of file BackendOptions.hpp.

OutputQueueDescriptor

using OutputQueueDescriptor = MemCopyQueueDescriptor

Definition at line 82 of file WorkloadData.hpp.

OutputTensors

using OutputTensors = std::vector<std::pair<LayerBindingId, class Tensor> >

Definition at line 341 of file Tensor.hpp.

ParameterStringifyFunction

using ParameterStringifyFunction = std::function<void(const std::string& name, const std::string& value)>

Definition at line 14 of file SerializeLayerParameters.hpp.

PreCompiledObjectDeleter

using PreCompiledObjectDeleter = std::function<void(const void*)>

Definition at line 19 of file PreCompiledLayer.hpp.

PreCompiledObjectPtr

using PreCompiledObjectPtr = std::unique_ptr<void, PreCompiledObjectDeleter>

Definition at line 20 of file PreCompiledLayer.hpp.

RefAdditionWorkload

using RefAdditionWorkload = RefElementwiseWorkload<std::plus<DataType>, AdditionQueueDescriptor, StringMapping::RefAdditionWorkload_Execute>

Definition at line 40 of file RefElementwiseWorkload.hpp.

RefDebugBFloat16Workload

using RefDebugBFloat16Workload = RefDebugWorkload<DataType::BFloat16>

Definition at line 42 of file RefDebugWorkload.hpp.

RefDebugFloat16Workload

using RefDebugFloat16Workload = RefDebugWorkload<DataType::Float16>

Definition at line 43 of file RefDebugWorkload.hpp.

RefDebugFloat32Workload

using RefDebugFloat32Workload = RefDebugWorkload<DataType::Float32>

Definition at line 44 of file RefDebugWorkload.hpp.

RefDebugQAsymmS8Workload

using RefDebugQAsymmS8Workload = RefDebugWorkload<DataType::QAsymmS8>

Definition at line 46 of file RefDebugWorkload.hpp.

RefDebugQAsymmU8Workload

using RefDebugQAsymmU8Workload = RefDebugWorkload<DataType::QAsymmU8>

Definition at line 45 of file RefDebugWorkload.hpp.

RefDebugQSymmS16Workload

using RefDebugQSymmS16Workload = RefDebugWorkload<DataType::QSymmS16>

Definition at line 47 of file RefDebugWorkload.hpp.

RefDebugQSymmS8Workload

using RefDebugQSymmS8Workload = RefDebugWorkload<DataType::QSymmS8>

Definition at line 48 of file RefDebugWorkload.hpp.

RefDebugSigned32Workload

using RefDebugSigned32Workload = RefDebugWorkload<DataType::Signed32>

Definition at line 49 of file RefDebugWorkload.hpp.

RefDivisionWorkload

using RefDivisionWorkload = RefElementwiseWorkload<std::divides<DataType>, DivisionQueueDescriptor, StringMapping::RefDivisionWorkload_Execute>

Definition at line 58 of file RefElementwiseWorkload.hpp.

RefMaximumWorkload

using RefMaximumWorkload = RefElementwiseWorkload<armnn::maximum<DataType>, MaximumQueueDescriptor, StringMapping::RefMaximumWorkload_Execute>

Definition at line 64 of file RefElementwiseWorkload.hpp.

RefMinimumWorkload

using RefMinimumWorkload = RefElementwiseWorkload<armnn::minimum<DataType>, MinimumQueueDescriptor, StringMapping::RefMinimumWorkload_Execute>

Definition at line 70 of file RefElementwiseWorkload.hpp.

RefMultiplicationWorkload

using RefMultiplicationWorkload = RefElementwiseWorkload<std::multiplies<DataType>, MultiplicationQueueDescriptor, StringMapping::RefMultiplicationWorkload_Execute>

Definition at line 52 of file RefElementwiseWorkload.hpp.

RefPermuteBFloat16Workload

using RefPermuteBFloat16Workload = RefPermuteWorkload<DataType::BFloat16>

Definition at line 33 of file RefPermuteWorkload.hpp.

RefPermuteFloat16Workload

using RefPermuteFloat16Workload = RefPermuteWorkload<DataType::Float16>

Definition at line 34 of file RefPermuteWorkload.hpp.

RefPermuteFloat32Workload

using RefPermuteFloat32Workload = RefPermuteWorkload<DataType::Float32>

Definition at line 35 of file RefPermuteWorkload.hpp.

RefPermuteQAsymm8Workload

using RefPermuteQAsymm8Workload = RefPermuteWorkload<DataType::QAsymmU8>

Definition at line 37 of file RefPermuteWorkload.hpp.

RefPermuteQAsymmS8Workload

using RefPermuteQAsymmS8Workload = RefPermuteWorkload<DataType::QAsymmS8>

Definition at line 36 of file RefPermuteWorkload.hpp.

RefPermuteQSymm16Workload

using RefPermuteQSymm16Workload = RefPermuteWorkload<DataType::QSymmS16>

Definition at line 38 of file RefPermuteWorkload.hpp.

RefSubtractionWorkload

using RefSubtractionWorkload = RefElementwiseWorkload<std::minus<DataType>, SubtractionQueueDescriptor, StringMapping::RefSubtractionWorkload_Execute>

Definition at line 46 of file RefElementwiseWorkload.hpp.

RefTransposeBFloat16Workload

using RefTransposeBFloat16Workload = RefTransposeWorkload<DataType::BFloat16>

Definition at line 33 of file RefTransposeWorkload.hpp.

RefTransposeFloat16Workload

using RefTransposeFloat16Workload = RefTransposeWorkload<DataType::Float16>

Definition at line 34 of file RefTransposeWorkload.hpp.

RefTransposeFloat32Workload

using RefTransposeFloat32Workload = RefTransposeWorkload<DataType::Float32>

Definition at line 35 of file RefTransposeWorkload.hpp.

RefTransposeQAsymm8Workload

using RefTransposeQAsymm8Workload = RefTransposeWorkload<DataType::QAsymmU8>

Definition at line 37 of file RefTransposeWorkload.hpp.

RefTransposeQAsymmS8Workload

using RefTransposeQAsymmS8Workload = RefTransposeWorkload<DataType::QAsymmS8>

Definition at line 36 of file RefTransposeWorkload.hpp.

RefTransposeQSymm16Workload

using RefTransposeQSymm16Workload = RefTransposeWorkload<DataType::QSymmS16>

Definition at line 38 of file RefTransposeWorkload.hpp.

ResolveType

using ResolveType = typename ResolveTypeImpl<DT>::Type

Definition at line 79 of file ResolveType.hpp.

SplitterDescriptor

using SplitterDescriptor = ViewsDescriptor

Definition at line 57 of file DescriptorsFwd.hpp.

supported

using supported = ISubgraphViewConverter

Definition at line 31 of file ISubgraphViewConverter.hpp.

Uint8ToFloat32Workload

using Uint8ToFloat32Workload = MultiTypedWorkload<QueueDescriptor, armnn::DataType::QAsymmU8, armnn::DataType::Float32>

Definition at line 217 of file Workload.hpp.

Uint8Workload

using Uint8Workload = TypedWorkload<QueueDescriptor, armnn::DataType::QAsymmU8>

Definition at line 176 of file Workload.hpp.

WorkloadQueue

using WorkloadQueue = std::vector< std::unique_ptr<IWorkload> >

Definition at line 13 of file ExecutionFrame.hpp.

Enumeration Type Documentation

ActivationFunction

enum ActivationFunction

strong

Enumerator
Sigmoid
TanH
Linear
ReLu
BoundedReLu	min(a, max(b, input)) ReLu1 & ReLu6.
SoftReLu
LeakyReLu
Abs
Sqrt
Square
Elu
HardSwish

Definition at line 67 of file Types.hpp.

{
    Sigmoid     = 0,
    TanH        = 1,
    Linear      = 2,
    ReLu        = 3,
    BoundedReLu = 4, ///< min(a, max(b, input)) ReLu1 & ReLu6.
    SoftReLu    = 5,
    LeakyReLu   = 6,
    Abs         = 7,
    Sqrt        = 8,
    Square      = 9,
    Elu         = 10,
    HardSwish   = 11
};

ArgMinMaxFunction

enum ArgMinMaxFunction

strong

Enumerator
Min
Max

Definition at line 83 of file Types.hpp.

{
    Min = 0,
    Max = 1
};

BackendCapability

enum BackendCapability : uint32_t

strong

BackendCapability class.

Enumerator
NonConstWeights	Constant weights can be accessed through the descriptors, On the other hand, non-const weights can be accessed through inputs.
AsyncExecution	Asynchronous Execution.

Definition at line 220 of file Types.hpp.

                             : uint32_t
{
    /// Constant weights can be accessed through the descriptors,
    /// On the other hand, non-const weights can be accessed through inputs.
    NonConstWeights,

    /// Asynchronous Execution.
    AsyncExecution,

    // add new enum values here
};

BoostLogSeverityMapping

enum BoostLogSeverityMapping

strong

Enumerator
trace
debug
info
warning
error
fatal

Definition at line 186 of file Logging.hpp.

{
    trace,
    debug,
    info,
    warning,
    error,
    fatal
};

CapabilityClass

enum CapabilityClass

strong

Capability class to calculate in the GetCapabilities function so that only the capability in the scope can be choose to calculate.

Enumerator
PaddingRequired
FallbackImportDisabled
CapabilityClassMax

Definition at line 20 of file ITensorHandleFactory.hpp.

{
    PaddingRequired = 1,
    FallbackImportDisabled = 2,

    // add new enum values here

    CapabilityClassMax = 254
};

ComparisonOperation

enum ComparisonOperation

strong

Enumerator
Equal
Greater
GreaterOrEqual
Less
LessOrEqual
NotEqual

Definition at line 89 of file Types.hpp.

{
    Equal          = 0,
    Greater        = 1,
    GreaterOrEqual = 2,
    Less           = 3,
    LessOrEqual    = 4,
    NotEqual       = 5
};

Compute

enum Compute

strong

The Compute enum is now deprecated and it is now being replaced by BackendId.

Enumerator
Undefined
CpuRef	CPU Execution: Reference C++ kernels.
CpuAcc	CPU Execution: NEON: ArmCompute.
GpuAcc	GPU Execution: OpenCL: ArmCompute.

Definition at line 21 of file BackendId.hpp.

{
    Undefined = 0,
    /// CPU Execution: Reference C++ kernels
    CpuRef    = 1,
    /// CPU Execution: NEON: ArmCompute
    CpuAcc    = 2,
    /// GPU Execution: OpenCL: ArmCompute
    GpuAcc    = 3
};

DataLayout

enum DataLayout

strong

Enumerator
NCHW
NHWC

Definition at line 54 of file Types.hpp.

{
    NCHW = 1,
    NHWC = 2
};

DataType

enum DataType

strong

Enumerator
Float16
Float32
QAsymmU8
Signed32
Boolean
QSymmS16
QuantizedSymm8PerAxis
QSymmS8
QAsymmS8
BFloat16
Signed64
QuantisedAsymm8
QuantisedSymm16

Definition at line 36 of file Types.hpp.

{
    Float16  = 0,
    Float32  = 1,
    QAsymmU8 = 2,
    Signed32 = 3,
    Boolean  = 4,
    QSymmS16 = 5,
    QuantizedSymm8PerAxis ARMNN_DEPRECATED_ENUM_MSG("Per Axis property inferred by number of scales in TensorInfo") = 6,
    QSymmS8  = 7,
    QAsymmS8 = 8,
    BFloat16 = 9,
    Signed64 = 10,

    QuantisedAsymm8 ARMNN_DEPRECATED_ENUM_MSG("Use DataType::QAsymmU8 instead.") = QAsymmU8,
    QuantisedSymm16 ARMNN_DEPRECATED_ENUM_MSG("Use DataType::QSymmS16 instead.") = QSymmS16
};

Dimensionality

enum Dimensionality

strong

Enumerator
NotSpecified
Specified
Scalar

Definition at line 136 of file Types.hpp.

{
    NotSpecified = 0,
    Specified    = 1,
    Scalar       = 2
};

EdgeStrategy

enum EdgeStrategy

strong

Enumerator
Undefined
DirectCompatibility	No strategy has been defined. Used internally to verify integrity of optimizations.
ExportToTarget	Destination backend can work directly with tensors on source backend.
CopyToTarget	Source backends tensor data can be exported to destination backend tensor without copy. Copy contents from source backend tensor to destination backend tensor.

Definition at line 100 of file ITensorHandleFactory.hpp.

{
    Undefined,              /// No strategy has been defined. Used internally to verify integrity of optimizations.
    DirectCompatibility,    /// Destination backend can work directly with tensors on source backend.
    ExportToTarget,         /// Source backends tensor data can be exported to destination backend tensor without copy.
    CopyToTarget            /// Copy contents from source backend tensor to destination backend tensor.
};

GraphEvent

enum GraphEvent

strong

Enumerator
LayerAdded
LayerErased

Definition at line 12 of file IGraphObservable.hpp.

{
    LayerAdded,
    LayerErased
};

JsonObjectType

enum JsonObjectType

strong

Enumerator
Measurement
Event

Definition at line 18 of file JsonPrinter.hpp.

{
    Measurement,
    Event
};

LayerType

enum LayerType

strong

When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below.

Enumerator
X
Activation
Addition
ArgMinMax
BatchNormalization
BatchToSpaceNd
Comparison
Concat
Constant
ConvertBf16ToFp32
ConvertFp16ToFp32
ConvertFp32ToBf16
ConvertFp32ToFp16
Convolution2d
Debug
DepthToSpace
DepthwiseConvolution2d
Dequantize
DetectionPostProcess
Division
ElementwiseUnary
FakeQuantization
Fill
Floor
FullyConnected
Gather
Input
InstanceNormalization
L2Normalization
LogicalBinary
LogSoftmax
Lstm
QLstm
Map
Maximum
Mean
MemCopy
MemImport
Merge
Minimum
Multiplication
Normalization
Output
Pad
Permute
Pooling2d
PreCompiled
Prelu
Quantize
QuantizedLstm
Reshape
Rank
Resize
Reduce
Slice
Softmax
SpaceToBatchNd
SpaceToDepth
Splitter
Stack
StandIn
StridedSlice
Subtraction
Switch
Transpose
TransposeConvolution2d
Unmap
Cast
FirstLayer
LastLayer

Definition at line 455 of file Types.hpp.

{
#define X(name) name,
    LIST_OF_LAYER_TYPE
#undef X
    FirstLayer = Activation,
    LastLayer = Cast
};

LogicalBinaryOperation

enum LogicalBinaryOperation

strong

Enumerator
LogicalAnd
LogicalOr

Definition at line 99 of file Types.hpp.

{
    LogicalAnd = 0,
    LogicalOr  = 1
};

LogSeverity

enum LogSeverity

strong

Enumerator
Trace
Debug
Info
Warning
Error
Fatal

Definition at line 13 of file Utils.hpp.

{
    Trace,
    Debug,
    Info,
    Warning,
    Error,
    Fatal
};

MemorySource

enum MemorySource : uint32_t

strong

Define the Memory Source to reduce copies.

Enumerator
Undefined
Malloc
DmaBuf
DmaBufProtected

Definition at line 197 of file Types.hpp.

                        : uint32_t
{
    Undefined = 0,
    Malloc = 1,
    DmaBuf = 2,
    DmaBufProtected = 4
};

NormalizationAlgorithmChannel

enum NormalizationAlgorithmChannel

strong

Enumerator
Across
Within

Definition at line 160 of file Types.hpp.

{
    Across = 0,
    Within = 1
};

NormalizationAlgorithmMethod

enum NormalizationAlgorithmMethod

strong

Enumerator
LocalBrightness	Krichevsky 2012: Local Brightness Normalization.
LocalContrast	Jarret 2009: Local Contrast Normalization.

Definition at line 166 of file Types.hpp.

{
    /// Krichevsky 2012: Local Brightness Normalization
    LocalBrightness = 0,
    /// Jarret 2009: Local Contrast Normalization
    LocalContrast = 1
};

OutputShapeRounding

enum OutputShapeRounding

strong

Enumerator
Floor
Ceiling

Definition at line 174 of file Types.hpp.

{
    Floor       = 0,
    Ceiling     = 1
};

PaddingMethod

enum PaddingMethod

strong

The padding method modifies the output of pooling layers.

In both supported methods, the values are ignored (they are not even zeroes, which would make a difference for max pooling a tensor with negative values). The difference between IgnoreValue and Exclude is that the former counts the padding fields in the divisor of Average and L2 pooling, while Exclude does not.

Enumerator
IgnoreValue	The padding fields count, but are ignored.
Exclude	The padding fields don't count and are ignored.

Definition at line 152 of file Types.hpp.

{
    /// The padding fields count, but are ignored
    IgnoreValue = 0,
    /// The padding fields don't count and are ignored
    Exclude     = 1
};

PoolingAlgorithm

enum PoolingAlgorithm

strong

Enumerator
Max
Average
L2

Definition at line 115 of file Types.hpp.

{
    Max     = 0,
    Average = 1,
    L2      = 2
};

QosExecPriority

enum QosExecPriority

strong

Enumerator
Low
Medium
High

Definition at line 60 of file Types.hpp.

{
    Low    = 0,
    Medium = 1,
    High   = 2
};

ReduceOperation

enum ReduceOperation

strong

Enumerator
Sum
Max
Mean
Min

Definition at line 122 of file Types.hpp.

{
    Sum  = 0,
    Max  = 1,
    Mean = 2,
    Min  = 3
};

ResizeMethod

enum ResizeMethod

strong

Enumerator
Bilinear
NearestNeighbor

Definition at line 130 of file Types.hpp.

{
    Bilinear        = 0,
    NearestNeighbor = 1
};

ShapeInferenceMethod

enum ShapeInferenceMethod

strong

The ShapeInferenceMethod modify how the output shapes are treated.

When ValidateOnly is selected, the output shapes are inferred from the input parameters of the layer and any mismatch is reported. When InferAndValidate is selected 2 actions must be performed: (1)infer output shape from inputs and (2)validate the shapes as in ValidateOnly. This option has been added to work with tensors which rank or dimension sizes are not specified explicitly, however this information can be calculated from the inputs.

Enumerator
ValidateOnly	Validate all output shapes.
InferAndValidate	Infer missing output shapes and validate all output shapes.

Definition at line 188 of file Types.hpp.

{
    /// Validate all output shapes
    ValidateOnly     = 0,
    /// Infer missing output shapes and validate all output shapes
    InferAndValidate = 1
};

Status

enum Status

strong

enumeration

Enumerator
Success
Failure

Definition at line 30 of file Types.hpp.

{
    Success = 0,
    Failure = 1
};

TuningLevel

enum TuningLevel

strong

Enumerator
None
Rapid
Normal
Exhaustive

Definition at line 70 of file ClBackendContext.cpp.

{
    None,
    Rapid,
    Normal,
    Exhaustive
};

UnaryOperation

enum UnaryOperation

strong

Enumerator
Abs
Exp
Sqrt
Rsqrt
Neg
LogicalNot

Definition at line 105 of file Types.hpp.

{
    Abs        = 0,
    Exp        = 1,
    Sqrt       = 2,
    Rsqrt      = 3,
    Neg        = 4,
    LogicalNot = 5
};

Function Documentation

Activation() [1/2]

float Activation	(	float	in,
		ActivationFunction	function,
		float	a,
		float	b
	)

Definition at line 13 of file Activation.cpp.

References Abs, BoundedReLu, Elu, HardSwish, LeakyReLu, Linear, ReLu, Sigmoid, SoftReLu, Sqrt, Square, and TanH.

Referenced by Activation().

{
    float output;

    // Compute the result of the activation function.
    switch (function)
    {
        case ActivationFunction::Linear:
        {
            output = a * in + b;
            break;
        }
        case ActivationFunction::Sigmoid:
        {
            output = 1.f / (1.f + expf(-in));
            break;
        }
        case ActivationFunction::ReLu:
        {
            output = std::max(0.f, in);
            break;
        }
        case ActivationFunction::BoundedReLu:
        {
            output = std::min(a, std::max(b, in));
            break;
        }
        case ActivationFunction::SoftReLu:
        {
            output = logf(1.0f + expf(in));
            break;
        }
        case ActivationFunction::LeakyReLu:
        {
            output = in > 0.0f ? in : (in * a);
            break;
        }
        case ActivationFunction::Abs:
        {
            output = in < 0 ? -in : in;
            break;
        }
        case ActivationFunction::Sqrt:
        {
            output = sqrtf(in);
            break;
        }
        case ActivationFunction::Square:
        {
            output = in * in;
            break;
        }
        case ActivationFunction::TanH:
        {
            output = a * tanhf(b * in);
            break;
        }
        case ActivationFunction::Elu:
        {
            output = (in >= 0) ? in : a * (expf(in) - 1);
            break;
        }
        case ActivationFunction::HardSwish:
        {
            // hard_swish(x) = x * relu6(x+3) / 6
            // relu6(x) = min(max(x,0),6)
            output = in * (std::min(std::max((in + 3),0.0f),6.0f)) / 6;
            break;
        }
        default:
        {
            throw InvalidArgumentException("Unsupported activation function");
        }
    }

    return output;
}

Activation() [2/2]

void Activation	(	Decoder< float > &	in,
		Encoder< float > &	out,
		const TensorInfo &	tensorInfo,
		ActivationFunction	function,
		float	a,
		float	b
	)

Definition at line 95 of file Activation.cpp.

References Activation(), Decoder< IType >::Get(), TensorInfo::GetNumElements(), and Encoder< IType >::Set().

{
    unsigned int numElements = tensorInfo.GetNumElements();

    for (unsigned int i = 0; i < numElements; i++)
    {
        out.Set(Activation(in.Get(), function, a, b));
        ++in;
        ++out;
    }
    in -= numElements;
    out -= numElements;
}

AllocateOutputData()

void armnn::AllocateOutputData	(	unsigned int	numOutput,
		unsigned int	numSelected,
		const std::vector< float > &	boxCorners,
		const std::vector< unsigned int > &	outputIndices,
		const std::vector< unsigned int > &	selectedBoxes,
		const std::vector< unsigned int > &	selectedClasses,
		const std::vector< float > &	selectedScores,
		float *	detectionBoxes,
		float *	detectionScores,
		float *	detectionClasses,
		float *	numDetections
	)

Definition at line 102 of file DetectionPostProcess.cpp.

References numeric_cast().

Referenced by DetectionPostProcess().

{
    for (unsigned int i = 0; i < numOutput; ++i)
        {
            unsigned int boxIndex = i * 4;
            if (i < numSelected)
            {
                unsigned int boxCornorIndex = selectedBoxes[outputIndices[i]] * 4;
                detectionScores[i] = selectedScores[outputIndices[i]];
                detectionClasses[i] = armnn::numeric_cast<float>(selectedClasses[outputIndices[i]]);
                detectionBoxes[boxIndex] = boxCorners[boxCornorIndex];
                detectionBoxes[boxIndex + 1] = boxCorners[boxCornorIndex + 1];
                detectionBoxes[boxIndex + 2] = boxCorners[boxCornorIndex + 2];
                detectionBoxes[boxIndex + 3] = boxCorners[boxCornorIndex + 3];
            }
            else
            {
                detectionScores[i] = 0.0f;
                detectionClasses[i] = 0.0f;
                detectionBoxes[boxIndex] = 0.0f;
                detectionBoxes[boxIndex + 1] = 0.0f;
                detectionBoxes[boxIndex + 2] = 0.0f;
                detectionBoxes[boxIndex + 3] = 0.0f;
            }
        }
        numDetections[0] = armnn::numeric_cast<float>(numSelected);
}

AllTypesAreEqualImpl() [1/2]

bool armnn::AllTypesAreEqualImpl

(

T

)

Definition at line 59 of file LayerSupportRules.hpp.

Referenced by AllTypesAreEqualImpl(), and TypesAreEqual::TypesAreEqual().

{
    return true;
}

AllTypesAreEqualImpl() [2/2]

bool armnn::AllTypesAreEqualImpl	(	T	t1,
		T	t2,
		Rest...	rest
	)

Definition at line 65 of file LayerSupportRules.hpp.

References AllTypesAreEqualImpl().

{
    static_assert(std::is_same<T, TensorInfo>::value, "Type T must be a TensorInfo");

    return (t1.GetDataType() == t2.GetDataType()) && AllTypesAreEqualImpl(t2, rest...);
}

Append() [1/2]

void armnn::Append	(	Optimizer::Optimizations &	optimizations,
		T &&	optimization
	)

Definition at line 30 of file Optimizer.hpp.

Referenced by Append(), and MakeOptimizations().

{
    optimizations.emplace_back(new T(optimization));
};

Append() [2/2]

void armnn::Append	(	Optimizer::Optimizations &	optimizations,
		Front &&	front,
		Others &&...	others
	)

Definition at line 36 of file Optimizer.hpp.

References Append().

{
    Append<Front>(optimizations, std::forward<Front>(front));
    Append<Others...>(optimizations, std::forward<Others>(others)...);
};

ApplyBackendOptimizations()

OptimizationResult armnn::ApplyBackendOptimizations	(	OptimizedNetworkImpl *	optNetObjPtr,
		BackendSettings &	backendSettings,
		BackendsMap &	backends,
		const ModelOptions &	modelOptions,
		Optional< std::vector< std::string > &>	errMessages
	)

Definition at line 1047 of file Network.cpp.

References ARMNN_ASSERT, AssignBackends(), SubgraphView::begin(), SubgraphView::end(), Layer::GetBackendId(), OptimizationViews::GetFailedSubgraphs(), OptimizedNetworkImpl::GetGraph(), OptimizationViews::GetSubstitutions(), Layer::GetType(), Input, OptimizationResult::m_Error, BackendSettings::m_SelectedBackends, Output, ReportWarning(), SubgraphViewSelector::SelectSubgraphs(), Graph::SubstituteSubgraph(), and OptimizationViews::Validate().

Referenced by Optimize().

{
    ARMNN_ASSERT(optNetObjPtr);

    OptimizationResult result;

    // Get the optimized graph
    Graph& optGraph = optNetObjPtr->GetGraph();

    // Run backend specific optimizations
    for (auto&& selectedBackend : backendSettings.m_SelectedBackends)
    {
        auto backendObjPtr = backends.find(selectedBackend)->second.get();
        ARMNN_ASSERT(backendObjPtr);

        // Select sub-graphs based on backend
        SubgraphViewSelector::Subgraphs subgraphs =
                SubgraphViewSelector::SelectSubgraphs(optGraph,
                                                      // Select layers assigned to the requested backend
                                                      [&backendObjPtr](const Layer& layer)
                                                      {
                                                          return layer.GetType() != LayerType::Input &&
                                                                 layer.GetType() != LayerType::Output &&
                                                                 layer.GetBackendId() == backendObjPtr->GetId();
                                                      });
        if (subgraphs.empty())
        {
            // No sub-graphs found, try with next selected backend
            continue;