Namespaces
	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

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	BooleanEncoder

struct	BroadcastLoop

struct	Capability
	Capability of the TensorHandleFactory. More...

struct	CheckLocation

class	ClAbsWorkload

class	ClActivationWorkload

class	ClAdditionWorkload

class	ClArgMinMaxWorkload

class	ClBackend

class	ClBackendContext

class	ClBatchNormalizationFloatWorkload

class	ClBatchToSpaceNdWorkload

class	ClComparisonWorkload

class	ClConcatWorkload

class	ClConstantWorkload

class	ClContextControl

class	ClConvertFp16ToFp32Workload

class	ClConvertFp32ToFp16Workload

class	ClConvolution2dWorkload

class	ClDepthToSpaceWorkload

class	ClDepthwiseConvolutionWorkload

class	ClDequantizeWorkload

class	ClDivisionFloatWorkload

class	ClExpWorkload

class	ClFillWorkload

class	ClFloorFloatWorkload

class	ClFullyConnectedWorkload

class	ClGatherWorkload

class	ClInstanceNormalizationWorkload

class	ClL2NormalizationFloatWorkload

class	ClLayerSupport

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

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	ConstCpuTensorHandle

class	ConstPassthroughCpuTensorHandle

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	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	CpuTensorHandle

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	DynamicQuantizationVisitor
	Visitor class to establish min/max ranges based on the type of the layer. More...

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

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	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	INetworkQuantizer
	Quantizer class Quantizes a float32 InputNetwork. More...

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

struct	IQuantizationScheme

class	IRuntime

struct	IsHalfType

struct	IsMemorySource

struct	IsMemorySource< MemorySource >

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

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::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::LogSoftmax >

struct	LayerTypeOfImpl< LayerType::Lstm >

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::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 >

class	LayerValidationException

class	LayerVisitorBase
	Visitor base class with empty implementations. More...

class	LayerWithParameters

class	LoadedNetwork

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

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	NeonBatchNormalizationWorkload

class	NeonBatchToSpaceNdWorkload

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	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

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	Network
	Private implementation of INetwork. More...

class	NetworkQuantizer

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	OptimizedNetwork

class	OptimizeForConnection

class	OptimizeForConnectionImpl
	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

class	OverrideInputRangeVisitor
	Visitor object for overriding the input range of the quantized input layers in a network. More...

struct	PadDescriptor
	A PadDescriptor for the PadLayer. More...

class	PadLayer
	This layer represents a pad operation. More...

struct	PadQueueDescriptor

class	ParseException

class	PassthroughCpuTensorHandle

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	Profiler

class	ProfilerManager

class	QASymm8Decoder

class	QASymm8Encoder

class	QASymmS8Decoder

class	QASymmS8Encoder

struct	QAsymmS8QuantizationScheme

struct	QAsymmU8QuantizationScheme

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

struct	QSymm16QuantizationScheme

class	QSymm8PerAxisDecoder

class	QSymm8PerAxisEncoder

class	QSymmS8Decoder

class	QSymmS8Encoder

struct	QSymmS8QuantizationScheme

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	QuantizerOptions

class	QuantizerVisitor
	Visitor object for quantizing layers in a network. More...

struct	QueueDescriptor

struct	QueueDescriptorWithParameters

class	RangeTracker

class	RankLayer

struct	RankQueueDescriptor

class	RefActivationWorkload

class	RefArgMinMaxWorkload

class	RefBackend

class	RefBatchNormalizationWorkload

class	RefBatchToSpaceNdWorkload

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	RefLogSoftmaxWorkload

class	RefLstmWorkload

class	RefMeanWorkload

class	RefMemoryManager

class	RefNormalizationWorkload

class	RefPadWorkload

class	RefPermuteWorkload

class	RefPooling2dWorkload

class	RefPreluWorkload

class	RefQLstmWorkload

class	RefQuantizeWorkload

struct	RefRankWorkload

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	rsqrt

class	RsqrtLayer

struct	RsqrtQueueDescriptor

struct	Rule

class	Runtime

class	RuntimeException

class	ScaledInt32Decoder

class	ScaledInt32PerAxisDecoder

class	ScopedCpuTensorHandle

class	ScopedProfilingEvent

struct	ScopedRecord

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...

class	StaticRangeVisitor
	Visitor class to establish min/max ranges based on the type of the layer. 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< 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	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

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

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	IBackendInternalUniquePtr = std::unique_ptr< IBackendInternal >

using	DynamicBackendPtr = std::unique_ptr< DynamicBackend >

using	IBackendContextUniquePtr = std::unique_ptr< IBackendContext >

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	ILayerSupportSharedPtr = std::shared_ptr< ILayerSupport >

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	INetworkQuantizerPtr = std::unique_ptr< class INetworkQuantizer, void()(INetworkQuantizer quantizer)>

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	PreCompiledObjectDeleter = std::function< void(const void *)>

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

template<LayerType Type>
using	LayerTypeOf = typename LayerTypeOfImpl< Type >::Type

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

using	OffsetScalePair = std::pair< float, int >

using	TContainer = boost::variant< std::vector< float >, std::vector< int >, std::vector< unsigned char > >

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	MinMaxRange = std::pair< float, float >

using	MinMaxRanges = std::vector< MinMaxRange >

using	MinMaxRangeMap = std::unordered_map< LayerGuid, MinMaxRanges >

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, 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	MemorySource { Undefined = 0, Malloc = 1, DmaBuf = 2, DmaBufProtected = 4 }

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, QuantisedAsymm8 = QAsymmU8, QuantisedSymm16 = QSymmS16 }

enum	DataLayout { NCHW = 1, NHWC = 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	UnaryOperation { Abs = 0, Exp = 1, Sqrt = 2, Rsqrt = 3, Neg = 4 }

enum	PoolingAlgorithm { Max = 0, Average = 1, L2 = 2 }

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	LogSeverity { Trace, Debug, Info, Warning, Error, Fatal }

enum	GraphEvent { LayerAdded, LayerErased }

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, LogSoftmax, Lstm, QLstm, Maximum, Mean, MemCopy, MemImport, Merge, Minimum, Multiplication, Normalization, Output, Pad, Permute, Pooling2d, PreCompiled, Prelu, Quantize, QuantizedLstm, Reshape, Rank, Resize, Slice, Softmax, SpaceToBatchNd, SpaceToDepth, Splitter, Stack, StandIn, StridedSlice, Subtraction, Switch, Transpose, TransposeConvolution2d, FirstLayer = Activation, LastLayer = TransposeConvolution2d }

enum	JsonObjectType { Measurement, Event }

enum	TuningLevel { None, Rapid, Normal, Exhaustive }

Functions
std::shared_ptr< ILayerSupport >	GetILayerSupportByBackendId (const armnn::BackendId &backend)
	Convenience function to retrieve the ILayerSupport for 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)

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	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)

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...

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 *	GetPoolingAlgorithmAsCString (PoolingAlgorithm pooling)

constexpr char const *	GetOutputShapeRoundingAsCString (OutputShapeRounding rounding)

constexpr char const *	GetPaddingMethodAsCString (PaddingMethod method)

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_signed< Dest >::value, Dest >	numeric_cast (Source source)

template<typename Dest , typename Source >
std::enable_if_t< std::is_signed< 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, 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)

void	ConfigureLogging (bool printToStandardOutput, bool printToDebugOutput, LogSeverity severity)
	Configures the logging behaviour of the ARMNN library. More...

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)

char const *	GetLayerTypeAsCString (LayerType type)

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 LogSoftmaxLayer *)

template<>
constexpr LayerType	LayerEnumOf (const LstmLayer *)

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 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 *)

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)

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 (OptimizedNetwork *optNetObjPtr, BackendSettings &backendSettings, Graph::Iterator &firstLayer, Graph::Iterator &lastLayer, Optional< std::vector< std::string > &> errMessages)

OptimizationResult	AssignBackends (OptimizedNetwork *optNetObjPtr, BackendSettings &backendSettings, SubgraphView &subgraph, Optional< std::vector< std::string > &> errMessages)

BackendsMap	CreateSupportedBackends (TensorHandleFactoryRegistry &handleFactoryRegistry, BackendSettings &backendSettings)

OptimizationResult	ApplyBackendOptimizations (OptimizedNetwork *optNetObjPtr, BackendSettings &backendSettings, BackendsMap &backends, 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)

ITensorHandleFactory::FactoryId	CalculateSlotOptionForOutput (BackendsMap &backends, OutputSlot &slot, TensorHandleFactoryRegistry &registry)

ITensorHandleFactory::FactoryId	CalculateSlotOption (BackendsMap &backends, OutputSlot &outputSlot, TensorHandleFactoryRegistry &registry)

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)

ConstTensor	CreateQuantizedConst (const ConstTensor &tensor, std::vector< uint8_t > &backing)

template<typename srcType >
void	QuantizeConstant (const srcType src, uint8_t dst, size_t numElements, float &scale, int &offset)

template<typename LayerContainer >
void	VisitLayers (const LayerContainer &layerContainer, ILayerVisitor &visitor)

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)

size_t	GetProfilerEventSequenceSize (armnn::Profiler *profiler)

void	VisitLayersTopologically (const INetwork *inputNetwork, ILayerVisitor &visitor)

	BOOST_AUTO_TEST_CASE (QuantizeAddition)

INetworkPtr	CreateNetworkWithActivationLayer (const ActivationDescriptor &descriptor, const TensorShape &shape)

INetworkPtr	CreateNetworkWithInputOutputLayers ()

TensorInfo	GetInputTensorInfo (const Network *network)

	BOOST_AUTO_TEST_CASE (InputOutputLayerDynamicQuant)

	BOOST_AUTO_TEST_CASE (QuantizeAbsActivation)

	BOOST_AUTO_TEST_CASE (QuantizeLinearActivation)

	BOOST_AUTO_TEST_CASE (QuantizeReLuActivation)

	BOOST_AUTO_TEST_CASE (QuantizeSoftReLuActivation)

	BOOST_AUTO_TEST_CASE (QuantizeBoundedReluActivation)

	BOOST_AUTO_TEST_CASE (QuantizeTanHActivation)

	BOOST_AUTO_TEST_CASE (QuantizeLeakyReLuActivation)

	BOOST_AUTO_TEST_CASE (QuantizeELuActivation)

	BOOST_AUTO_TEST_CASE (QuantizeHardSwishActivation)

	BOOST_AUTO_TEST_CASE (QuantizeBatchNorm)

	BOOST_AUTO_TEST_CASE (QuantizeDepthToSpace)

	BOOST_AUTO_TEST_CASE (OverrideInputRangeEmptyNetwork)

	BOOST_AUTO_TEST_CASE (OverrideInputRangeNoInputLayers)

	BOOST_AUTO_TEST_CASE (OverrideInputRangeInputLayers)

INetworkPtr	CreateNetworkWithFullyConnectedLayer (const bool biasEnabled, const TensorShape &inputShape, const TensorShape &outputShape)

void	ValidateFullyConnectedLayer (const bool biasEnabled)

	BOOST_AUTO_TEST_CASE (QuantizeFill)

	BOOST_AUTO_TEST_CASE (QuantizeFullyConnected)

	BOOST_AUTO_TEST_CASE (QuantizeFullyConnectedBiasEnabled)

void	TestQuantizeConvolution2d (bool useBiases)

	BOOST_AUTO_TEST_CASE (QuantizeConvolution2d)

	BOOST_AUTO_TEST_CASE (QuantizeConvolution2dWithBiases)

void	TestQuantizeDepthwiseConvolution2d (bool useBiases)

	BOOST_AUTO_TEST_CASE (QuantizeDepthwiseConvolution2d)

	BOOST_AUTO_TEST_CASE (QuantizeDepthwiseConvolution2dWithBiases)

	BOOST_AUTO_TEST_CASE (QuantizeInstanceNormalization)

	BOOST_AUTO_TEST_CASE (QuantizeLogSoftmax)

INetworkPtr	CreateNetworkWithSoftmaxLayer (const SoftmaxDescriptor &descriptor, const TensorShape &shape)

	BOOST_AUTO_TEST_CASE (QuantizeSoftmax)

	BOOST_AUTO_TEST_CASE (QuantizeStandIn)

IConnectableLayer *	CreateStartOfLeakyReluNetwork (INetwork *network, const TensorInfo &info)

void	CompleteLeakyReluNetwork (INetwork network, IConnectableLayer activation, IConnectableLayer *layerUnderTest, const TensorInfo &info)

	BOOST_AUTO_TEST_CASE (QuantizePermute)

	BOOST_AUTO_TEST_CASE (QuantizeSpaceToBatch)

	BOOST_AUTO_TEST_CASE (QuantizeSpaceToDepth)

	BOOST_AUTO_TEST_CASE (QuantizePooling2d)

	BOOST_AUTO_TEST_CASE (QuantizeConstant)

	BOOST_AUTO_TEST_CASE (QuantizeArgMinMax)

	BOOST_AUTO_TEST_CASE (QuantizeComparison)

	BOOST_AUTO_TEST_CASE (QuantizeConcat)

	BOOST_AUTO_TEST_CASE (QuantizeReshape)

	BOOST_AUTO_TEST_CASE (QuantizeSplitter)

	BOOST_AUTO_TEST_CASE (QuantizeResize)

	BOOST_AUTO_TEST_CASE (QuantizeStridedSlice)

	BOOST_AUTO_TEST_CASE (QuantizeBatchToSpace)

	BOOST_AUTO_TEST_CASE (QuantizePrelu)

void	TestQuantizeTransposeConvolution2d (bool useBiases)

	BOOST_AUTO_TEST_CASE (QuantizeTransposeConvolution2d)

	BOOST_AUTO_TEST_CASE (QuantizeTransposeConvolution2dWithBiases)

	BOOST_AUTO_TEST_CASE (QuantizeStack)

	BOOST_AUTO_TEST_CASE (QuantizeSlice)

std::vector< uint8_t >	SetupQuantize (float value)

	BOOST_AUTO_TEST_CASE (QuantizeInf)

	BOOST_AUTO_TEST_CASE (QuantizeNegativeInf)

void	PreserveTypeTestImpl (const DataType &dataType)

	BOOST_AUTO_TEST_CASE (PreserveTypeFloat32)

	BOOST_AUTO_TEST_CASE (PreserveTypeQAsymmU8)

	BOOST_AUTO_TEST_CASE (PreserveTypeQsymm8)

	BOOST_AUTO_TEST_CASE (PreserveTypeQsymm16)

	BOOST_AUTO_TEST_CASE (TestConnectionPreservationAfterDynamicQuant)

void	RuntimeLoadedNetworksReserve (armnn::Runtime *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)

profiling::ProfilingService &	GetProfilingService (armnn::Runtime *runtime)

std::ostream &	operator<< (std::ostream &os, const BFloat16 &b)

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::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)

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...

TensorShape	GetUnpaddedTensorStrides (const TensorInfo &tensorInfo)

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)

constexpr const char *	MockImportBackendId ()

constexpr const char *	MockBackendId ()

DataType	GetBiasDataType (DataType inputDataType)

armnn::ConstTensor	PermuteTensor (const ConstCpuTensorHandle 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 ConstCpuTensorHandle 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)

template<typename F >
void	ParseOptions (const std::vector< BackendOptions > &options, BackendId backend, F f)

void	ConfigureTuner (arm_compute::CLTuner &tuner, TuningLevel level)

constexpr const char *	ClBackendId ()

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)

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)

arm_compute::Status	ClBatchToSpaceNdWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &desc)

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)

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)

arm_compute::Status	ClDequantizeWorkloadValidate (const TensorInfo &input, const TensorInfo &output)

arm_compute::Status	ClDivisionWorkloadValidate (const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)

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)

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	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)

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	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)

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 ConstCpuTensorHandle *handle)

RuntimeException	WrapClError (const cl::Error &clError, const CheckLocation &location)

void	RunClFunction (arm_compute::IFunction &function, const CheckLocation &location)

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)

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)

arm_compute::Status	NeonBatchToSpaceNdWorkloadValidate (const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &desc)

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)

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)

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)

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)

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	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)

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	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)

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 ConstCpuTensorHandle *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)

void	ArgMinMax (Decoder< float > &in, int32_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)

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< 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, 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, Decoder< float > &inputDecoder, Encoder< float > &outputEncoder)

void	LogSoftmax (Decoder< float > &input, Encoder< float > &output, const TensorInfo &inputInfo, const LogSoftmaxDescriptor &descriptor)

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	Mean (const armnn::TensorInfo &inputInfo, const armnn::TensorInfo &outputInfo, const std::vector< unsigned int > &axis, Decoder< float > &input, Encoder< float > &output)

void	Pad (const TensorInfo &inputInfo, const TensorInfo &outputInfo, 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 PreluQueueDescriptor &data, Decoder< float > &inputData, Decoder< float > &alphaData, Encoder< float > &outputData)

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 , typename PayloadType >
DataType *	GetOutputTensorData (unsigned int idx, const PayloadType &data)

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)

template<typename DataType >
void	Splitter (const SplitterQueueDescriptor &data)

void	Stack (const StackQueueDescriptor &data, std::vector< std::unique_ptr< Decoder< float >>> &inputs, Encoder< float > &output)

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 std::size_t	g_ProfilingEventCountHint = 1024

constexpr bool	g_WriteProfilingEventSequence = true

constexpr bool	g_AggregateProfilingEventsByInference = true

constexpr bool	g_WriteReportToStdOutOnProfilerDestruction = false

thread_local Profiler *	tl_Profiler = nullptr

const float	g_AsymmU8QuantizationBase = 255.0f

const float	g_AsymmS8QuantizationBase = 255.0f

const float	g_SymmS8QuantizationBase = 127.0f

const float	g_SymmS16QuantizationBase = 32767.0f

const float	g_TestTolerance = 0.000001f

const std::set< armnn::LayerType >	paddingRequiredLayers

Detailed Description

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

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

SPDX-License-Identifier: MIT

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

◆ 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 318 of file Network.hpp.

◆ BaseFloat32ComparisonWorkload

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

Definition at line 172 of file Workload.hpp.

◆ BaseUint8ComparisonWorkload

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

Definition at line 177 of file Workload.hpp.

◆ BFloat16ToFloat32Workload

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

Definition at line 182 of file Workload.hpp.

◆ BindingPointInfo

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

Definition at line 245 of file Tensor.hpp.

◆ BooleanWorkload

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

Definition at line 167 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 49 of file DescriptorsFwd.hpp.

◆ Coordinates

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

Definition at line 94 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 267 of file Types.hpp.

◆ DepthToSpaceDescriptor

typedef SpaceToDepthDescriptor DepthToSpaceDescriptor

A DepthToSpaceDescriptor for the DepthToSpaceLayer.

Definition at line 891 of file Descriptors.hpp.

◆ Dimensions

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

Definition at line 95 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 20 of file ClTensorHandleFactory.cpp.

◆ Float16ToFloat32Workload

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

Definition at line 192 of file Workload.hpp.

◆ Float32ToBFloat16Workload

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

Definition at line 187 of file Workload.hpp.

◆ Float32ToFloat16Workload

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

Definition at line 197 of file Workload.hpp.

◆ Float32Workload

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

Definition at line 158 of file Workload.hpp.

◆ FloatWorkload

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

Definition at line 155 of file Workload.hpp.

◆ Half

using Half = half_float::half

Definition at line 16 of file Half.hpp.

◆ IBackendContextUniquePtr

using IBackendContextUniquePtr = std::unique_ptr<IBackendContext>

Definition at line 30 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 180 of file Types.hpp.

◆ IBackendUniquePtr

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

Definition at line 181 of file Types.hpp.

◆ IGpuAccTunedParametersPtr

using IGpuAccTunedParametersPtr = std::shared_ptr<IGpuAccTunedParameters>

The following API is replaced by the backend options API.

Definition at line 177 of file IRuntime.hpp.

◆ ILayerSupportSharedPtr

using ILayerSupportSharedPtr = std::shared_ptr<ILayerSupport>

Definition at line 413 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 101 of file INetwork.hpp.

◆ INetworkQuantizerPtr

using INetworkQuantizerPtr = std::unique_ptr<class INetworkQuantizer, void(*)(INetworkQuantizer* quantizer)>

Definition at line 29 of file INetworkQuantizer.hpp.

◆ InputQueueDescriptor

using InputQueueDescriptor = MemCopyQueueDescriptor

Definition at line 63 of file WorkloadData.hpp.

◆ InputTensors

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

Definition at line 324 of file Tensor.hpp.

◆ instead

using instead = SubgraphView

Definition at line 102 of file SubgraphView.hpp.

◆ Int32Workload

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

Definition at line 164 of file Workload.hpp.

◆ IOptimizedNetworkPtr

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

Definition at line 593 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 25 of file IRuntime.hpp.

◆ LayerBindingId

using LayerBindingId = int

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

Definition at line 194 of file Types.hpp.

◆ LayerGuid

using LayerGuid = profiling::ProfilingGuid

Define LayerGuid type.

Definition at line 259 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 79 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 150 of file Descriptors.hpp.

◆ MemorySourceFlags

using MemorySourceFlags = unsigned int

Definition at line 21 of file MemorySources.hpp.

◆ MergerDescriptor

using MergerDescriptor = OriginsDescriptor

MergerDescriptor is deprecated, use ConcatDescriptor instead.

Definition at line 53 of file DescriptorsFwd.hpp.

◆ MergerQueueDescriptor

using MergerQueueDescriptor = ConcatQueueDescriptor

Definition at line 121 of file WorkloadData.hpp.

◆ MinMaxRange

using MinMaxRange = std::pair<float, float>

Definition at line 28 of file QuantizerTest.cpp.

◆ MinMaxRangeMap

using MinMaxRangeMap = std::unordered_map<LayerGuid, MinMaxRanges>

Definition at line 30 of file QuantizerTest.cpp.

◆ MinMaxRanges

using MinMaxRanges = std::vector<MinMaxRange>

Definition at line 29 of file QuantizerTest.cpp.

◆ NetworkId

using NetworkId = int

Definition at line 20 of file IRuntime.hpp.

◆ NetworkOptions

using NetworkOptions = std::vector<BackendOptions>

Definition at line 15 of file BackendOptions.hpp.

◆ OffsetScalePair

using OffsetScalePair = std::pair<float, int>

Definition at line 16 of file NetworkQuantizationScheme.hpp.

◆ OutputQueueDescriptor

using OutputQueueDescriptor = MemCopyQueueDescriptor

Definition at line 64 of file WorkloadData.hpp.

◆ OutputTensors

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

Definition at line 325 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 42 of file RefElementwiseWorkload.hpp.

◆ RefDebugBFloat16Workload

using RefDebugBFloat16Workload = RefDebugWorkload<DataType::BFloat16>

Definition at line 40 of file RefDebugWorkload.hpp.

◆ RefDebugFloat16Workload

using RefDebugFloat16Workload = RefDebugWorkload<DataType::Float16>

Definition at line 41 of file RefDebugWorkload.hpp.

◆ RefDebugFloat32Workload

using RefDebugFloat32Workload = RefDebugWorkload<DataType::Float32>

Definition at line 42 of file RefDebugWorkload.hpp.

◆ RefDebugQAsymmS8Workload

using RefDebugQAsymmS8Workload = RefDebugWorkload<DataType::QAsymmS8>

Definition at line 44 of file RefDebugWorkload.hpp.

◆ RefDebugQAsymmU8Workload

using RefDebugQAsymmU8Workload = RefDebugWorkload<DataType::QAsymmU8>

Definition at line 43 of file RefDebugWorkload.hpp.

◆ RefDebugQSymmS16Workload

using RefDebugQSymmS16Workload = RefDebugWorkload<DataType::QSymmS16>

Definition at line 45 of file RefDebugWorkload.hpp.

◆ RefDebugQSymmS8Workload

using RefDebugQSymmS8Workload = RefDebugWorkload<DataType::QSymmS8>

Definition at line 46 of file RefDebugWorkload.hpp.

◆ RefDebugSigned32Workload

using RefDebugSigned32Workload = RefDebugWorkload<DataType::Signed32>

Definition at line 47 of file RefDebugWorkload.hpp.

◆ RefDivisionWorkload

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

Definition at line 60 of file RefElementwiseWorkload.hpp.

◆ RefMaximumWorkload

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

Definition at line 66 of file RefElementwiseWorkload.hpp.

◆ RefMinimumWorkload

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

Definition at line 72 of file RefElementwiseWorkload.hpp.

◆ RefMultiplicationWorkload

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

Definition at line 54 of file RefElementwiseWorkload.hpp.

◆ RefPermuteBFloat16Workload

using RefPermuteBFloat16Workload = RefPermuteWorkload<DataType::BFloat16>

Definition at line 30 of file RefPermuteWorkload.hpp.

◆ RefPermuteFloat16Workload

using RefPermuteFloat16Workload = RefPermuteWorkload<DataType::Float16>

Definition at line 31 of file RefPermuteWorkload.hpp.

◆ RefPermuteFloat32Workload

using RefPermuteFloat32Workload = RefPermuteWorkload<DataType::Float32>

Definition at line 32 of file RefPermuteWorkload.hpp.

◆ RefPermuteQAsymm8Workload

using RefPermuteQAsymm8Workload = RefPermuteWorkload<DataType::QAsymmU8>

Definition at line 34 of file RefPermuteWorkload.hpp.

◆ RefPermuteQAsymmS8Workload

using RefPermuteQAsymmS8Workload = RefPermuteWorkload<DataType::QAsymmS8>

Definition at line 33 of file RefPermuteWorkload.hpp.

◆ RefPermuteQSymm16Workload

using RefPermuteQSymm16Workload = RefPermuteWorkload<DataType::QSymmS16>

Definition at line 35 of file RefPermuteWorkload.hpp.

◆ RefSubtractionWorkload

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

Definition at line 48 of file RefElementwiseWorkload.hpp.

◆ RefTransposeBFloat16Workload

using RefTransposeBFloat16Workload = RefTransposeWorkload<DataType::BFloat16>

Definition at line 30 of file RefTransposeWorkload.hpp.

◆ RefTransposeFloat16Workload

using RefTransposeFloat16Workload = RefTransposeWorkload<DataType::Float16>

Definition at line 31 of file RefTransposeWorkload.hpp.

◆ RefTransposeFloat32Workload

using RefTransposeFloat32Workload = RefTransposeWorkload<DataType::Float32>

Definition at line 32 of file RefTransposeWorkload.hpp.

◆ RefTransposeQAsymm8Workload

using RefTransposeQAsymm8Workload = RefTransposeWorkload<DataType::QAsymmU8>

Definition at line 34 of file RefTransposeWorkload.hpp.

◆ RefTransposeQAsymmS8Workload

using RefTransposeQAsymmS8Workload = RefTransposeWorkload<DataType::QAsymmS8>

Definition at line 33 of file RefTransposeWorkload.hpp.

◆ RefTransposeQSymm16Workload

using RefTransposeQSymm16Workload = RefTransposeWorkload<DataType::QSymmS16>

Definition at line 35 of file RefTransposeWorkload.hpp.

◆ ResolveType

using ResolveType = typename ResolveTypeImpl<DT>::Type

Definition at line 73 of file ResolveType.hpp.

◆ SplitterDescriptor

using SplitterDescriptor = ViewsDescriptor

Definition at line 54 of file DescriptorsFwd.hpp.

◆ supported

using supported = ISubgraphViewConverter

Definition at line 31 of file ISubgraphViewConverter.hpp.

◆ TContainer

using TContainer = boost::variant<std::vector<float>, std::vector<int>, std::vector<unsigned char> >

Definition at line 34 of file NetworkQuantizer.cpp.

◆ Uint8ToFloat32Workload

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

Definition at line 202 of file Workload.hpp.

◆ Uint8Workload

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

Definition at line 161 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 55 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 71 of file Types.hpp.

 {
     Min = 0,
     Max = 1
 };

◆ BoostLogSeverityMapping

enum BoostLogSeverityMapping

strong

Enumerator
trace
debug
info
warning
error
fatal

Definition at line 147 of file Logging.hpp.

◆ 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
CapabilityClassMax

Definition at line 20 of file ITensorHandleFactory.hpp.

 {
     PaddingRequired = 1,
 
     // add new enum values here
 
     CapabilityClassMax = 254
 };

◆ ComparisonOperation

enum ComparisonOperation

strong

Enumerator
Equal
Greater
GreaterOrEqual
Less
LessOrEqual
NotEqual

Definition at line 77 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 49 of file Types.hpp.

 {
     NCHW = 1,
     NHWC = 2
 };

◆ DataType

enum DataType

strong

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

Definition at line 32 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,
 
     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 109 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 97 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

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
LogSoftmax
Lstm
QLstm
Maximum
Mean
MemCopy
MemImport
Merge
Minimum
Multiplication
Normalization
Output
Pad
Permute
Pooling2d
PreCompiled
Prelu
Quantize
QuantizedLstm
Reshape
Rank
Resize
Slice
Softmax
SpaceToBatchNd
SpaceToDepth
Splitter
Stack
StandIn
StridedSlice
Subtraction
Switch
Transpose
TransposeConvolution2d
FirstLayer
LastLayer

Definition at line 83 of file InternalTypes.hpp.

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

◆ LogSeverity

enum LogSeverity

strong

Enumerator
Trace
Debug
Info
Warning
Error
Fatal

Definition at line 12 of file Utils.hpp.

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

◆ MemorySource

enum MemorySource

strong

Enumerator
Undefined
Malloc
DmaBuf
DmaBufProtected

Definition at line 13 of file MemorySources.hpp.

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

◆ NormalizationAlgorithmChannel

enum NormalizationAlgorithmChannel

strong

Enumerator
Across
Within

Definition at line 133 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 139 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 147 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 125 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 96 of file Types.hpp.

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

◆ ResizeMethod

enum ResizeMethod

strong

Enumerator
Bilinear
NearestNeighbor

Definition at line 103 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 161 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 26 of file Types.hpp.

 {
     Success = 0,
     Failure = 1
 };

◆ TuningLevel

enum TuningLevel

strong

Enumerator
None
Rapid
Normal
Exhaustive

Definition at line 69 of file ClBackendContext.cpp.

 {
     None,
     Rapid,
     Normal,
     Exhaustive
 };

◆ UnaryOperation

enum UnaryOperation

strong

Enumerator
Abs
Exp
Sqrt
Rsqrt
Neg

Definition at line 87 of file Types.hpp.

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

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 103 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] = boost::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] = boost::numeric_cast<float>(numSelected);
 }

◆ AllTypesAreEqualImpl() [1/2]

bool armnn::AllTypesAreEqualImpl ( T )

Definition at line 60 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 66 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	(	OptimizedNetwork *	optNetObjPtr,
		BackendSettings &	backendSettings,
		BackendsMap &	backends,
		Optional< std::vector< std::string > &>	errMessages
	)

Definition at line 541 of file Network.cpp.

References ARMNN_ASSERT, AssignBackends(), SubgraphView::begin(), SubgraphView::end(), Layer::GetBackendId(), OptimizationViews::GetFailedSubgraphs(), OptimizedNetwork::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;
         }
 
         // Try to optimize each sub-graph
         for (auto& subgraph : subgraphs)
         {
             // Try to optimize the current sub-graph
             OptimizationViews optimizationViews = backendObjPtr->OptimizeSubgraphView(*subgraph);
             ARMNN_ASSERT(optimizationViews.Validate(*subgraph));
 
             // Optimization attempted, check the resulting optimized sub-graph
             for (auto& substitution : optimizationViews.GetSubstitutions())
             {
                 // Sub-graph optimized, substitute the sub-graph with the new optimized one in the main optimized graph
                 SubgraphView& replacementSubgraph   = substitution.m_ReplacementSubgraph;
                 SubgraphView& substitutableSubgraph = substitution.m_SubstitutableSubgraph;
                 optGraph.SubstituteSubgraph(substitutableSubgraph, replacementSubgraph);
 
                 // Assign the current backend to the optimized sub-graph
                 std::for_each(replacementSubgraph.begin(), replacementSubgraph.end(), [&selectedBackend](Layer* l)
                     {
                         ARMNN_ASSERT(l);
                         l->SetBackendId(selectedBackend);
                     });
             }
 
             if (!optimizationViews.GetFailedSubgraphs().empty())
             {
                 std::stringstream warningMsg;
                 warningMsg << "Some sub-graph(s) failed to optimized on " << backendObjPtr->GetId() << " backend.";
                 ReportWarning(warningMsg.str(), errMessages);
 
                 // Failed to optimize the given sub-graph, re-assign the sub-graph layers to other available backends
                 BackendSettings settingsCopy(backendSettings);
                 if (!backendObjPtr->GetId().IsCpuRef())
                 {
                     // Add the current backend to the list of backends to ignore
                     settingsCopy.m_IgnoredBackends.insert(backendObjPtr->GetId());
                 }
 
                 int count=0;
                 for (auto& failedSubgraph : optimizationViews.GetFailedSubgraphs())
                 {
                     // An error occurred: the optimization was attempted but not performed, try different backends
                     std::stringstream subgraphMsg;
                     subgraphMsg << "Re-assigning backends to " << failedSubgraph.GetLayers().size()
                                 << " layers inside sub-graph " << count++;
                     ReportWarning(subgraphMsg.str(), errMessages);
 
                     OptimizationResult reassignmentResult = AssignBackends(optNetObjPtr,
                                                                            settingsCopy,
                                                                            *subgraph,
                                                                            errMessages);
                     if (reassignmentResult.m_Error)
                     {
                         // Failed to re-assign one of the remaining backends to each layer of the sub-graph
                         result.m_Error = true;
                         return result;
                     }
                 }
             }
         }
     }
 
     return result;
 }

◆ ArgMinMax()

void ArgMinMax	(	Decoder< float > &	in,
		int32_t *	out,
		const TensorInfo &	inputTensorInfo,
		const TensorInfo &	outputTensorInfo,
		ArgMinMaxFunction	function,
		int	axis
	)

Definition at line 15 of file ArgMinMax.cpp.

References Decoder< IType >::Get(), TensorInfo::GetNumDimensions(), armnnUtils::GetNumElementsBetween(), TensorInfo::GetShape(), armnnUtils::GetUnsignedAxis(), IgnoreUnused(), Max, Min, and numeric_cast().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     IgnoreUnused(outputTensorInfo);
 
     unsigned int uAxis = armnnUtils::GetUnsignedAxis(inputTensorInfo.GetNumDimensions(), axis);
 
     const unsigned int outerElements = armnnUtils::GetNumElementsBetween(inputTensorInfo.GetShape(), 0, uAxis);
     const unsigned int axisSize = inputTensorInfo.GetShape()[uAxis];
     const unsigned int innerElements = armnnUtils::GetNumElementsBetween(inputTensorInfo.GetShape(),
                                                                          uAxis + 1,
                                                                          inputTensorInfo.GetNumDimensions());
 
     for (unsigned int outer = 0; outer < outerElements; ++outer) {
         for (unsigned int inner = 0; inner < innerElements; ++inner) {
             in[outer * axisSize * innerElements + inner];
             auto tmpValue = in.Get();
             unsigned int tmpIndex = 0;
             for (unsigned int i = 1; i < axisSize; ++i) {
                 in[(outer * axisSize * innerElements) + (i * innerElements) + inner];
                 const auto& value = in.Get();
                 if ((function == armnn::ArgMinMaxFunction::Min && value < tmpValue) ||
                     (function == armnn::ArgMinMaxFunction::Max &&  value > tmpValue)) {
                     tmpValue = value;
                     tmpIndex = i;
                 }
             }
             out[outer * innerElements + inner] = boost::numeric_cast<int32_t>(tmpIndex);
         }
     }
 }

◆ AssignBackends() [1/2]

OptimizationResult AssignBackends	(	OptimizedNetwork *	optNetObjPtr,
		BackendSettings &	backendSettings,
		Graph::Iterator &	firstLayer,
		Graph::Iterator &	lastLayer,
		Optional< std::vector< std::string > &>	errMessages
	)

Definition at line 382 of file Network.cpp.

References ARMNN_ASSERT_MSG, AttemptBackendAssignment(), CheckScaleSetOnQuantizedType(), Constant, CpuRef, Float32, BackendSettings::GetAvailablePreferredBackends(), OptimizedNetwork::GetGraph(), BackendSettings::IsBackendSupported(), BackendSettings::IsCpuRefUsed(), OptimizationResult::IsError(), OptimizationResult::IsOk(), OptimizationResult::IsWarningOnly(), OptimizationResult::m_Error, BackendSettings::m_SelectedBackends, MemCopy, Permute, ReportError(), and ReturnWithError().

Referenced by ApplyBackendOptimizations(), AssignBackends(), BOOST_AUTO_TEST_CASE(), and Optimize().

 {
     OptimizationResult result;
 
     // Helper lambda to compose meaningful error message before returning with error
     auto ReturnError = [&](const Layer* layer)
         {
             return ReturnWithError(result, layer, backendSettings, errMessages);
         };
 
 
     auto availablePreferredBackends = backendSettings.GetAvailablePreferredBackends();
     if (availablePreferredBackends.empty())
     {
         std::stringstream failureMsg;
         failureMsg << "No preferred backends are available";
         ReportError(failureMsg.str(), errMessages);
 
         result.m_Error = true;
         return result;
     }
 
     for (auto it = firstLayer; it != lastLayer; ++it)
     {
         auto layer = *it;
 
         DataType dataTypeIn  = layer->GetNumInputSlots() == 0 ? DataType::Float32 :
             layer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo().GetDataType();
         DataType dataTypeOut = layer->GetNumOutputSlots() == 0 ? DataType::Float32 :
             layer->GetOutputSlot(0).GetTensorInfo().GetDataType();
 
         std::string reasonIfUnsupported;
         bool found = false;
         if (!CheckScaleSetOnQuantizedType(layer, errMessages))
         {
             // don't bomb immediately, find all the quantized outputs
             // which haven't had a scale set and report them all back.
             result.m_Error = true;
         }
 
         // First try assign layer to hint backend
         if (layer->GetBackendHint().has_value() &&
             backendSettings.IsBackendSupported(layer->GetBackendHint().value()) &&
             AttemptBackendAssignment(backendSettings,
                                      optNetObjPtr->GetGraph(),
                                      layer,
                                      layer->GetBackendHint().value(),
                                      dataTypeIn,
                                      dataTypeOut,
                                      availablePreferredBackends,
                                      reasonIfUnsupported,
                                      errMessages).IsOk())
         {
             found = true;
             backendSettings.m_SelectedBackends.insert(layer->GetBackendHint().value());
         }
         else
         {
             // Try assign layer to prefered list of backends
             for (const auto& backend : availablePreferredBackends)
             {
                 if (layer->GetBackendHint().has_value() &&
                     layer->GetBackendHint().value() == backend)
                 {
                     continue; //Don't re-test the backend hint
                 }
 
                 OptimizationResult res = AttemptBackendAssignment(backendSettings,
                                                                   optNetObjPtr->GetGraph(),
                                                                   layer,
                                                                   backend,
                                                                   dataTypeIn,
                                                                   dataTypeOut,
                                                                   availablePreferredBackends,
                                                                   reasonIfUnsupported,
                                                                   errMessages);
 
                 if (res.IsOk())
                 {
                     found = true;
                     backendSettings.m_SelectedBackends.insert(backend);
                     break;
                 }
                 else if (res.IsError())
                 {
                    return res;  // Cannot continue.
                    // Note: we don't need to log the error as it would already
                    // be logged in AttemptBackendAssignment().
                 }
                 else
                 {
                     ARMNN_ASSERT_MSG(res.IsWarningOnly(), "OptimizationResult in unexpected state.");
                 }
             }
         }
 
         // If the layer is unsupported by any devices, log and return a null network.
         if (!found)
         {
             // NOTE: if the layer is not an operation queue type AND we have not got CpuRef as a
             //       fallback we should set the compute device on the layer to CpuRef (these are not
             //       available as accelerated operations, or are only available under certain
             //       conditions, currently they comprise MemCopy, Constant, Permute)
             armnn::LayerType layerType = layer->GetType();
             if (!backendSettings.IsCpuRefUsed() && (layerType == armnn::LayerType::MemCopy ||
                                                     layerType == armnn::LayerType::Constant ||
                                                     layerType == armnn::LayerType::Permute))
             {
                 BackendId cpuBackendId(armnn::Compute::CpuRef);
                 layer->SetBackendId(cpuBackendId);
                 backendSettings.m_SelectedBackends.insert(cpuBackendId);
             }
             else
             {
                 return ReturnError(layer);
             }
         }
     }
 
     return result;
 }

◆ AssignBackends() [2/2]

OptimizationResult armnn::AssignBackends	(	OptimizedNetwork *	optNetObjPtr,
		BackendSettings &	backendSettings,
		SubgraphView &	subgraph,
		Optional< std::vector< std::string > &>	errMessages
	)

Definition at line 508 of file Network.cpp.

References AssignBackends(), SubgraphView::begin(), and SubgraphView::end().

 {
     Graph::Iterator firstLayer = subgraph.begin();
     Graph::Iterator lastLayer  = subgraph.end();
     return AssignBackends(optNetObjPtr,
                           backendSettings,
                           firstLayer,
                           lastLayer,
                           errMessages);
 }

◆ AssignSplitId()

void armnn::AssignSplitId	(	LayerSelectionInfo::LayerInfoContainer &	layerInfos,
		LayerSelectionInfo &	layerInfo
	)

Definition at line 305 of file SubgraphViewSelector.cpp.

References ForEachLayerInput().

Referenced by SubgraphViewSelector::SelectSubgraphs().

 {
     // Check each input to see if we can attach ourselves to any of the subgraphs that have already been assigned.
     ForEachLayerInput(layerInfos, layerInfo, [&](LayerSelectionInfo& parentInfo)
     {
         // We can only attach ourselves to the subgraph from this input if there isn't a cut here.
         if (layerInfo.m_IsSelected == parentInfo.m_IsSelected)
         {
             // We also need to check that merging into this subgraph won't cause a dependency cycle between subgraphs.
             // This will be the case if the subgraph that we will become part of is already a dependency
             // of one of the subgraphs that are input to this layer, e.g:
             //
             //    0     |  The numbers (0, 1) are the subgraph IDs of each layer and we are looking at layer X.
             //   / \    |
             //  1   0   |  We can't merge X into subgraph 0, because the left-hand input already depends on subgraph 0.
             //   \ /    |  We can however merge X into subgraph 1.
             //    X     |
             //
             bool dependenciesOk = true;
             ForEachLayerInput(layerInfos, layerInfo, [&](LayerSelectionInfo& otherParentInfo)
             {
                 // We call HasAntecedent() ~ n^2 times, where n is the number of inputs to this layer.
                 // Hence it is important that this is efficient - see PartialSubgraph class description.
                 if (otherParentInfo.m_Subgraph->HasAntecedent(parentInfo.m_Subgraph.get()))
                 {
                     dependenciesOk = false;
                 }
             });
 
             if (dependenciesOk)
             {
                 // Merge into the subgraph of this input. If we have already been merged into another subgraph
                 // (from another input of this layer), then merge both of them together.
                 if (layerInfo.m_Subgraph == nullptr)
                 {
                     layerInfo.m_Subgraph = parentInfo.m_Subgraph;
                 }
                 else
                 {
                     // We call MergeWith() ~ n times, where n is the number of inputs to this layer.
                     // Therefore it does not need to be as performant as HasAntecedent().
                     layerInfo.m_Subgraph->MergeWith(parentInfo.m_Subgraph.get());
                 }
             }
         }
     });
 
     // If we weren't able to merge into an existing subgraph then we need to make a new one
     if (layerInfo.m_Subgraph == nullptr)
     {
         layerInfo.m_Subgraph = std::make_shared<PartialSubgraph>();
     }
 
     // Record dependencies of the chosen subgraph based on the inputs of this layer.
     ForEachLayerInput(layerInfos, layerInfo, [&](LayerSelectionInfo& parentInfo)
     {
         // These functions are called ~n times, where n is the number of inputs to this layer.
         // Therefore it does not need to be as performant as HasAntecedent().
         if (!layerInfo.m_Subgraph->IsMergedWith(parentInfo.m_Subgraph.get()))
         {
             layerInfo.m_Subgraph->AddDirectAntecedent(parentInfo.m_Subgraph.get());
         }
     });
 }

◆ AttemptBackendAssignment()

OptimizationResult armnn::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
	)

Definition at line 174 of file Network.cpp.

References BFloat16, ConvertBf16ToFp32, ConvertFp16ToFp32, ConvertFp32ToBf16, ConvertFp32ToFp16, Convolution2d, Float16, Float32, FullyConnected, BackendId::Get(), Layer::GetBackendId(), GetDataTypeName(), GetLayerTypeAsCString(), Layer::GetType(), InsertConvertBf16ToFp32LayersBefore(), InsertConvertFp16ToFp32LayersBefore(), InsertConvertFp32ToBf16LayersAfter(), InsertConvertFp32ToFp16LayersAfter(), IWorkloadFactory::IsLayerSupported(), ReportWarning(), ReturnWithError(), and Layer::SetBackendId().

Referenced by AssignBackends().

 {
     OptimizationResult result;
 
     // Helper lambda to compose meaningful error message before returning with error
     auto ReturnError = [&](const Layer* layer)
         {
             return ReturnWithError(result, layer, backendSettings, errMessages);
         };
 
     // need to set the compute device on the layer
     // before we can check if it is supported
     layer->SetBackendId(backend);
     if (!IWorkloadFactory::IsLayerSupported(*layer, EmptyOptional(), reasonIfUnsupported))
     {
         if (dataTypeIn == DataType::Float16 || dataTypeOut == DataType::Float16)
         {
             if (IWorkloadFactory::IsLayerSupported(*layer, DataType::Float32, reasonIfUnsupported)
                 && layer->GetType() != LayerType::ConvertFp32ToFp16
                 && layer->GetType() != LayerType::ConvertFp16ToFp32)
             {
                 // Insert FP16 -> FP32 conversion layer before current layer
                 std::vector<ConvertFp16ToFp32Layer*> convertFp16ToFp32Layers;
                 if (dataTypeIn == DataType::Float16)
                 {
                     convertFp16ToFp32Layers =
                         InsertConvertFp16ToFp32LayersBefore(graph, *layer);
                 }
 
                 // Insert FP32 -> FP16 conversion layer after current layer
                 std::vector<ConvertFp32ToFp16Layer*> convertFp32ToFp16Layers;
                 if (dataTypeOut == DataType::Float16)
                 {
                     convertFp32ToFp16Layers =
                         InsertConvertFp32ToFp16LayersAfter(graph, *layer);
                 }
 
                 // Assign a supported backend to the newly introduced conversion layers
                 auto AssignFirstSupportedBackend = [&](Layer* layer, BackendId preferredBackend)
                     {
                         bool supportedBackendFound = false;
                         std::string reasonIfUnsupported;
 
                         // Try preferred backend first
                         layer->SetBackendId(preferredBackend);
                         if (IWorkloadFactory::IsLayerSupported(*layer,
                                                                EmptyOptional(),
                                                                reasonIfUnsupported))
                         {
                             supportedBackendFound = true;
                         }
                         else
                         {
                             for (const auto& backend : availablePreferredBackends)
                             {
                                 // Skip preferred backend (we already determined that it is not supported)
                                 if (backend == preferredBackend)
                                 {
                                     continue;
                                 }
 
                                 layer->SetBackendId(backend);
                                 if (IWorkloadFactory::IsLayerSupported(*layer,
                                                                        EmptyOptional(),
                                                                        reasonIfUnsupported))
                                 {
                                     supportedBackendFound = true;
                                     break;
                                 }
                             }
                         }
 
                         return supportedBackendFound;
                     };
 
                 for (ConvertFp16ToFp32Layer* convertLayer : convertFp16ToFp32Layers)
                 {
                     if (!AssignFirstSupportedBackend(convertLayer, backend))
                     {
                         return ReturnError(convertLayer);
                     }
                 }
 
                 for (ConvertFp32ToFp16Layer* convertLayer : convertFp32ToFp16Layers)
                 {
                     if (!AssignFirstSupportedBackend(convertLayer, backend))
                     {
                         return ReturnError(convertLayer);
                     }
                 }
 
                 return result;
             }
         }
         else if (dataTypeIn == DataType::BFloat16 || dataTypeOut == DataType::BFloat16)
         {
             if (IWorkloadFactory::IsLayerSupported(*layer, DataType::Float32, reasonIfUnsupported)
                 && layer->GetType() != LayerType::ConvertFp32ToBf16
                 && layer->GetType() != LayerType::ConvertBf16ToFp32)
             {
                 // Insert BF16 -> FP32 conversion layer before current layer
                 std::vector<ConvertBf16ToFp32Layer*> convertBf16ToFp32Layers;
                 if (dataTypeIn == DataType::BFloat16)
                 {
                     convertBf16ToFp32Layers =
                         InsertConvertBf16ToFp32LayersBefore(graph, *layer);
                     if (layer->GetType() == LayerType::Convolution2d)
                     {
                         ConvertBf16ToFp32Weight<Convolution2dLayer>(layer);
                     }
                     else if (layer->GetType() == LayerType::FullyConnected)
                     {
                         ConvertBf16ToFp32Weight<FullyConnectedLayer>(layer);
                     }
                 }
 
                 // Insert FP32 -> BF16 conversion layer after current layer
                 std::vector<ConvertFp32ToBf16Layer*> convertFp32ToBf16Layers;
                 if (dataTypeOut == DataType::BFloat16)
                 {
                     convertFp32ToBf16Layers =
                         InsertConvertFp32ToBf16LayersAfter(graph, *layer);
                 }
 
                 // Assign a supported backend to the newly introduced conversion layers
                 auto AssignFirstSupportedBackend = [&](Layer* layer, BackendId preferredBackend)
                     {
                         bool supportedBackendFound = false;
                         std::string reasonIfUnsupported;
 
                         // Try preferred backend first
                         layer->SetBackendId(preferredBackend);
                         if (IWorkloadFactory::IsLayerSupported(*layer,
                                                                EmptyOptional(),
                                                                reasonIfUnsupported))
                         {
                             supportedBackendFound = true;
                         }
                         else
                         {
                             for (const auto& backend : availablePreferredBackends)
                             {
                                 // Skip preferred backend (we already determined that it is not supported)
                                 if (backend == preferredBackend)
                                 {
                                     continue;
                                 }
 
                                 layer->SetBackendId(backend);
                                 if (IWorkloadFactory::IsLayerSupported(*layer,
                                                                        EmptyOptional(),
                                                                        reasonIfUnsupported))
                                 {
                                     supportedBackendFound = true;
                                     break;
                                 }
                             }
                         }
 
                         return supportedBackendFound;
                     };
 
                 for (ConvertBf16ToFp32Layer* convertLayer : convertBf16ToFp32Layers)
                 {
                     if (!AssignFirstSupportedBackend(convertLayer, backend))
                     {
                         return ReturnError(convertLayer);
                     }
                 }
 
                 for (ConvertFp32ToBf16Layer* convertLayer : convertFp32ToBf16Layers)
                 {
                     if (!AssignFirstSupportedBackend(convertLayer, backend))
                     {
                         return ReturnError(convertLayer);
                     }
                 }
 
                 return result;
             }
         }
 
         std::stringstream warningMsg;
         warningMsg << "Layer of type " << GetLayerTypeAsCString(layer->GetType())
                    << " is not supported on requested backend " << layer->GetBackendId().Get()
                    << " for input data type " << GetDataTypeName(dataTypeIn)
                    << " and output data type " << GetDataTypeName(dataTypeOut)
                    << " (reason: " << reasonIfUnsupported
                    << "), falling back to the next backend.";
         ReportWarning(warningMsg.str(), errMessages);
 
         return OptimizationResult(true, false);
     }
     else
     {
         return result;
     }
 }

◆ BackendRegistryInstance()

BackendRegistry & BackendRegistryInstance ( )

Definition at line 13 of file BackendRegistry.cpp.

Referenced by InferenceModel< IParser, TDataType >::AddCommandLineOptions(), BOOST_AUTO_TEST_CASE(), CreateBackendObject(), CreateSupportedBackends(), DynamicBackendUtils::DeregisterDynamicBackends(), GetILayerSupportByBackendId(), ProfilingService::GetSendTimelinePacket(), GetSuitableBackendRegistered(), IWorkloadFactory::IsLayerSupported(), main(), LoadedNetwork::MakeLoadedNetwork(), MockBackendInitialiser::MockBackendInitialiser(), MockImportBackendInitialiser::MockImportBackendInitialiser(), Optimize(), DynamicBackendUtils::RegisterDynamicBackends(), RunCsvTest(), Runtime::Runtime(), RuntimeEmptyTestImpl(), RuntimeInvalidOverridePathTestImpl(), TestBackendRegistry::TestBackendRegistry(), MockBackendInitialiser::~MockBackendInitialiser(), MockImportBackendInitialiser::~MockImportBackendInitialiser(), Runtime::~Runtime(), and TestBackendRegistry::~TestBackendRegistry().

 {
     static BackendRegistry instance;
     return instance;
 }

◆ BatchNormImpl()

void BatchNormImpl	(	const BatchNormalizationQueueDescriptor &	data,
		Decoder< float > &	meanDecoder,
		Decoder< float > &	varianceDecoder,
		Decoder< float > &	betaDecoder,
		Decoder< float > &	gammaDecoder,
		Decoder< float > &	inputDecoder,
		Encoder< float > &	outputEncoder
	)

Definition at line 18 of file BatchNormImpl.cpp.

References Decoder< IType >::Get(), DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), DataLayoutIndexed::GetIndex(), TensorInfo::GetShape(), GetTensorInfo(), DataLayoutIndexed::GetWidthIndex(), BatchNormalizationDescriptor::m_DataLayout, BatchNormalizationDescriptor::m_Eps, QueueDescriptor::m_Inputs, QueueDescriptorWithParameters< LayerDescriptor >::m_Parameters, and Encoder< IType >::Set().

Referenced by RefBatchNormalizationWorkload::Execute().

 {
     const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[0]);
     const TensorShape inputShape = inputInfo.GetShape();
 
     armnnUtils::DataLayoutIndexed dataLayout(data.m_Parameters.m_DataLayout);
 
     unsigned int inputBatches  = inputShape[0];
     unsigned int inputHeight   = inputShape[dataLayout.GetHeightIndex()];
     unsigned int inputWidth    = inputShape[dataLayout.GetWidthIndex()];
     unsigned int inputChannels = inputShape[dataLayout.GetChannelsIndex()];
 
     for (unsigned int c = 0; c < inputChannels; c++)
     {
         meanDecoder[c];
         varianceDecoder[c];
         betaDecoder[c];
         gammaDecoder[c];
         float mean  = meanDecoder.Get();
         float var   = varianceDecoder.Get();
         float beta  = betaDecoder.Get();
         float gamma = gammaDecoder.Get();
 
         float mult = gamma / sqrtf(var + data.m_Parameters.m_Eps);
         float add  = beta - mult * mean;
 
         for (unsigned int n = 0; n < inputBatches; n++)
         {
             for (unsigned int h = 0; h < inputHeight; h++)
             {
                 for (unsigned int w = 0; w < inputWidth; w++)
                 {
                     unsigned int index = dataLayout.GetIndex(inputShape, n, c, h, w);
                     inputDecoder[index];
                     outputEncoder[index];
                     outputEncoder.Set(mult * inputDecoder.Get() + add);
                 }
             }
         }
     }
 }

◆ BatchToSpaceNd()

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
	)

Definition at line 35 of file BatchToSpaceNd.cpp.

References ARMNN_ASSERT_MSG, BatchToSpaceNd(), Decoder< IType >::Get(), DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), TensorShape::GetNumDimensions(), TensorInfo::GetShape(), DataLayoutIndexed::GetWidthIndex(), Offset(), and Encoder< IType >::Set().

Referenced by BatchToSpaceNd(), BatchToSpaceNdLayer::BatchToSpaceNdLayer(), and BOOST_AUTO_TEST_CASE().

 {
     TensorShape inputShape = inputTensorInfo.GetShape();
 
     ARMNN_ASSERT_MSG(inputShape.GetNumDimensions() == 4, "Expected Input with 4 Dimensions");
 
     TensorShape outputShape = outputTensorInfo.GetShape();
 
     ARMNN_ASSERT_MSG(outputShape.GetNumDimensions() == 4, "Expected Output with 4 Dimensions");
 
     const unsigned int inputBatchSize = inputShape[0];
     const unsigned int channels = inputShape[dataLayout.GetChannelsIndex()];
 
     const unsigned int outputBatchSize = outputShape[0];
     const unsigned int outputHeight = outputShape[dataLayout.GetHeightIndex()];
     const unsigned int outputWidth = outputShape[dataLayout.GetWidthIndex()];
 
     ARMNN_ASSERT_MSG(blockShape.size() > 0, "BlockShape must contain 1 or more entries");
 
     const unsigned int blockShapeHeight = blockShape[0];
     const unsigned int blockShapeWidth = blockShape[1];
 
     ARMNN_ASSERT_MSG(cropsData.size() > 0, "Crops must contain 1 or more entries");
 
     const unsigned int cropsTop = cropsData[0].first;
     const unsigned int cropsLeft = cropsData[1].first;
 
     for (unsigned int inBatch = 0; inBatch < inputBatchSize; ++inBatch)
     {
         const unsigned int outBatch = inBatch % outputBatchSize;
         const unsigned int spatialOffset = inBatch / outputBatchSize;
 
         for (unsigned int inH = 0; inH < inputTensorInfo.GetShape()[dataLayout.GetHeightIndex()]; ++inH) {
             const unsigned int outH = inH * blockShapeHeight + spatialOffset / blockShapeWidth - cropsTop;
 
             if (outH >= outputHeight)
             {
                 continue;
             }
 
             for (unsigned int inW = 0; inW < inputTensorInfo.GetShape()[dataLayout.GetWidthIndex()]; ++inW) {
                 const unsigned int outW = inW * blockShapeWidth + spatialOffset % blockShapeWidth - cropsLeft;
 
                 if (outW >= outputWidth)
                 {
                     continue;
                 }
 
                 for (unsigned int c = 0; c < channels; c++)
                 {
                     unsigned int outOffset = Offset(outputShape, outBatch, outH, outW, c, dataLayout);
                     unsigned int inOffset = Offset(inputShape, inBatch, inH, inW, c, dataLayout);
 
                     outputEncoder[outOffset];
                     inputDecoder[inOffset];
                     outputEncoder.Set(inputDecoder.Get());
                 }
             }
         }
     }
 }

◆ BOOST_AUTO_TEST_CASE() [1/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckInputLayerVisitorBindingIdAndName )

Definition at line 13 of file TestInputOutputLayerVisitor.cpp.

References IConnectableLayer::Accept(), and Network::AddInputLayer().

 {
     const char* layerName = "InputLayer";
     TestInputLayerVisitor visitor(1, layerName);
     Network net;
 
     IConnectableLayer *const layer = net.AddInputLayer(1, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [2/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckInputLayerVisitorBindingIdAndNameNull )

Definition at line 23 of file TestInputOutputLayerVisitor.cpp.

References IConnectableLayer::Accept(), and Network::AddInputLayer().

 {
     TestInputLayerVisitor visitor(1);
     Network net;
 
     IConnectableLayer *const layer = net.AddInputLayer(1);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [3/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckOutputLayerVisitorBindingIdAndName )

Definition at line 32 of file TestInputOutputLayerVisitor.cpp.

References IConnectableLayer::Accept(), and Network::AddOutputLayer().

 {
     const char* layerName = "OutputLayer";
     TestOutputLayerVisitor visitor(1, layerName);
     Network net;
 
     IConnectableLayer *const layer = net.AddOutputLayer(1, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [4/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckOutputLayerVisitorBindingIdAndNameNull )

Definition at line 42 of file TestInputOutputLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddOutputLayer(), and BOOST_AUTO_TEST_SUITE_END().

 {
     TestOutputLayerVisitor visitor(1);
     Network net;
 
     IConnectableLayer *const layer = net.AddOutputLayer(1);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [5/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeAddition )

Definition at line 226 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, QAsymmS8, QAsymmU8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     INetworkPtr network = INetwork::Create();
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* input1 = network->AddInputLayer(1);
     IConnectableLayer* addition = network->AddAdditionLayer();
     IConnectableLayer* output = network->AddOutputLayer(2);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(addition->GetInputSlot(0));
     input1->GetOutputSlot(0).Connect(addition->GetInputSlot(1));
     addition->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set TensorInfo
     const TensorShape shape{1U};
     TensorInfo info(shape, DataType::Float32);
     input0->GetOutputSlot(0).SetTensorInfo(info);
     input1->GetOutputSlot(0).SetTensorInfo(info);
     addition->GetOutputSlot(0).SetTensorInfo(info);
 
     const QuantizerOptions qAsymmU8Options(DataType::QAsymmU8);
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get(), qAsymmU8Options)->ExportNetwork();
     TestAdditionQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestAdditionQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestAdditionQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestAdditionQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [6/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckConvolution2dLayer )

Definition at line 268 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddConvolution2dLayer(), Float32, Convolution2dDescriptor::m_DataLayout, Convolution2dDescriptor::m_PadBottom, Convolution2dDescriptor::m_PadLeft, Convolution2dDescriptor::m_PadRight, Convolution2dDescriptor::m_PadTop, Convolution2dDescriptor::m_StrideX, Convolution2dDescriptor::m_StrideY, and NHWC.

Referenced by BOOST_AUTO_TEST_CASE(), and QuantizeData().

 {
     Convolution2dDescriptor descriptor;
     descriptor.m_PadLeft = 2;
     descriptor.m_PadRight = 3;
     descriptor.m_PadBottom = 1;
     descriptor.m_PadTop = 5;
     descriptor.m_StrideX = 2;
     descriptor.m_StrideY = 3;
     descriptor.m_DataLayout = DataLayout::NHWC;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     TestConvolution2dLayerVisitor visitor(descriptor, weights, EmptyOptional());
 
     Network net;
 
     IConnectableLayer* const layer = net.AddConvolution2dLayer(descriptor, weights, EmptyOptional());
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [7/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedConvolution2dLayer )

Definition at line 291 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddConvolution2dLayer(), Float32, Convolution2dDescriptor::m_DataLayout, Convolution2dDescriptor::m_PadBottom, Convolution2dDescriptor::m_PadLeft, Convolution2dDescriptor::m_PadRight, Convolution2dDescriptor::m_PadTop, Convolution2dDescriptor::m_StrideX, Convolution2dDescriptor::m_StrideY, and NHWC.

 {
     const char* layerName = "Convolution2dLayer";
     Convolution2dDescriptor descriptor;
     descriptor.m_PadLeft = 2;
     descriptor.m_PadRight = 3;
     descriptor.m_PadBottom = 1;
     descriptor.m_PadTop = 5;
     descriptor.m_StrideX = 2;
     descriptor.m_StrideY = 3;
     descriptor.m_DataLayout = DataLayout::NHWC;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     TestConvolution2dLayerVisitor visitor(descriptor, weights, EmptyOptional(), layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddConvolution2dLayer(descriptor, weights, EmptyOptional(), layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [8/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckConvolution2dLayerWithBiases )

Definition at line 315 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddConvolution2dLayer(), Float32, Convolution2dDescriptor::m_BiasEnabled, Convolution2dDescriptor::m_DataLayout, Convolution2dDescriptor::m_PadBottom, Convolution2dDescriptor::m_PadLeft, Convolution2dDescriptor::m_PadRight, Convolution2dDescriptor::m_PadTop, Convolution2dDescriptor::m_StrideX, Convolution2dDescriptor::m_StrideY, and NHWC.

 {
     Convolution2dDescriptor descriptor;
     descriptor.m_PadLeft = 2;
     descriptor.m_PadRight = 3;
     descriptor.m_PadBottom = 1;
     descriptor.m_PadTop = 5;
     descriptor.m_StrideX = 2;
     descriptor.m_StrideY = 3;
     descriptor.m_DataLayout = DataLayout::NHWC;
     descriptor.m_BiasEnabled = true;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
     ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
     Optional<ConstTensor> optionalBiases(biases);
 
     TestConvolution2dLayerVisitor visitor(descriptor, weights, optionalBiases);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddConvolution2dLayer(descriptor, weights, optionalBiases);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [9/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedConvolution2dLayerWithBiases )

Definition at line 344 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddConvolution2dLayer(), Float32, Convolution2dDescriptor::m_BiasEnabled, Convolution2dDescriptor::m_DataLayout, Convolution2dDescriptor::m_PadBottom, Convolution2dDescriptor::m_PadLeft, Convolution2dDescriptor::m_PadRight, Convolution2dDescriptor::m_PadTop, Convolution2dDescriptor::m_StrideX, Convolution2dDescriptor::m_StrideY, and NHWC.

 {
     const char* layerName = "Convolution2dLayer";
     Convolution2dDescriptor descriptor;
     descriptor.m_PadLeft = 2;
     descriptor.m_PadRight = 3;
     descriptor.m_PadBottom = 1;
     descriptor.m_PadTop = 5;
     descriptor.m_StrideX = 2;
     descriptor.m_StrideY = 3;
     descriptor.m_DataLayout = DataLayout::NHWC;
     descriptor.m_BiasEnabled = true;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
     ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
     Optional<ConstTensor> optionalBiases(biases);
 
     TestConvolution2dLayerVisitor visitor(descriptor, weights, optionalBiases, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddConvolution2dLayer(descriptor, weights, optionalBiases, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [10/90]

armnn::BOOST_AUTO_TEST_CASE ( InputOutputLayerDynamicQuant )

Definition at line 346 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithInputOutputLayers(), IInputSlot::GetConnection(), TensorInfo::GetDataType(), GetDataTypeName(), IConnectableLayer::GetInputSlot(), GetInputTensorInfo(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), and info.

 {
     INetworkPtr network = CreateNetworkWithInputOutputLayers();
 
     armnn::TensorInfo tensorInfo = GetInputTensorInfo(PolymorphicDowncast<const Network*>(network.get()));
 
     // Outliers -56 and 98
     std::vector<float> inputData({0, 0, 0, -56, 98, 0, 0, 0});
     armnn::ConstTensor inputTensor(tensorInfo, inputData.data());
 
     InputTensors inputTensors;
     inputTensors.push_back(std::make_pair(0, inputTensor));
 
     armnn::INetworkQuantizerPtr quantizer = armnn::INetworkQuantizer::Create(network.get());
 
     quantizer->Refine(inputTensors);
 
     // Outliers -77 and 65
     std::vector<float> inputData2({0, -77, 0, -56, 65, 0, 0, 0});
     armnn::ConstTensor inputTensor2(tensorInfo, inputData2.data());
     InputTensors inputTensors2;
     inputTensors2.push_back(std::make_pair(0, inputTensor2));
 
     quantizer->Refine(inputTensors2);
 
     INetworkPtr quantizedNetwork = quantizer->ExportNetwork();
     // Output Layer should be quantized for a min max of -77 and 98
     // according to QU8 Quantization Scheme
     std::unique_ptr<IQuantizationScheme> quantizationScheme = std::make_unique<QAsymmU8QuantizationScheme>();
     OffsetScalePair qParams = quantizationScheme->ComputeScheme(-77.0, 98.0);
 
     class TestOutputLayerVisitor : public LayerVisitorBase<VisitorNoThrowPolicy>
     {
     public:
         TestOutputLayerVisitor(const OffsetScalePair& offsetScalePair, const DataType& dataType) :
             m_OffsetScalePair(offsetScalePair), m_DataType(dataType) {}
 
         void VisitOutputLayer(const IConnectableLayer* layer,
                                       LayerBindingId id,
                                       const char* name = nullptr) override
         {
             IgnoreUnused(id, name);
             const TensorInfo& info = layer->GetInputSlot(0).GetConnection()->GetTensorInfo();
             BOOST_CHECK_MESSAGE(info.GetDataType() == m_DataType,
                                 std::string(armnn::GetDataTypeName(info.GetDataType()))
                                         .append(" == ").append(armnn::GetDataTypeName(m_DataType)));
             // int_32t
             BOOST_CHECK(info.GetQuantizationOffset() == m_OffsetScalePair.second);
             // float
             BOOST_TEST(info.GetQuantizationScale() == m_OffsetScalePair.first, boost::test_tools::tolerance(0.001));
         }
 
     private:
         const OffsetScalePair m_OffsetScalePair;
         const DataType m_DataType;
     };
 
     TestOutputLayerVisitor visitor(qParams, quantizationScheme->GetDataType());
     quantizedNetwork->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [11/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckDepthwiseConvolution2dLayer )

Definition at line 374 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddDepthwiseConvolution2dLayer(), Float32, DepthwiseConvolution2dDescriptor::m_DataLayout, DepthwiseConvolution2dDescriptor::m_PadBottom, DepthwiseConvolution2dDescriptor::m_PadLeft, DepthwiseConvolution2dDescriptor::m_PadRight, DepthwiseConvolution2dDescriptor::m_PadTop, DepthwiseConvolution2dDescriptor::m_StrideX, DepthwiseConvolution2dDescriptor::m_StrideY, and NHWC.

 {
     DepthwiseConvolution2dDescriptor descriptor;
     descriptor.m_PadLeft = 2;
     descriptor.m_PadRight = 3;
     descriptor.m_PadBottom = 1;
     descriptor.m_PadTop = 5;
     descriptor.m_StrideX = 2;
     descriptor.m_StrideY = 3;
     descriptor.m_DataLayout = DataLayout::NHWC;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     TestDepthwiseConvolution2dLayerVisitor visitor(descriptor, weights, EmptyOptional());
 
     Network net;
 
     IConnectableLayer* const layer = net.AddDepthwiseConvolution2dLayer(descriptor, weights, EmptyOptional());
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [12/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedDepthwiseConvolution2dLayer )

Definition at line 397 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddDepthwiseConvolution2dLayer(), Float32, DepthwiseConvolution2dDescriptor::m_DataLayout, DepthwiseConvolution2dDescriptor::m_PadBottom, DepthwiseConvolution2dDescriptor::m_PadLeft, DepthwiseConvolution2dDescriptor::m_PadRight, DepthwiseConvolution2dDescriptor::m_PadTop, DepthwiseConvolution2dDescriptor::m_StrideX, DepthwiseConvolution2dDescriptor::m_StrideY, and NHWC.

 {
     const char* layerName = "DepthwiseConvolution2dLayer";
     DepthwiseConvolution2dDescriptor descriptor;
     descriptor.m_PadLeft = 2;
     descriptor.m_PadRight = 3;
     descriptor.m_PadBottom = 1;
     descriptor.m_PadTop = 5;
     descriptor.m_StrideX = 2;
     descriptor.m_StrideY = 3;
     descriptor.m_DataLayout = DataLayout::NHWC;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     TestDepthwiseConvolution2dLayerVisitor visitor(descriptor, weights, EmptyOptional(), layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddDepthwiseConvolution2dLayer(descriptor,
                                                                         weights,
                                                                         EmptyOptional(),
                                                                         layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [13/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeAbsActivation )

Definition at line 407 of file QuantizerTest.cpp.

References Abs, INetworkQuantizer::Create(), CreateNetworkWithActivationLayer(), ActivationDescriptor::m_A, ActivationDescriptor::m_B, ActivationDescriptor::m_Function, QAsymmS8, QAsymmU8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     ActivationDescriptor descriptor;
     descriptor.m_Function = ActivationFunction::Abs;
     descriptor.m_A        = 3.5f;
     descriptor.m_B        = -10.0f;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithActivationLayer(descriptor, shape);
 
     const QuantizerOptions qAsymmU8Options(DataType::QAsymmU8);
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get(), qAsymmU8Options)->ExportNetwork();
     TestActivationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestActivationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestActivationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestActivationQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [14/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckDepthwiseConvolution2dLayerWithBiases )

Definition at line 424 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddDepthwiseConvolution2dLayer(), Float32, DepthwiseConvolution2dDescriptor::m_BiasEnabled, DepthwiseConvolution2dDescriptor::m_DataLayout, DepthwiseConvolution2dDescriptor::m_PadBottom, DepthwiseConvolution2dDescriptor::m_PadLeft, DepthwiseConvolution2dDescriptor::m_PadRight, DepthwiseConvolution2dDescriptor::m_PadTop, DepthwiseConvolution2dDescriptor::m_StrideX, DepthwiseConvolution2dDescriptor::m_StrideY, and NHWC.

 {
     DepthwiseConvolution2dDescriptor descriptor;
     descriptor.m_PadLeft = 2;
     descriptor.m_PadRight = 3;
     descriptor.m_PadBottom = 1;
     descriptor.m_PadTop = 5;
     descriptor.m_StrideX = 2;
     descriptor.m_StrideY = 3;
     descriptor.m_DataLayout = DataLayout::NHWC;
     descriptor.m_BiasEnabled = true;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
     ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
     Optional<ConstTensor> optionalBiases(biases);
 
     TestDepthwiseConvolution2dLayerVisitor visitor(descriptor, weights, optionalBiases);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddDepthwiseConvolution2dLayer(descriptor, weights, optionalBiases);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [15/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeLinearActivation )

Definition at line 438 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithActivationLayer(), Linear, ActivationDescriptor::m_A, ActivationDescriptor::m_B, ActivationDescriptor::m_Function, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     ActivationDescriptor descriptor;
     descriptor.m_Function = ActivationFunction::Linear;
     descriptor.m_A        = 3.5f;
     descriptor.m_B        = -10.0f;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithActivationLayer(descriptor, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestActivationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestActivationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestActivationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestActivationQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [16/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedDepthwiseConvolution2dLayerWithBiases )

Definition at line 453 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddDepthwiseConvolution2dLayer(), Float32, DepthwiseConvolution2dDescriptor::m_BiasEnabled, DepthwiseConvolution2dDescriptor::m_DataLayout, DepthwiseConvolution2dDescriptor::m_PadBottom, DepthwiseConvolution2dDescriptor::m_PadLeft, DepthwiseConvolution2dDescriptor::m_PadRight, DepthwiseConvolution2dDescriptor::m_PadTop, DepthwiseConvolution2dDescriptor::m_StrideX, DepthwiseConvolution2dDescriptor::m_StrideY, and NHWC.

 {
     const char* layerName = "DepthwiseConvolution2dLayer";
     DepthwiseConvolution2dDescriptor descriptor;
     descriptor.m_PadLeft = 2;
     descriptor.m_PadRight = 3;
     descriptor.m_PadBottom = 1;
     descriptor.m_PadTop = 5;
     descriptor.m_StrideX = 2;
     descriptor.m_StrideY = 3;
     descriptor.m_DataLayout = DataLayout::NHWC;
     descriptor.m_BiasEnabled = true;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
     ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
     Optional<ConstTensor> optionalBiases(biases);
 
     TestDepthwiseConvolution2dLayerVisitor visitor(descriptor, weights, optionalBiases, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddDepthwiseConvolution2dLayer(descriptor, weights, optionalBiases, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [17/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeReLuActivation )

Definition at line 468 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithActivationLayer(), ActivationDescriptor::m_A, ActivationDescriptor::m_B, ActivationDescriptor::m_Function, QAsymmS8, QSymmS16, QSymmS8, ReLu, and VisitLayersTopologically().

 {
     ActivationDescriptor descriptor;
     descriptor.m_Function = ActivationFunction::ReLu;
     descriptor.m_A        = 3.5f;
     descriptor.m_B        = -10.0f;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithActivationLayer(descriptor, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestActivationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestActivationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestActivationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestActivationQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [18/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckFullyConnectedLayer )

Definition at line 483 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddFullyConnectedLayer(), Float32, and FullyConnectedDescriptor::m_TransposeWeightMatrix.

 {
     FullyConnectedDescriptor descriptor;
     descriptor.m_TransposeWeightMatrix = true;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     TestFullyConnectedLayerVistor visitor(descriptor, weights, EmptyOptional());
 
     Network net;
 
     IConnectableLayer* const layer = net.AddFullyConnectedLayer(descriptor, weights, EmptyOptional());
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [19/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeSoftReLuActivation )

Definition at line 498 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithActivationLayer(), ActivationDescriptor::m_A, ActivationDescriptor::m_B, ActivationDescriptor::m_Function, QAsymmS8, QSymmS16, QSymmS8, SoftReLu, and VisitLayersTopologically().

 {
     ActivationDescriptor descriptor;
     descriptor.m_Function = ActivationFunction::SoftReLu;
     descriptor.m_A        = 3.5f;
     descriptor.m_B        = -10.0f;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithActivationLayer(descriptor, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestActivationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestActivationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestActivationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestActivationQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [20/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedFullyConnectedLayer )

Definition at line 500 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddFullyConnectedLayer(), Float32, and FullyConnectedDescriptor::m_TransposeWeightMatrix.

 {
     const char* layerName = "FullyConnectedLayer";
     FullyConnectedDescriptor descriptor;
     descriptor.m_TransposeWeightMatrix = true;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     TestFullyConnectedLayerVistor visitor(descriptor, weights, EmptyOptional(), layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddFullyConnectedLayer(descriptor, weights, EmptyOptional(), layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [21/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckFullyConnectedLayerWithBiases )

Definition at line 518 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddFullyConnectedLayer(), Float32, FullyConnectedDescriptor::m_BiasEnabled, and FullyConnectedDescriptor::m_TransposeWeightMatrix.

 {
     FullyConnectedDescriptor descriptor;
     descriptor.m_TransposeWeightMatrix = true;
     descriptor.m_BiasEnabled = true;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
     ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
     Optional<ConstTensor> optionalBiases(biases);
 
     TestFullyConnectedLayerVistor visitor(descriptor, weights, optionalBiases);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddFullyConnectedLayer(descriptor, weights, optionalBiases);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [22/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeBoundedReluActivation )

Definition at line 528 of file QuantizerTest.cpp.

References BoundedReLu, INetworkQuantizer::Create(), CreateNetworkWithActivationLayer(), g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, ActivationDescriptor::m_A, ActivationDescriptor::m_B, ActivationDescriptor::m_Function, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestBoundedReluActivationQuantization : public TestQuantization
     {
     public:
         TestBoundedReluActivationQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestBoundedReluActivationQuantization(const QuantizerOptions& options,
                                               const TensorShape& inputShape,
                                               const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitActivationLayer(const IConnectableLayer* layer,
                                   const ActivationDescriptor& descriptor,
                                   const char* name = nullptr) override
         {
             IgnoreUnused(descriptor, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             // Based off default static range [0.0f, 3.5f]
             TestQuantizationParams(info, {3.5f / g_AsymmU8QuantizationBase, 0},
                                          {3.5f / g_AsymmS8QuantizationBase, -128},
                                          {3.5f / g_SymmS8QuantizationBase,  0},
                                          {3.5f / g_SymmS16QuantizationBase, 0});
         }
     };
 
     ActivationDescriptor descriptor;
     descriptor.m_Function = ActivationFunction::BoundedReLu;
     descriptor.m_A        = 3.5f;
     descriptor.m_B        = -10.0f;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithActivationLayer(descriptor, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestBoundedReluActivationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestBoundedReluActivationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestBoundedReluActivationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestBoundedReluActivationQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [23/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedFullyConnectedLayerWithBiases )

Definition at line 541 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddFullyConnectedLayer(), Float32, FullyConnectedDescriptor::m_BiasEnabled, and FullyConnectedDescriptor::m_TransposeWeightMatrix.

 {
     const char* layerName = "FullyConnectedLayer";
     FullyConnectedDescriptor descriptor;
     descriptor.m_TransposeWeightMatrix = true;
     descriptor.m_BiasEnabled = true;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
     ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
     Optional<ConstTensor> optionalBiases(biases);
 
     TestFullyConnectedLayerVistor visitor(descriptor, weights, optionalBiases, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddFullyConnectedLayer(descriptor, weights, optionalBiases, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [24/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckBatchNormalizationLayer )

Definition at line 565 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddBatchNormalizationLayer(), Float32, BatchNormalizationDescriptor::m_DataLayout, BatchNormalizationDescriptor::m_Eps, and NHWC.

 {
     BatchNormalizationDescriptor descriptor;
     descriptor.m_Eps = 0.0002f;
     descriptor.m_DataLayout = DataLayout::NHWC;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor mean(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     std::vector<float> varianceData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> varianceDimensions = {1, 1, 3, 3};
     ConstTensor variance(TensorInfo(4, varianceDimensions.data(), DataType::Float32), varianceData);
 
     std::vector<float> betaData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> betaDimensions = {1, 1, 3, 3};
     ConstTensor beta(TensorInfo(4, betaDimensions.data(), DataType::Float32), betaData);
 
     std::vector<float> gammaData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> gammaDimensions = {1, 1, 3, 3};
     ConstTensor gamma(TensorInfo(4, gammaDimensions.data(), DataType::Float32), gammaData);
 
     TestBatchNormalizationLayerVisitor visitor(descriptor, mean, variance, beta, gamma);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddBatchNormalizationLayer(descriptor, mean, variance, beta, gamma);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [25/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeTanHActivation )

Definition at line 584 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithActivationLayer(), g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, ActivationDescriptor::m_A, ActivationDescriptor::m_B, ActivationDescriptor::m_Function, QAsymmS8, QSymmS16, QSymmS8, TanH, and VisitLayersTopologically().

 {
     class TestTanHActivationQuantization : public TestQuantization
     {
     public:
         TestTanHActivationQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestTanHActivationQuantization(const QuantizerOptions& options,
                                        const TensorShape& inputShape,
                                        const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitActivationLayer(const IConnectableLayer* layer,
                                   const ActivationDescriptor& descriptor,
                                   const char* name = nullptr) override
         {
             IgnoreUnused(descriptor, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             // Based off default static range [-1.0f, 1.0f]
             TestQuantizationParams(
                 info, {2.0f / g_AsymmU8QuantizationBase, 128},
                       {2.0f / g_AsymmS8QuantizationBase,   0},
                       {1.0f / g_SymmS8QuantizationBase ,   0},
                       {1.0f / g_SymmS16QuantizationBase,   0});
         }
     };
 
     ActivationDescriptor descriptor;
     descriptor.m_Function = ActivationFunction::TanH;
     descriptor.m_A        = 3.5f;
     descriptor.m_B        = -10.0f;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithActivationLayer(descriptor, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestTanHActivationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestTanHActivationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestTanHActivationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestTanHActivationQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [26/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedBatchNormalizationLayer )

Definition at line 595 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddBatchNormalizationLayer(), Float32, BatchNormalizationDescriptor::m_DataLayout, BatchNormalizationDescriptor::m_Eps, and NHWC.

 {
     const char* layerName = "BatchNormalizationLayer";
     BatchNormalizationDescriptor descriptor;
     descriptor.m_Eps = 0.0002f;
     descriptor.m_DataLayout = DataLayout::NHWC;
 
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor mean(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     std::vector<float> varianceData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> varianceDimensions = {1, 1, 3, 3};
     ConstTensor variance(TensorInfo(4, varianceDimensions.data(), DataType::Float32), varianceData);
 
     std::vector<float> betaData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> betaDimensions = {1, 1, 3, 3};
     ConstTensor beta(TensorInfo(4, betaDimensions.data(), DataType::Float32), betaData);
 
     std::vector<float> gammaData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> gammaDimensions = {1, 1, 3, 3};
     ConstTensor gamma(TensorInfo(4, gammaDimensions.data(), DataType::Float32), gammaData);
 
     TestBatchNormalizationLayerVisitor visitor(descriptor, mean, variance, beta, gamma, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddBatchNormalizationLayer(
             descriptor, mean, variance, beta, gamma, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [27/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckConstLayer )

Definition at line 627 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddConstantLayer(), and Float32.

 {
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor input(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     TestConstantLayerVisitor visitor(input);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddConstantLayer(input);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [28/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedConstLayer )

Definition at line 641 of file ConstTensorLayerVisitor.cpp.

References IConnectableLayer::Accept(), Network::AddConstantLayer(), and Float32.

 {
     const char* layerName = "ConstantLayer";
     std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> dimensions = {1, 1, 3, 3};
     ConstTensor input(TensorInfo(4, dimensions.data(), DataType::Float32), data);
 
     TestConstantLayerVisitor visitor(input, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddConstantLayer(input, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [29/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckLstmLayerBasic )

Definition at line 656 of file ConstTensorLayerVisitor.cpp.

 {
     LstmDescriptor descriptor;
     descriptor.m_ActivationFunc = 3;
     descriptor.m_ClippingThresProj = 0.5f;
     descriptor.m_ClippingThresCell = 0.3f;
     descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
 
     std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
 
     std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
 
     std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
 
     std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
 
     std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
 
     std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
 
     std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
 
     std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
 
     std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
 
     LstmInputParams params;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     TestLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [30/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeLeakyReLuActivation )

Definition at line 679 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithActivationLayer(), LeakyReLu, ActivationDescriptor::m_A, ActivationDescriptor::m_B, ActivationDescriptor::m_Function, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     ActivationDescriptor descriptor;
     descriptor.m_Function = ActivationFunction::LeakyReLu;
     descriptor.m_A        = 3.5f;
     descriptor.m_B        = -10.0f;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithActivationLayer(descriptor, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestLeakyReLuActivationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestLeakyReLuActivationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestLeakyReLuActivationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestLeakyReLuActivationQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [31/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeELuActivation )

Definition at line 710 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithActivationLayer(), Elu, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, ActivationDescriptor::m_Function, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestEluActivationQuantization : public TestQuantization
     {
     public:
         TestEluActivationQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestEluActivationQuantization(const QuantizerOptions& options,
                                        const TensorShape& inputShape,
                                        const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitActivationLayer(const IConnectableLayer* layer,
                                   const ActivationDescriptor& descriptor,
                                   const char* name = nullptr) override
         {
             IgnoreUnused(descriptor, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             // Based off default static range [-15.0f, 15.0f]
             TestQuantizationParams(
                 info, {30.0f / g_AsymmU8QuantizationBase, 128},
                       {30.0f / g_AsymmS8QuantizationBase, 0},
                       {15.0f / g_SymmS8QuantizationBase,  0},
                       {15.0f / g_SymmS16QuantizationBase, 0});
         }
     };
 
     ActivationDescriptor descriptor;
     descriptor.m_Function = ActivationFunction::Elu;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithActivationLayer(descriptor, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestEluActivationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestEluActivationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestEluActivationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestEluActivationQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [32/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedLstmLayerBasic )

Definition at line 728 of file ConstTensorLayerVisitor.cpp.

 {
     const char* layerName = "LstmLayer";
     LstmDescriptor descriptor;
     descriptor.m_ActivationFunc = 3;
     descriptor.m_ClippingThresProj = 0.5f;
     descriptor.m_ClippingThresCell = 0.3f;
     descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
 
     std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
 
     std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
 
     std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
 
     std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
 
     std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
 
     std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
 
     std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
 
     std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
 
     std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
 
     LstmInputParams params;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     TestLstmLayerVisitor visitor(descriptor, params, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [33/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeHardSwishActivation )

Definition at line 764 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithActivationLayer(), g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), HardSwish, IgnoreUnused(), info, ActivationDescriptor::m_Function, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestHardSwishActivationQuantization : public TestQuantization
     {
     public:
         TestHardSwishActivationQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
             : TestQuantization(inputShape, outputShape) {}
 
         TestHardSwishActivationQuantization(const QuantizerOptions& options,
                                       const TensorShape& inputShape,
                                       const TensorShape& outputShape)
             : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitActivationLayer(const IConnectableLayer* layer,
                                   const ActivationDescriptor& descriptor,
                                   const char* name = nullptr) override
         {
             IgnoreUnused(descriptor, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             // Based off default static range [-15.0f, 15.0f]
             TestQuantizationParams(
                 info, {30.0f / g_AsymmU8QuantizationBase, 128},
                 {30.0f / g_AsymmS8QuantizationBase, 0},
                 {15.0f / g_SymmS8QuantizationBase,  0},
                 {15.0f / g_SymmS16QuantizationBase, 0});
         }
     };
 
     ActivationDescriptor descriptor;
     descriptor.m_Function = ActivationFunction::HardSwish;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithActivationLayer(descriptor, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestHardSwishActivationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestHardSwishActivationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestHardSwishActivationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestHardSwishActivationQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [34/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckLstmLayerCifgDisabled )

Definition at line 801 of file ConstTensorLayerVisitor.cpp.

 {
     LstmDescriptor descriptor;
     descriptor.m_ActivationFunc = 3;
     descriptor.m_ClippingThresProj = 0.5f;
     descriptor.m_ClippingThresCell = 0.3f;
     descriptor.m_CifgEnabled = false; // if this is true then we DON'T need to set the OptCifgParams
 
     std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
 
     std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
 
     std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
 
     std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
 
     std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
 
     std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
 
     std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
 
     std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
 
     std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
 
     std::vector<float> inputToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToInputWeights(
             TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::Float32), inputToInputWeightsData);
 
     std::vector<float> recurrentToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToInputWeights(TensorInfo(
             4, recurrentToInputWeightsDimensions.data(), DataType::Float32), recurrentToInputWeightsData);
 
     std::vector<float> inputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor inputGateBias(
             TensorInfo(4, inputGateBiasDimensions.data(), DataType::Float32), inputGateBiasData);
 
         LstmInputParams params;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     params.m_InputToInputWeights = &inputToInputWeights;
     params.m_RecurrentToInputWeights = &recurrentToInputWeights;
     params.m_InputGateBias = &inputGateBias;
 
     TestLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [35/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeBatchNorm )

Definition at line 820 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, BaseTensor< MemoryType >::GetInfo(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestBatchNormalizationQuantization : public TestQuantization
     {
     public:
         TestBatchNormalizationQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestBatchNormalizationQuantization(const QuantizerOptions& options,
                                            const TensorShape& inputShape,
                                            const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitBatchNormalizationLayer(const IConnectableLayer* layer,
                                           const BatchNormalizationDescriptor& desc,
                                           const ConstTensor& mean,
                                           const ConstTensor& variance,
                                           const ConstTensor& beta,
                                           const ConstTensor& gamma,
                                           const char* name = nullptr) override
         {
             IgnoreUnused(desc, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             // Based off default static range [-15.0f, 15.0f]
             TestQuantizationParams(
                 info, {30.0f / g_AsymmU8QuantizationBase, 128},
                       {30.0f / g_AsymmS8QuantizationBase,  0},
                       {15.0f / g_SymmS8QuantizationBase,  0},
                       {15.0f / g_SymmS16QuantizationBase, 0});
 
             // Test constants
             TestConstantQuantizationParams(mean.GetInfo(), {3.0f / g_AsymmU8QuantizationBase, 85});
             TestConstantQuantizationParams(variance.GetInfo(), {3.0f / g_AsymmU8QuantizationBase, 85});
             TestConstantQuantizationParams(beta.GetInfo(), {3.0f / g_AsymmU8QuantizationBase, 85});
             TestConstantQuantizationParams(gamma.GetInfo(), {3.0f / g_AsymmU8QuantizationBase, 85});
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape shape{3U};
     TensorInfo info(shape, DataType::Float32);
 
     std::vector<float> meanData{-1.0f, 1.5f, 2.0f};
     std::vector<float> varData{-1.0f, 1.5f, 2.0f};
     std::vector<float> betaData{-1.0f, 1.5f, 2.0f};
     std::vector<float> gammaData{-1.0f, 1.5f, 2.0f};
 
     ConstTensor mean(info, meanData);
     ConstTensor var(info, varData);
     ConstTensor beta(info, betaData);
     ConstTensor gamma(info, gammaData);
 
     BatchNormalizationDescriptor desc;
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* batchNorm = network->AddBatchNormalizationLayer(desc, mean, var, beta, gamma);
     IConnectableLayer* output = network->AddOutputLayer(1);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(batchNorm->GetInputSlot(0));
     batchNorm->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set TensorInfo
     input0->GetOutputSlot(0).SetTensorInfo(info);
     batchNorm->GetOutputSlot(0).SetTensorInfo(info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestBatchNormalizationQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestBatchNormalizationQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestBatchNormalizationQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions QQsymm16Options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), QQsymm16Options)->ExportNetwork();
     TestBatchNormalizationQuantization validatorQSymmS16(QQsymm16Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [36/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedLstmLayerCifgDisabled )

Definition at line 892 of file ConstTensorLayerVisitor.cpp.

 {
     const char* layerName = "LstmLayer";
     LstmDescriptor descriptor;
     descriptor.m_ActivationFunc = 3;
     descriptor.m_ClippingThresProj = 0.5f;
     descriptor.m_ClippingThresCell = 0.3f;
     descriptor.m_CifgEnabled = false; // if this is true then we DON'T need to set the OptCifgParams
 
     std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
 
     std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
 
     std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
 
     std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
 
     std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
 
     std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
 
     std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
 
     std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
 
     std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
 
     std::vector<float> inputToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToInputWeights(
             TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::Float32), inputToInputWeightsData);
 
     std::vector<float> recurrentToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToInputWeights(TensorInfo(
             4, recurrentToInputWeightsDimensions.data(), DataType::Float32), recurrentToInputWeightsData);
 
     std::vector<float> inputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor inputGateBias(
             TensorInfo(4, inputGateBiasDimensions.data(), DataType::Float32), inputGateBiasData);
 
     LstmInputParams params;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     params.m_InputToInputWeights = &inputToInputWeights;
     params.m_RecurrentToInputWeights = &recurrentToInputWeights;
     params.m_InputGateBias = &inputGateBias;
 
     TestLstmLayerVisitor visitor(descriptor, params, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [37/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeDepthToSpace )

Definition at line 909 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, NHWC, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestDepthToSpaceQuantization : public TestQuantization
     {
     public:
         TestDepthToSpaceQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
             : TestQuantization(inputShape, outputShape) {}
 
         TestDepthToSpaceQuantization(const QuantizerOptions& options,
                                      const TensorShape& inputShape,
                                      const TensorShape& outputShape)
             : TestQuantization(options, inputShape, outputShape) {}
 
         virtual void VisitDepthToSpaceLayer(const IConnectableLayer* layer,
                                             const DepthToSpaceDescriptor& desc,
                                             const char* name = nullptr)
         {
             IgnoreUnused(desc, name);
             const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
 
             const OffsetScalePair qAsymmU8Params{ 30.0f / g_AsymmU8QuantizationBase, 128 };
             const OffsetScalePair qAsymmS8Params{ 30.0f / g_AsymmS8QuantizationBase, 0 };
             const OffsetScalePair qSymmS8Params { 15.0f / g_SymmS8QuantizationBase,  0 };
             const OffsetScalePair qSymmS16Params{ 15.0f / g_SymmS16QuantizationBase, 0 };
 
             TestQuantizationParams(info, qAsymmU8Params, qAsymmS8Params, qSymmS8Params, qSymmS16Params);
         }
     };
 
     const TensorShape inputShape { 1, 2, 2, 4 };
     const TensorShape outputShape{ 1, 4, 4, 1 };
 
     const TensorInfo inputInfo (inputShape,  DataType::Float32);
     const TensorInfo outputInfo(outputShape, DataType::Float32);
 
     INetworkPtr network = INetwork::Create();
     const DepthToSpaceDescriptor descriptor(2, armnn::DataLayout::NHWC);
 
     IConnectableLayer* inputLayer        = network->AddInputLayer(0);
     IConnectableLayer* depthToSpaceLayer = network->AddDepthToSpaceLayer(descriptor);
     IConnectableLayer* outputLayer       = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(depthToSpaceLayer->GetInputSlot(0));
     depthToSpaceLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
     depthToSpaceLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     // test QAsymmU8 quantization
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestDepthToSpaceQuantization validatorQAsymmU8(inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     // test QAsymmS8 quantization
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestDepthToSpaceQuantization validatorQAsymmS8(qAsymmS8Options, inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     // test QSymmS8 quantization
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestDepthToSpaceQuantization validatorQSymmS8(qSymmS8Options, inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     // test QSymmS16 quantization
     const QuantizerOptions Qsymm16Options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), Qsymm16Options)->ExportNetwork();
     TestDepthToSpaceQuantization validatorQSymmS16(Qsymm16Options, inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [38/90]

armnn::BOOST_AUTO_TEST_CASE ( OverrideInputRangeEmptyNetwork )

Definition at line 981 of file QuantizerTest.cpp.

References Network::GetGraph(), Graph::GetInputLayers(), RangeTracker::IsEmpty(), and VisitLayers().

 {
     RangeTracker ranges;
     RangeTracker::MinMaxRange minMaxRange(-12.3f, 45.6f); // Range to use for the override
 
     Network network; // Empty network
     auto inputLayers = network.GetGraph().GetInputLayers(); // Empty list of input layers
 
     OverrideInputRangeVisitor overrideInputRangeVisitor(ranges, 0, minMaxRange);
     VisitLayers(inputLayers, overrideInputRangeVisitor);
 
     BOOST_CHECK(ranges.IsEmpty()); // Check that the map of ranges remained untouched
 }

◆ BOOST_AUTO_TEST_CASE() [39/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckLstmLayerPeephole )

Definition at line 985 of file ConstTensorLayerVisitor.cpp.

 {
     LstmDescriptor descriptor;
     descriptor.m_ActivationFunc = 3;
     descriptor.m_ClippingThresProj = 0.5f;
     descriptor.m_ClippingThresCell = 0.3f;
     descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
     descriptor.m_PeepholeEnabled = true;
 
     std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
 
     std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
 
     std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
 
     std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
 
     std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
 
     std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
 
     std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
 
     std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
 
     std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
 
     std::vector<float> cellToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToForgetWeights(
             TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::Float32), cellToForgetWeightsData);
 
     std::vector<float> cellToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToOutputWeights(
             TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::Float32), cellToOutputWeightsData);
 
             LstmInputParams params;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     params.m_CellToForgetWeights = &cellToForgetWeights;
     params.m_CellToOutputWeights = &cellToOutputWeights;
 
     TestLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [40/90]

armnn::BOOST_AUTO_TEST_CASE ( OverrideInputRangeNoInputLayers )

Definition at line 995 of file QuantizerTest.cpp.

References Network::AddAdditionLayer(), Network::GetGraph(), Graph::GetInputLayers(), RangeTracker::IsEmpty(), and VisitLayers().

 {
     RangeTracker ranges;
     MinMaxRange minMaxRange(-12.3f, 45.6f); // Range to use for the override
 
     Network network;
     network.AddAdditionLayer(); // Network with no input layers
     auto inputLayers = network.GetGraph().GetInputLayers(); // Empty list of input layers
 
     OverrideInputRangeVisitor overrideInputRangeVisitor(ranges, 0, minMaxRange);
     VisitLayers(inputLayers, overrideInputRangeVisitor);
 
     BOOST_CHECK(ranges.IsEmpty()); // Check that the map of ranges remained untouched
 }

◆ BOOST_AUTO_TEST_CASE() [41/90]

armnn::BOOST_AUTO_TEST_CASE ( OverrideInputRangeInputLayers )

Definition at line 1010 of file QuantizerTest.cpp.

References Network::AddAdditionLayer(), Network::AddInputLayer(), Network::AddOutputLayer(), IOutputSlot::Connect(), Float32, Network::GetGraph(), IConnectableLayer::GetGuid(), Graph::GetInputLayers(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), RangeTracker::GetRange(), RangeTracker::HasRanges(), info, RangeTracker::IsEmpty(), IOutputSlot::SetTensorInfo(), and VisitLayers().

 {
     RangeTracker ranges;
     MinMaxRange minMaxRange(-12.3f, 45.6f); // Range to use for the override
 
     Network network;
 
     // Adding the layers
     IConnectableLayer* input0 = network.AddInputLayer(0);
     IConnectableLayer* input1 = network.AddInputLayer(1);
     IConnectableLayer* addition = network.AddAdditionLayer();
     IConnectableLayer* output = network.AddOutputLayer(2);
 
     // Connecting the layer
     input0->GetOutputSlot(0).Connect(addition->GetInputSlot(0));
     input1->GetOutputSlot(0).Connect(addition->GetInputSlot(1));
     addition->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Setting the TensorInfos
     TensorShape shape{1U};
     TensorInfo info(shape, DataType::Float32);
     input0->GetOutputSlot(0).SetTensorInfo(info);
     input1->GetOutputSlot(0).SetTensorInfo(info);
     addition->GetOutputSlot(0).SetTensorInfo(info);
 
     auto inputLayers = network.GetGraph().GetInputLayers(); // List of input layers
 
     // Trying to override the input range for the input layer with binding id 3 (does not exist in the network)
     OverrideInputRangeVisitor overrideInputRangeVisitorLayer3(ranges, 3, minMaxRange);
     VisitLayers(inputLayers, overrideInputRangeVisitorLayer3);
 
     // Check that the map of ranges remained untouched
     BOOST_CHECK(ranges.IsEmpty());
 
     // Override the input range for the input layer with binding id 1
     OverrideInputRangeVisitor overrideInputRangeVisitorLayer1(ranges, 1, minMaxRange);
     VisitLayers(inputLayers, overrideInputRangeVisitorLayer1);
 
     // Check that the map of ranges has been populated
     BOOST_CHECK(!ranges.IsEmpty());
 
     // Check that an entry for the input layer with binding id 0 does not exist
     BOOST_CHECK(!ranges.HasRanges(input0->GetGuid()));
 
     // Check that an entry for the input layer with binding id 1 exists
     BOOST_CHECK(ranges.HasRanges(input1->GetGuid()));
 
     // Check the the overridden values are what we intended to set
     BOOST_CHECK(ranges.GetRange(input1->GetGuid(), 0) == minMaxRange);
 }

◆ BOOST_AUTO_TEST_CASE() [42/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckLstmLayerPeepholeCifgDisabled )

Definition at line 1071 of file ConstTensorLayerVisitor.cpp.

 {
     LstmDescriptor descriptor;
     descriptor.m_ActivationFunc = 3;
     descriptor.m_ClippingThresProj = 0.5f;
     descriptor.m_ClippingThresCell = 0.3f;
     descriptor.m_CifgEnabled = false;
     descriptor.m_PeepholeEnabled = true;
 
     std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
 
     std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
 
     std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
 
     std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
 
     std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
 
     std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
 
     std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
 
     std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
 
     std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
 
     std::vector<float> cellToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToInputWeights(
             TensorInfo(4, cellToInputWeightsDimensions.data(), DataType::Float32), cellToInputWeightsData);
 
     std::vector<float> cellToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToForgetWeights(
             TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::Float32), cellToForgetWeightsData);
 
     std::vector<float> cellToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToOutputWeights(
             TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::Float32), cellToOutputWeightsData);
 
     std::vector<float> inputToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToInputWeights(
             TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::Float32), inputToInputWeightsData);
 
     std::vector<float> recurrentToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToInputWeights(TensorInfo(
             4, recurrentToInputWeightsDimensions.data(), DataType::Float32), recurrentToInputWeightsData);
 
     std::vector<float> inputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor inputGateBias(
             TensorInfo(4, inputGateBiasDimensions.data(), DataType::Float32), inputGateBiasData);
 
     LstmInputParams params;
     // Basic params
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     // Peephole params
     params.m_CellToInputWeights  = &cellToInputWeights;
     params.m_CellToForgetWeights = &cellToForgetWeights;
     params.m_CellToOutputWeights = &cellToOutputWeights;
 
     // Cifg params
     params.m_InputToInputWeights = &inputToInputWeights;
     params.m_RecurrentToInputWeights = &recurrentToInputWeights;
     params.m_InputGateBias = &inputGateBias;
 
     TestLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [43/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeFill )

Definition at line 1146 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, FillDescriptor::m_Value, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestFillQuantization : public TestQuantization
     {
     public:
         TestFillQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestFillQuantization(const QuantizerOptions& options,
                              const TensorShape& inputShape,
                              const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         virtual void VisitFillLayer(const IConnectableLayer* layer,
                                     const FillDescriptor& desc,
                                     const char* name = nullptr)
         {
             IgnoreUnused(desc, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             const OffsetScalePair qAsymmU8Params{ 30.0f / g_AsymmU8QuantizationBase, 128 };
             const OffsetScalePair qAsymmS8Params { 30.0f / g_AsymmS8QuantizationBase,  0};
             const OffsetScalePair qSymmS8Params { 15.0f / g_SymmS8QuantizationBase,  0};
             const OffsetScalePair qSymmS16Params{ 15.0f / g_SymmS16QuantizationBase, 0 };
 
             TestQuantizationParams(info, qAsymmU8Params, qAsymmS8Params, qSymmS8Params, qSymmS16Params);
         }
     };
 
     const TensorShape tensorShape{ 1U };
     const TensorInfo tensorInfo(tensorShape, DataType::Float32);
 
     INetworkPtr network = INetwork::Create();
 
     FillDescriptor descriptor;
     descriptor.m_Value = 1;
 
     IConnectableLayer* inputLayer = network->AddInputLayer(0);
     IConnectableLayer* fillLayer = network->AddFillLayer(descriptor);
     IConnectableLayer* outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(fillLayer->GetInputSlot(0));
     fillLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     fillLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     // test QAsymmU8 quantization
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestFillQuantization validatorQAsymmU8(tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     // test QAsymmS8 quantization
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestFillQuantization validatorQAsymmS8(qAsymmS8Options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     // test QSymmS8 quantization
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestFillQuantization validatorQSymmS8(qSymmS8Options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     // test QuantisedSymmS16 quantization
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestFillQuantization validatorQSymmS16(qSymmS16options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [44/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedLstmLayerPeephole )

Definition at line 1185 of file ConstTensorLayerVisitor.cpp.

 {
     const char* layerName = "LstmLayer";
     LstmDescriptor descriptor;
     descriptor.m_ActivationFunc = 3;
     descriptor.m_ClippingThresProj = 0.5f;
     descriptor.m_ClippingThresCell = 0.3f;
     descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
     descriptor.m_PeepholeEnabled = true;
 
     std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
 
     std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
 
     std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
 
     std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
 
     std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
 
     std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
 
     std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
 
     std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
 
     std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
 
     std::vector<float> cellToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToForgetWeights(
             TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::Float32), cellToForgetWeightsData);
 
     std::vector<float> cellToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToOutputWeights(
             TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::Float32), cellToOutputWeightsData);
 
     LstmInputParams params;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     params.m_CellToForgetWeights = &cellToForgetWeights;
     params.m_CellToOutputWeights = &cellToOutputWeights;
 
     TestLstmLayerVisitor visitor(descriptor, params, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [45/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeFullyConnected )

Definition at line 1217 of file QuantizerTest.cpp.

References ValidateFullyConnectedLayer().

 {
     ValidateFullyConnectedLayer(false);
 }

◆ BOOST_AUTO_TEST_CASE() [46/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeFullyConnectedBiasEnabled )

Definition at line 1222 of file QuantizerTest.cpp.

References ValidateFullyConnectedLayer().

 {
     ValidateFullyConnectedLayer(true);
 }

◆ BOOST_AUTO_TEST_CASE() [47/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckLstmLayerProjection )

Definition at line 1273 of file ConstTensorLayerVisitor.cpp.

 {
     LstmDescriptor descriptor;
     descriptor.m_ActivationFunc = 3;
     descriptor.m_ClippingThresProj = 0.5f;
     descriptor.m_ClippingThresCell = 0.3f;
     descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
     descriptor.m_ProjectionEnabled = true;
 
     std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
 
     std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
 
     std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
 
     std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
 
     std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
 
     std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
 
     std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
 
     std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
 
     std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
 
     std::vector<float> projectionBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> projectionBiasDimensions = {1, 1, 3, 3};
     ConstTensor projectionBias(
             TensorInfo(4, projectionBiasDimensions.data(), DataType::Float32), projectionBiasData);
 
     std::vector<float> projectionWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> projectionWeightsDimensions = {1, 1, 3, 3};
     ConstTensor projectionWeights(
             TensorInfo(4, projectionWeightsDimensions.data(), DataType::Float32), projectionWeightsData);
 
             LstmInputParams params;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     params.m_ProjectionWeights = &projectionWeights;
     params.m_ProjectionBias = &projectionBias;
 
     TestLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [48/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeConvolution2d )

Definition at line 1303 of file QuantizerTest.cpp.

References TestQuantizeConvolution2d().

 {
     TestQuantizeConvolution2d(false);
 }

◆ BOOST_AUTO_TEST_CASE() [49/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeConvolution2dWithBiases )

Definition at line 1308 of file QuantizerTest.cpp.

References TestQuantizeConvolution2d().

 {
     TestQuantizeConvolution2d(true);
 }

◆ BOOST_AUTO_TEST_CASE() [50/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedLstmLayerProjection )

Definition at line 1359 of file ConstTensorLayerVisitor.cpp.

 {
     const char* layerName = "LstmLayer";
     LstmDescriptor descriptor;
     descriptor.m_ActivationFunc = 3;
     descriptor.m_ClippingThresProj = 0.5f;
     descriptor.m_ClippingThresCell = 0.3f;
     descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
     descriptor.m_ProjectionEnabled = true;
 
     std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
 
     std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
 
     std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
 
     std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
 
     std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
 
     std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
 
     std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
 
     std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
 
     std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
 
     std::vector<float> projectionBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> projectionBiasDimensions = {1, 1, 3, 3};
     ConstTensor projectionBias(
             TensorInfo(4, projectionBiasDimensions.data(), DataType::Float32), projectionBiasData);
 
     std::vector<float> projectionWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
     std::vector<unsigned int> projectionWeightsDimensions = {1, 1, 3, 3};
     ConstTensor projectionWeights(
             TensorInfo(4, projectionWeightsDimensions.data(), DataType::Float32), projectionWeightsData);
 
     LstmInputParams params;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     params.m_ProjectionWeights = &projectionWeights;
     params.m_ProjectionBias = &projectionBias;
 
     TestLstmLayerVisitor visitor(descriptor, params, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [51/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeDepthwiseConvolution2d )

Definition at line 1389 of file QuantizerTest.cpp.

References TestQuantizeDepthwiseConvolution2d().

 {
     TestQuantizeDepthwiseConvolution2d(false);
 }

◆ BOOST_AUTO_TEST_CASE() [52/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeDepthwiseConvolution2dWithBiases )

Definition at line 1394 of file QuantizerTest.cpp.

References TestQuantizeDepthwiseConvolution2d().

 {
     TestQuantizeDepthwiseConvolution2d(true);
 }

◆ BOOST_AUTO_TEST_CASE() [53/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeInstanceNormalization )

Definition at line 1399 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestInstanceNormalizationQuantization : public TestQuantization
     {
     public:
         TestInstanceNormalizationQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
             : TestQuantization(inputShape, outputShape) {}
 
         TestInstanceNormalizationQuantization(const QuantizerOptions& options,
                                               const TensorShape& inputShape,
                                               const TensorShape& outputShape)
             : TestQuantization(options, inputShape, outputShape) {}
 
         virtual void VisitInstanceNormalizationLayer(const IConnectableLayer* layer,
                                                      const InstanceNormalizationDescriptor& descriptor,
                                                      const char* name = nullptr)
         {
             IgnoreUnused(descriptor, name);
             const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
 
             const OffsetScalePair qAsymmU8Params{ 30.0f / g_AsymmU8QuantizationBase, 128 };
             const OffsetScalePair qAsymmS8Params { 30.0f / g_AsymmS8QuantizationBase,  0};
             const OffsetScalePair qSymmS8Params { 15.0f / g_SymmS8QuantizationBase,  0};
             const OffsetScalePair qSymmS16Params{ 15.0f / g_SymmS16QuantizationBase, 0 };
 
             TestQuantizationParams(info, qAsymmU8Params, qAsymmS8Params, qSymmS8Params, qSymmS16Params);
         }
     };
 
     const TensorShape tensorShape{ 1, 4, 4, 1 };
     const TensorInfo tensorInfo(tensorShape, DataType::Float32);
 
     INetworkPtr network = INetwork::Create();
 
     IConnectableLayer* inputLayer        = network->AddInputLayer(0);
     IConnectableLayer* instanceNormLayer = network->AddInstanceNormalizationLayer(InstanceNormalizationDescriptor());
     IConnectableLayer* outputLayer       = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(instanceNormLayer->GetInputSlot(0));
     instanceNormLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     instanceNormLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     // test QAsymmU8 quantization
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestInstanceNormalizationQuantization validatorQAsymmU8(tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     //test QAsymmS8 quantization
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestInstanceNormalizationQuantization validatorQAsymmS8(qAsymmS8Options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     // test QSymmS8 quantization
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestInstanceNormalizationQuantization validatorQSymmS8(qSymmS8Options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     // test QSymmS16 quantization
     const QuantizerOptions qSymmS16Options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16Options)->ExportNetwork();
     TestInstanceNormalizationQuantization validatorQSymmS16(qSymmS16Options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [54/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckQLstmLayerBasic )

Definition at line 1446 of file ConstTensorLayerVisitor.cpp.

 {
     QLstmDescriptor descriptor;
     descriptor.m_ProjectionClip = 0.5f;
     descriptor.m_CellClip = 0.3f;
     descriptor.m_CifgEnabled = true;
 
     // Basic params ONLY
     std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
 
     std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
 
     std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
 
     std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
 
     std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
 
     std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
 
     std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
 
     std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
 
     std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
 
     LstmInputParams params;
     params.m_InputToForgetWeights     = &inputToForgetWeights;
     params.m_InputToCellWeights       = &inputToCellWeights;
     params.m_InputToOutputWeights     = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights   = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias           = &forgetGateBias;
     params.m_CellBias                 = &cellBias;
     params.m_OutputGateBias           = &outputGateBias;
 
     TestQLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [55/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeLogSoftmax )

Definition at line 1467 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, SoftmaxDescriptor::m_Beta, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestLogSoftmaxQuantization : public TestQuantization
     {
     public:
         TestLogSoftmaxQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
             : TestQuantization(inputShape, outputShape) {}
 
         TestLogSoftmaxQuantization(const QuantizerOptions& options,
                                    const TensorShape& inputShape,
                                    const TensorShape& outputShape)
             : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitLogSoftmaxLayer(const IConnectableLayer* layer,
                                   const SoftmaxDescriptor& descriptor,
                                   const char* name = nullptr) override
         {
             IgnoreUnused(descriptor, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             const OffsetScalePair qAsymmU8Params{ 30.0f / g_AsymmU8QuantizationBase, 128 };
             const OffsetScalePair qAsymmS8Params { 30.0f / g_AsymmS8QuantizationBase,  0};
             const OffsetScalePair qSymmS8Params { 15.0f / g_SymmS8QuantizationBase,  0};
             const OffsetScalePair qSymmS16Params{ 15.0f / g_SymmS16QuantizationBase, 0 };
 
             TestQuantizationParams(info, qAsymmU8Params, qAsymmS8Params, qSymmS8Params, qSymmS16Params);
         }
     };
 
     const TensorShape tensorShape{ 1U };
     const TensorInfo tensorInfo(tensorShape, DataType::Float32);
 
     INetworkPtr network = INetwork::Create();
 
     LogSoftmaxDescriptor descriptor;
     descriptor.m_Beta = 1.0f;
 
     IConnectableLayer* inputLayer        = network->AddInputLayer(0);
     IConnectableLayer* logSoftmaxLayer   = network->AddLogSoftmaxLayer(descriptor);
     IConnectableLayer* outputLayer       = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(logSoftmaxLayer->GetInputSlot(0));
     logSoftmaxLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     logSoftmaxLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     // test QAsymmU8 quantization
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestLogSoftmaxQuantization validatorQAsymmU8(tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     // test QAsymmS8 quantization
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestLogSoftmaxQuantization validatorQAsymmS8(qAsymmS8Options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     // test QSymmS8 quantization
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestLogSoftmaxQuantization validatorQSymmS8(qSymmS8Options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     // test QuantisedSymmS16 quantization
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestLogSoftmaxQuantization validatorQSymmS16(qSymmS16options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [56/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedQLstmLayerBasic )

Definition at line 1518 of file ConstTensorLayerVisitor.cpp.

 {
     const char* layerName = "QLstmLayer";
     QLstmDescriptor descriptor;
     descriptor.m_ProjectionClip = 0.5f;
     descriptor.m_CellClip = 0.3f;
     descriptor.m_CifgEnabled = true;
 
     // Basic params ONLY
     std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
 
     std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
 
     std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
 
     std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
 
     std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
 
     std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
 
     std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
 
     std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
 
     std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
 
     LstmInputParams params;
     params.m_InputToForgetWeights     = &inputToForgetWeights;
     params.m_InputToCellWeights       = &inputToCellWeights;
     params.m_InputToOutputWeights     = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights   = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias           = &forgetGateBias;
     params.m_CellBias                 = &cellBias;
     params.m_OutputGateBias           = &outputGateBias;
 
     TestQLstmLayerVisitor visitor(descriptor, params, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [57/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeSoftmax )

Definition at line 1559 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithSoftmaxLayer(), g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, SoftmaxDescriptor::m_Beta, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestSoftmaxQuantization : public TestQuantization
     {
     public:
         TestSoftmaxQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestSoftmaxQuantization(const QuantizerOptions& options,
                                 const TensorShape& inputShape,
                                 const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitSoftmaxLayer(const IConnectableLayer* layer,
                                const SoftmaxDescriptor& descriptor,
                                const char* name = nullptr) override
         {
             IgnoreUnused(descriptor, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             // Based off default static range [0.0f, 1.0f]
             TestQuantizationParams(info, {1.0f / g_AsymmU8QuantizationBase, 0},
                                          {1.0f / g_AsymmS8QuantizationBase, -128},
                                          {1.0f / g_SymmS8QuantizationBase,  0},
                                          {1.0f / g_SymmS16QuantizationBase, 0});
         }
     };
 
     SoftmaxDescriptor descriptor;
     descriptor.m_Beta = 1.0f;
 
     const TensorShape shape{1U};
     INetworkPtr network = CreateNetworkWithSoftmaxLayer(descriptor, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestSoftmaxQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestSoftmaxQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     // test QSymmS8 quantization
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestSoftmaxQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestSoftmaxQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [58/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckQLstmLayerCifgDisabled )

Definition at line 1591 of file ConstTensorLayerVisitor.cpp.

 {
     QLstmDescriptor descriptor;
     descriptor.m_ProjectionClip = 0.5f;
     descriptor.m_CellClip = 0.3f;
     descriptor.m_CifgEnabled = false;
 
     // Basic params
     std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
 
     std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
 
     std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
 
     std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
 
     std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
 
     std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
 
     std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
 
     std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
 
     std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
 
     // CIFG disabled params
     std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToInputWeights(
             TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QSymmS8), inputToInputWeightsData);
 
     std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToInputWeights(TensorInfo(
             4, recurrentToInputWeightsDimensions.data(), DataType::QSymmS8), recurrentToInputWeightsData);
 
     std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor inputGateBias(
             TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
 
     LstmInputParams params;
 
     // Basic params
     params.m_InputToForgetWeights     = &inputToForgetWeights;
     params.m_InputToCellWeights       = &inputToCellWeights;
     params.m_InputToOutputWeights     = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights   = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias           = &forgetGateBias;
     params.m_CellBias                 = &cellBias;
     params.m_OutputGateBias           = &outputGateBias;
 
     // CIFG disabled params
     params.m_InputToInputWeights     = &inputToInputWeights;
     params.m_RecurrentToInputWeights = &recurrentToInputWeights;
     params.m_InputGateBias           = &inputGateBias;
 
     TestQLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [59/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeStandIn )

Definition at line 1614 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), StandInDescriptor::m_NumInputs, StandInDescriptor::m_NumOutputs, QAsymmS8, QSymmS16, QSymmS8, and IOutputSlot::SetTensorInfo().

 {
     const TensorShape tensorShape{ 1U };
     const TensorInfo tensorInfo(tensorShape, DataType::Float32);
 
     INetworkPtr network = INetwork::Create();
 
     StandInDescriptor descriptor;
     descriptor.m_NumInputs = 1;
     descriptor.m_NumOutputs = 1;
 
     IConnectableLayer* inputLayer     = network->AddInputLayer(0);
     IConnectableLayer* standInLayer   = network->AddStandInLayer(descriptor);
     IConnectableLayer* outputLayer    = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(standInLayer->GetInputSlot(0));
     standInLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     standInLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     // test QAsymmU8 quantization
     BOOST_CHECK_THROW(INetworkQuantizer::Create(network.get())->ExportNetwork(),
                       armnn::UnimplementedException);
 
     // test QAsymmS8 quantization
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     BOOST_CHECK_THROW(INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork(),
                       armnn::UnimplementedException);
 
     // test QuantisedSymmS16 quantization
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     BOOST_CHECK_THROW(INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork(),
                       armnn::UnimplementedException);
 
     // test QuantisedSymmS16 quantization
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     BOOST_CHECK_THROW(INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork(),
                       armnn::UnimplementedException);
 }

◆ BOOST_AUTO_TEST_CASE() [60/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckQLstmLayerCifgDisabledPeepholeEnabled )

Definition at line 1686 of file ConstTensorLayerVisitor.cpp.

 {
     QLstmDescriptor descriptor;
     descriptor.m_ProjectionClip = 0.5f;
     descriptor.m_CellClip = 0.3f;
     descriptor.m_CifgEnabled = false;
     descriptor.m_PeepholeEnabled = true;
 
     // Basic params
     std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
 
     std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
 
     std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
 
     std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
 
     std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
 
     std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
 
     std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
 
     std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
 
     std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
 
     // CIFG disabled params
     std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToInputWeights(
             TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QSymmS8), inputToInputWeightsData);
 
     std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToInputWeights(TensorInfo(
             4, recurrentToInputWeightsDimensions.data(), DataType::QSymmS8), recurrentToInputWeightsData);
 
     std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor inputGateBias(
             TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
 
     // Peephole enabled, CIFG disabled params
     std::vector<int16_t> cellToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToInputWeights(
             TensorInfo(4, cellToInputWeightsDimensions.data(), DataType::QSymmS16), cellToInputWeightsData);
 
     std::vector<int16_t> cellToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToForgetWeights(
             TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::QSymmS16), cellToForgetWeightsData);
 
     std::vector<int16_t> cellToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToOutputWeights(
             TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::QSymmS16), cellToOutputWeightsData);
 
     LstmInputParams params;
 
     // Basic params
     params.m_InputToForgetWeights     = &inputToForgetWeights;
     params.m_InputToCellWeights       = &inputToCellWeights;
     params.m_InputToOutputWeights     = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights   = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias           = &forgetGateBias;
     params.m_CellBias                 = &cellBias;
     params.m_OutputGateBias           = &outputGateBias;
 
     // CIFG disabled params
     params.m_InputToInputWeights     = &inputToInputWeights;
     params.m_RecurrentToInputWeights = &recurrentToInputWeights;
     params.m_InputGateBias           = &inputGateBias;
 
     // Peephole enabled, CIFG disabled params
     params.m_CellToInputWeights  = &cellToInputWeights;
     params.m_CellToForgetWeights = &cellToForgetWeights;
     params.m_CellToOutputWeights = &cellToOutputWeights;
 
     TestQLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [61/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizePermute )

Definition at line 1692 of file QuantizerTest.cpp.

References CompleteLeakyReluNetwork(), INetworkQuantizer::Create(), INetwork::Create(), CreateStartOfLeakyReluNetwork(), Float32, IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestPermuteQuantization : public TestLeakyReLuActivationQuantization
     {
     public:
         TestPermuteQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(inputShape, outputShape) {}
 
         TestPermuteQuantization(const QuantizerOptions& options,
                                 const TensorShape& inputShape,
                                 const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(options, inputShape, outputShape) {}
 
         void VisitPermuteLayer(const IConnectableLayer* layer,
                                const PermuteDescriptor& desc,
                                const char* name = nullptr) override
         {
             IgnoreUnused(desc, name);
             CheckForwardedQuantizationSettings(layer);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape shape{1U};
     TensorInfo info(shape, DataType::Float32);
 
     IConnectableLayer* activation = CreateStartOfLeakyReluNetwork(network.get(), info);
 
     // Add the layer under test
     PermuteDescriptor desc;
     IConnectableLayer* permute = network->AddPermuteLayer(desc);
 
     CompleteLeakyReluNetwork(network.get(), activation, permute, info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestPermuteQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestPermuteQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestPermuteQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestPermuteQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [62/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeSpaceToBatch )

Definition at line 1747 of file QuantizerTest.cpp.

References CompleteLeakyReluNetwork(), INetworkQuantizer::Create(), INetwork::Create(), CreateStartOfLeakyReluNetwork(), Float32, IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestSpaceToBatchQuantization : public TestLeakyReLuActivationQuantization
     {
     public:
         TestSpaceToBatchQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(inputShape, outputShape) {}
 
         TestSpaceToBatchQuantization(const QuantizerOptions& options,
                                      const TensorShape& inputShape,
                                      const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(options, inputShape, outputShape) {}
 
         void VisitSpaceToBatchNdLayer(const IConnectableLayer* layer,
                                       const SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
                                       const char* name = nullptr) override
         {
             IgnoreUnused(spaceToBatchNdDescriptor, name);
             CheckForwardedQuantizationSettings(layer);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape shape{1U};
     TensorInfo info(shape, DataType::Float32);
 
     IConnectableLayer* activation = CreateStartOfLeakyReluNetwork(network.get(), info);
 
     // Add the layer under test
     SpaceToBatchNdDescriptor descriptor;
     IConnectableLayer* spaceToBatch = network->AddSpaceToBatchNdLayer(descriptor);
 
     CompleteLeakyReluNetwork(network.get(), activation, spaceToBatch, info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestSpaceToBatchQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestSpaceToBatchQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestSpaceToBatchQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestSpaceToBatchQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [63/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeSpaceToDepth )

Definition at line 1802 of file QuantizerTest.cpp.

References CompleteLeakyReluNetwork(), INetworkQuantizer::Create(), INetwork::Create(), CreateStartOfLeakyReluNetwork(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), info, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestSpaceToDepthQuantization : public TestLeakyReLuActivationQuantization
     {
     public:
         TestSpaceToDepthQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
             : TestLeakyReLuActivationQuantization(inputShape, outputShape)
         {}
 
         TestSpaceToDepthQuantization(const QuantizerOptions& options,
                                      const TensorShape& inputShape,
                                      const TensorShape& outputShape)
             : TestLeakyReLuActivationQuantization(options, inputShape, outputShape)
         {}
 
         void VisitSpaceToDepthLayer(const IConnectableLayer* layer,
                                     const SpaceToDepthDescriptor&,
                                     const char* = nullptr) override
         {
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
             TestQuantizationParams(info,
                                   { 30.0f / g_AsymmU8QuantizationBase, 128 },
                                   { 30.0f / g_AsymmS8QuantizationBase, 0   },
                                   { 15.0f / g_SymmS8QuantizationBase,  0   },
                                   { 15.0f / g_SymmS16QuantizationBase, 0   });
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape shape{ 1u };
     TensorInfo info(shape, DataType::Float32);
 
     IConnectableLayer* activation   = CreateStartOfLeakyReluNetwork(network.get(), info);
     IConnectableLayer* spaceToDepth = network->AddSpaceToDepthLayer(SpaceToDepthDescriptor());
 
     CompleteLeakyReluNetwork(network.get(), activation, spaceToDepth, info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestSpaceToDepthQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestSpaceToDepthQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestSpaceToDepthQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestSpaceToDepthQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [64/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckQLstmLayerCifgEnabledPeepholeEnabled )

Definition at line 1803 of file ConstTensorLayerVisitor.cpp.

 {
     QLstmDescriptor descriptor;
     descriptor.m_ProjectionClip = 0.5f;
     descriptor.m_CellClip = 0.3f;
     descriptor.m_CifgEnabled = true;
     descriptor.m_PeepholeEnabled = true;
 
     // Basic params
     std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
 
     std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
 
     std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
 
     std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
 
     std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
 
     std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
 
     std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
 
     std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
 
     std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
 
     // Peephole enabled and CIFG enabled params
     std::vector<int16_t> cellToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToForgetWeights(
             TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::QSymmS16), cellToForgetWeightsData);
 
     std::vector<int16_t> cellToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellToOutputWeights(
             TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::QSymmS16), cellToOutputWeightsData);
 
     LstmInputParams params;
 
     // Basic params
     params.m_InputToForgetWeights     = &inputToForgetWeights;
     params.m_InputToCellWeights       = &inputToCellWeights;
     params.m_InputToOutputWeights     = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights   = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias           = &forgetGateBias;
     params.m_CellBias                 = &cellBias;
     params.m_OutputGateBias           = &outputGateBias;
 
     // Peephole enabled and CIFG enabled params
     params.m_CellToForgetWeights = &cellToForgetWeights;
     params.m_CellToOutputWeights = &cellToOutputWeights;
 
     TestQLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [65/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizePooling2d )

Definition at line 1860 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IgnoreUnused(), info, LeakyReLu, ActivationDescriptor::m_A, ActivationDescriptor::m_B, ActivationDescriptor::m_Function, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestPooling2dQuantization : public TestLeakyReLuActivationQuantization
     {
     public:
         TestPooling2dQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(inputShape, outputShape) {}
 
         TestPooling2dQuantization(const QuantizerOptions& options,
                                   const TensorShape& inputShape,
                                   const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(options, inputShape, outputShape) {}
 
         void VisitPooling2dLayer(const IConnectableLayer* layer,
                                  const Pooling2dDescriptor& desc,
                                  const char* name = nullptr) override
         {
             IgnoreUnused(desc, name);
             CheckForwardedQuantizationSettings(layer);
         }
     };
 
     auto network = INetwork::Create();
 
     TensorShape shape{1U};
     TensorInfo info(shape, DataType::Float32);
 
     Pooling2dDescriptor desc;
     ActivationDescriptor activationDescriptor;
     activationDescriptor.m_Function = ActivationFunction::LeakyReLu;
     activationDescriptor.m_A        = 3.5f;
     activationDescriptor.m_B        = -10.0f;
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* activation = network->AddActivationLayer(activationDescriptor);
     IConnectableLayer* pooling2d = network->AddPooling2dLayer(desc);
     IConnectableLayer* output = network->AddOutputLayer(3);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(activation->GetInputSlot(0));
     activation->GetOutputSlot(0).Connect(pooling2d->GetInputSlot(0));
     pooling2d->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set TensorInfo
     input0->GetOutputSlot(0).SetTensorInfo(info);
     activation->GetOutputSlot(0).SetTensorInfo(info);
     pooling2d->GetOutputSlot(0).SetTensorInfo(info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestPooling2dQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestPooling2dQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestPooling2dQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestPooling2dQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [66/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckQLstmLayerProjectionEnabled )

Definition at line 1893 of file ConstTensorLayerVisitor.cpp.

 {
     QLstmDescriptor descriptor;
     descriptor.m_ProjectionClip = 0.5f;
     descriptor.m_CellClip = 0.3f;
     descriptor.m_CifgEnabled = true;
     descriptor.m_ProjectionEnabled = true;
 
     // Basic params ONLY
     std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
 
     std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
 
     std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
 
     std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
 
     std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
 
     std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
 
     std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
 
     std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
 
     std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
 
     // Projection enabled params
     std::vector<uint8_t> projectionWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> projectionWeightsDimensions = {1, 1, 3, 3};
     ConstTensor projectionWeights(TensorInfo(
             4, projectionWeightsDimensions.data(), DataType::QSymmS8), projectionWeightsData);
 
     std::vector<int32_t> projectionBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> projectionBiasDimensions = {1, 1, 3, 3};
     ConstTensor projectionBias(TensorInfo(
             4, projectionBiasDimensions.data(), DataType::Signed32), projectionBiasData);
 
     LstmInputParams params;
 
     // Basic params
     params.m_InputToForgetWeights     = &inputToForgetWeights;
     params.m_InputToCellWeights       = &inputToCellWeights;
     params.m_InputToOutputWeights     = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights   = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias           = &forgetGateBias;
     params.m_CellBias                 = &cellBias;
     params.m_OutputGateBias           = &outputGateBias;
 
     // Projection enabled params
     params.m_ProjectionWeights = &projectionWeights;
     params.m_ProjectionBias    = &projectionBias;
 
     TestQLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [67/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeConstant )

Definition at line 1929 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestConstantQuantization : public TestAdditionQuantization
     {
     public:
         TestConstantQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestAdditionQuantization(inputShape, outputShape) {}
 
         TestConstantQuantization(const QuantizerOptions& options,
                                  const TensorShape& inputShape,
                                  const TensorShape& outputShape)
         : TestAdditionQuantization(options, inputShape, outputShape) {}
 
         void VisitConstantLayer(const IConnectableLayer* layer,
                                 const ConstTensor& input,
                                 const char* name = nullptr) override
         {
             IgnoreUnused(input, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             // Based off the range of values in the const tensor used for the test: [-2.0f, 6.0f]
             TestQuantizationParams(info, {8.0f / g_AsymmU8QuantizationBase, 64},
                                          {8.0f / g_AsymmS8QuantizationBase, -64},
                                          {6.0f / g_SymmS8QuantizationBase,  0},
                                          {6.0f / g_SymmS16QuantizationBase, 0});
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     // Constant layer data
     std::vector<float> data = {-2.0f, -1.0f, 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
     const TensorShape shape{1U, 1U, 3U, 3U};
     TensorInfo tensorInfo(shape, DataType::Float32);
     ConstTensor constantTensor(tensorInfo, data);
 
     // Add the layers
     IConnectableLayer* input    = network->AddInputLayer(0);
     IConnectableLayer* constant = network->AddConstantLayer(constantTensor);
     IConnectableLayer* addition = network->AddAdditionLayer();
     IConnectableLayer* output   = network->AddOutputLayer(1);
 
     // Establish connections
     input->GetOutputSlot(0).Connect(addition->GetInputSlot(0));
     constant->GetOutputSlot(0).Connect(addition->GetInputSlot(1));
     addition->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set TensorInfo in the remaining layers
     input->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     addition->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     constant->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestConstantQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestConstantQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestConstantQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestConstantQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [68/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckQLstmLayerCifgDisabledLayerNormEnabled )

Definition at line 1983 of file ConstTensorLayerVisitor.cpp.

 {
     QLstmDescriptor descriptor;
     descriptor.m_ProjectionClip = 0.5f;
     descriptor.m_CellClip = 0.3f;
     descriptor.m_CifgEnabled = false;
     descriptor.m_LayerNormEnabled = true;
 
     // Basic params
     std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
 
     std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
 
     std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
 
     std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
 
     std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
 
     std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
 
     std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
 
     std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
 
     std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
 
     // CIFG disabled params
     std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToInputWeights(
             TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QSymmS8), inputToInputWeightsData);
 
     std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToInputWeights(TensorInfo(
             4, recurrentToInputWeightsDimensions.data(), DataType::QSymmS8), recurrentToInputWeightsData);
 
     std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor inputGateBias(
             TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
 
     // Layer Norm enabled, CIFG disabled params
     std::vector<int16_t> inputLayerNormWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputLayerNormWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputLayerNormWeights(
             TensorInfo(4, inputLayerNormWeightsDimensions.data(), DataType::QSymmS16), inputLayerNormWeightsData);
 
     std::vector<int16_t> forgetLayerNormWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetLayerNormWeightsDimensions = {1, 1, 3, 3};
     ConstTensor forgetLayerNormWeights(
             TensorInfo(4, forgetLayerNormWeightsDimensions.data(), DataType::QSymmS16), forgetLayerNormWeightsData);
 
     std::vector<int16_t> cellLayerNormWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellLayerNormWeightsDimensions = {1, 1, 3, 3};
     ConstTensor cellLayerNormWeights(
             TensorInfo(4, cellLayerNormWeightsDimensions.data(), DataType::QSymmS16), cellLayerNormWeightsData);
 
     std::vector<int16_t> outputLayerNormWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputLayerNormWeightsDimensions = {1, 1, 3, 3};
     ConstTensor outputLayerNormWeights(
             TensorInfo(4, outputLayerNormWeightsDimensions.data(), DataType::QSymmS16), outputLayerNormWeightsData);
 
     LstmInputParams params;
 
     // Basic params
     params.m_InputToForgetWeights     = &inputToForgetWeights;
     params.m_InputToCellWeights       = &inputToCellWeights;
     params.m_InputToOutputWeights     = &inputToOutputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights   = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
     params.m_ForgetGateBias           = &forgetGateBias;
     params.m_CellBias                 = &cellBias;
     params.m_OutputGateBias           = &outputGateBias;
 
     // CIFG disabled params
     params.m_InputToInputWeights     = &inputToInputWeights;
     params.m_RecurrentToInputWeights = &recurrentToInputWeights;
     params.m_InputGateBias           = &inputGateBias;
 
     // Layer Norm enabled, CIFG disabled params
     params.m_InputLayerNormWeights  = &inputLayerNormWeights;
     params.m_ForgetLayerNormWeights = &forgetLayerNormWeights;
     params.m_CellLayerNormWeights   = &cellLayerNormWeights;
     params.m_OutputLayerNormWeights = &outputLayerNormWeights;
 
     TestQLstmLayerVisitor visitor(descriptor, params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [69/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeArgMinMax )

Definition at line 2001 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), ArgMinMaxDescriptor::m_Function, Max, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestArgMinMaxQuantization : public TestQuantization
     {
     public:
         TestArgMinMaxQuantization(const TensorShape& inputShape, const TensorShape& outputShape)  :
                 TestQuantization(inputShape, outputShape) {}
 
         TestArgMinMaxQuantization(const QuantizerOptions& options,
                                   const TensorShape& inputShape,
                                   const TensorShape& outputShape) :
                 TestQuantization(options, inputShape, outputShape)
         {}
 
         void VisitInputLayer(const IConnectableLayer* layer,
                              LayerBindingId id,
                              const char* name = nullptr) override
         {
             IgnoreUnused(layer, id, name);
         }
 
         void VisitOutputLayer(const IConnectableLayer* layer,
                               LayerBindingId id,
                               const char* name = nullptr) override
         {
             IgnoreUnused(layer, id, name);
         }
         void VisitArgMinMaxLayer(const IConnectableLayer* layer,
                                  const ArgMinMaxDescriptor& argMinMaxDescriptor,
                                  const char* name = nullptr) override
         {
                 IgnoreUnused(argMinMaxDescriptor, name);
                 TensorInfo outputInfo = layer->GetOutputSlot(0).GetTensorInfo();
 
                 TestQuantizationParams(outputInfo,
                                        { 30.0f / g_AsymmU8QuantizationBase, 128 },
                                        { 30.0f / g_AsymmS8QuantizationBase,  0},
                                        { 15.0f / g_SymmS8QuantizationBase,  0},
                                        { 15.0f / g_SymmS16QuantizationBase, 0 });
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape inputShape{ 1, 1, 1, 5 };
     const TensorShape outputShape{ 1, 1, 1 };
 
     TensorInfo inputInfo(inputShape, DataType::Float32);
     TensorInfo outputInfo(outputShape, DataType::Float32);
 
     // Add the input layers
     IConnectableLayer* input = network->AddInputLayer(0);
 
     // Add the layer under test
     ArgMinMaxDescriptor argMinMaxDescriptor;
     argMinMaxDescriptor.m_Function = ArgMinMaxFunction::Max;
     IConnectableLayer* argMinMaxLayer = network->AddArgMinMaxLayer(argMinMaxDescriptor);
 
     // Add the output layers
     IConnectableLayer* output = network->AddOutputLayer(1);
 
     // Establish connections
     input->GetOutputSlot(0).Connect(argMinMaxLayer->GetInputSlot(0));
     argMinMaxLayer->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set tensor info
     input->GetOutputSlot(0).SetTensorInfo(inputInfo);
     argMinMaxLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestArgMinMaxQuantization validatorQAsymmU8(inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestArgMinMaxQuantization validatorQAsymmS8(qAsymmS8Options, inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestArgMinMaxQuantization validatorQSymmS8(qSymmS8Options, inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestArgMinMaxQuantization validatorQSymmS16(qSymmS16options, inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [70/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeComparison )

Definition at line 2090 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, LessOrEqual, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestComparisonQuantization : public TestQuantization
     {
     public:
         TestComparisonQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
             : TestQuantization(inputShape, outputShape) {}
 
         TestComparisonQuantization(const QuantizerOptions& options,
                                    const TensorShape& inputShape,
                                    const TensorShape& outputShape)
             : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitComparisonLayer(const IConnectableLayer* layer,
                                   const ComparisonDescriptor& descriptor,
                                   const char* name = nullptr) override
         {
             IgnoreUnused(descriptor, name);
             TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
 
             const OffsetScalePair qAsymmU8Params{ 30.0f / g_AsymmU8QuantizationBase, 128 };
             const OffsetScalePair qAsymmS8Params { 30.0f / g_AsymmS8QuantizationBase,  0};
             const OffsetScalePair qSymmS8Params { 15.0f / g_SymmS8QuantizationBase,  0};
             const OffsetScalePair qSymmS16Params{ 15.0f / g_SymmS16QuantizationBase, 0 };
 
             TestQuantizationParams(info, qAsymmU8Params, qAsymmS8Params, qSymmS8Params, qSymmS16Params);
         }
     };
 
     const TensorShape tensorShape{ 1u };
     const TensorInfo tensorInfo(tensorShape, DataType::Float32);
 
     INetworkPtr network = INetwork::Create();
     ComparisonDescriptor descriptor(ComparisonOperation::LessOrEqual);
 
     IConnectableLayer* inputLayer0     = network->AddInputLayer(0);
     IConnectableLayer* inputLayer1     = network->AddInputLayer(1);
     IConnectableLayer* comparisonLayer = network->AddComparisonLayer(descriptor);
     IConnectableLayer* outputLayer     = network->AddOutputLayer(0);
 
     inputLayer0->GetOutputSlot(0).Connect(comparisonLayer->GetInputSlot(0));
     inputLayer1->GetOutputSlot(0).Connect(comparisonLayer->GetInputSlot(1));
     comparisonLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer0->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     inputLayer1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
     comparisonLayer->GetOutputSlot(0).SetTensorInfo(tensorInfo);
 
     // test QAsymmU8 quantization
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestComparisonQuantization validatorQAsymmU8(tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     // test QAsymmS8 quantization
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestComparisonQuantization validatorQAsymmS8(qAsymmS8Options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     // test QSymmS8 quantization
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestComparisonQuantization validatorQSymmS8(qSymmS8Options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     // test QuantisedSymmS16 quantization
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestComparisonQuantization validatorQSymmS16(qSymmS16options, tensorShape, tensorShape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [71/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckQuantizedLstmLayer )

Definition at line 2107 of file ConstTensorLayerVisitor.cpp.

 {
     std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToInputWeights(
             TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QSymmS8), inputToInputWeightsData);
 
     std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
 
     std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
 
     std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
 
 
     std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToInputWeights(TensorInfo(
             4, recurrentToInputWeightsDimensions.data(), DataType::QSymmS8), recurrentToInputWeightsData);
 
     std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
 
     std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
 
     std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
 
 
     std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor inputGateBias(
             TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
 
     std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
 
     std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
 
     std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
 
     QuantizedLstmInputParams params;
 
     params.m_InputToInputWeights = &inputToInputWeights;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
 
     params.m_RecurrentToInputWeights = &recurrentToInputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
 
     params.m_InputGateBias = &inputGateBias;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     TestQuantizedLstmLayerVisitor visitor(params);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddQuantizedLstmLayer(params);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [72/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeConcat )

Definition at line 2162 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IInputSlot::GetConnection(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestConcatQuantization : public TestQuantization
     {
     public:
         TestConcatQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestConcatQuantization(const QuantizerOptions& options,
                                const TensorShape& inputShape,
                                const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitInputLayer(const IConnectableLayer* layer,
                              LayerBindingId id,
                              const char* name = nullptr) override
         {
             IgnoreUnused(layer, id, name);
         }
         void VisitOutputLayer(const IConnectableLayer* layer,
                               LayerBindingId id,
                               const char* name = nullptr) override
         {
             IgnoreUnused(layer, id, name);
         }
         void VisitConcatLayer(const IConnectableLayer* layer,
                               const OriginsDescriptor& originsDescriptor,
                               const char* name = nullptr) override
         {
             IgnoreUnused(originsDescriptor, name);
             TensorInfo outputInfo = layer->GetOutputSlot(0).GetTensorInfo();
             TestQuantizationParams(
                 outputInfo, {60.8f / g_AsymmU8QuantizationBase, 65},
                             {60.8f / g_SymmS8QuantizationBase,  -63},
                             {45.3f / g_SymmS8QuantizationBase,  0},
                             {45.3f / g_SymmS16QuantizationBase, 0});
 
             TensorInfo inputInfo0 = layer->GetInputSlot(0).GetConnection()->GetTensorInfo();
             TensorInfo inputInfo1 = layer->GetInputSlot(1).GetConnection()->GetTensorInfo();
             TensorInfo inputInfo2 = layer->GetInputSlot(2).GetConnection()->GetTensorInfo();
 
             TestDifferentQuantizationScale(inputInfo0, inputInfo1);
             TestDifferentQuantizationScale(inputInfo0, inputInfo2);
             TestDifferentQuantizationScale(inputInfo1, inputInfo2);
             TestDifferentQuantizationScale(inputInfo0, outputInfo);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* input1 = network->AddInputLayer(1);
     IConnectableLayer* input2 = network->AddInputLayer(2);
 
     OriginsDescriptor descriptor(3, 1);
     IConnectableLayer* concatLayer = network->AddConcatLayer(descriptor);
 
     IConnectableLayer* output0 = network->AddOutputLayer(3);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(concatLayer->GetInputSlot(0));
     input1->GetOutputSlot(0).Connect(concatLayer->GetInputSlot(1));
     input2->GetOutputSlot(0).Connect(concatLayer->GetInputSlot(2));
     concatLayer->GetOutputSlot(0).Connect(output0->GetInputSlot(0));
 
     // Set TensorInfo
     const TensorShape shape{1U};
     TensorInfo info(shape, DataType::Float32);
 
     input0->GetOutputSlot(0).SetTensorInfo(info);
     input1->GetOutputSlot(0).SetTensorInfo(info);
     input2->GetOutputSlot(0).SetTensorInfo(info);
     concatLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkQuantizerPtr quantizerPtrQAsymmU8 =  INetworkQuantizer::Create(network.get());
     INetworkQuantizerPtr quantizerPtrQSymmS8  =  INetworkQuantizer::Create(network.get(), qSymmS8Options);
     INetworkQuantizerPtr quantizerPtrQSymmS16 =  INetworkQuantizer::Create(network.get(), qSymmS16options);
     // Override the input ranges
     float min = -15.5f;
     float max = 45.3f;
 
     quantizerPtrQAsymmU8->OverrideInputRange(0, (min + 2.1f), (max - 3.2f));
     quantizerPtrQAsymmU8->OverrideInputRange(1, (min + 6.7f), max);
     quantizerPtrQAsymmU8->OverrideInputRange(2, min, (max - 7.8f));
 
     quantizerPtrQSymmS8->OverrideInputRange(0, (min + 2.1f), (max - 3.2f));
     quantizerPtrQSymmS8->OverrideInputRange(1, (min + 6.7f), max);
     quantizerPtrQSymmS8->OverrideInputRange(2, min, (max - 7.8f));
 
     quantizerPtrQSymmS16->OverrideInputRange(0, (min + 2.1f), (max - 3.2f));
     quantizerPtrQSymmS16->OverrideInputRange(1, (min + 6.7f), max);
     quantizerPtrQSymmS16->OverrideInputRange(2, min, (max - 7.8f));
 
     INetworkPtr quantizedNetworkQAsymmU8 = quantizerPtrQAsymmU8->ExportNetwork();
     TestConcatQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     INetworkPtr quantizedNetworkQSymmS8 = quantizerPtrQSymmS8->ExportNetwork();
     TestConcatQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     INetworkPtr quantizedNetworkQSymmS16 = quantizerPtrQSymmS16->ExportNetwork();
     TestConcatQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [73/90]

armnn::BOOST_AUTO_TEST_CASE ( CheckNamedQuantizedLstmLayer )

Definition at line 2196 of file ConstTensorLayerVisitor.cpp.

 {
     const char* layerName = "LstmLayer";
     std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToInputWeights(
             TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QAsymmU8), inputToInputWeightsData);
 
     std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToForgetWeights(
             TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QAsymmU8), inputToForgetWeightsData);
 
     std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToCellWeights(
             TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QAsymmU8), inputToCellWeightsData);
 
     std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor inputToOutputWeights(
             TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QAsymmU8), inputToOutputWeightsData);
 
 
     std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToInputWeights(TensorInfo(
             4, recurrentToInputWeightsDimensions.data(), DataType::QAsymmU8), recurrentToInputWeightsData);
 
     std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToForgetWeights(TensorInfo(
             4, recurrentToForgetWeightsDimensions.data(), DataType::QAsymmU8), recurrentToForgetWeightsData);
 
     std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToCellWeights(TensorInfo(
             4, recurrentToCellWeightsDimensions.data(), DataType::QAsymmU8), recurrentToCellWeightsData);
 
     std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
     ConstTensor recurrentToOutputWeights(TensorInfo(
             4, recurrentToOutputWeightsDimensions.data(), DataType::QAsymmU8), recurrentToOutputWeightsData);
 
 
     std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor inputGateBias(
             TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
 
     std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor forgetGateBias(TensorInfo(
             4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
 
     std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
     ConstTensor cellBias(TensorInfo(
             4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
 
     std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
     ConstTensor outputGateBias(TensorInfo(
             4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
 
     QuantizedLstmInputParams params;
 
     params.m_InputToInputWeights = &inputToInputWeights;
     params.m_InputToForgetWeights = &inputToForgetWeights;
     params.m_InputToCellWeights = &inputToCellWeights;
     params.m_InputToOutputWeights = &inputToOutputWeights;
 
     params.m_RecurrentToInputWeights = &recurrentToInputWeights;
     params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
     params.m_RecurrentToCellWeights = &recurrentToCellWeights;
     params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
 
     params.m_InputGateBias = &inputGateBias;
     params.m_ForgetGateBias = &forgetGateBias;
     params.m_CellBias = &cellBias;
     params.m_OutputGateBias = &outputGateBias;
 
     TestQuantizedLstmLayerVisitor visitor(params, layerName);
 
     Network net;
 
     IConnectableLayer* const layer = net.AddQuantizedLstmLayer(params, layerName);
     layer->Accept(visitor);
 }

◆ BOOST_AUTO_TEST_CASE() [74/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeReshape )

Definition at line 2270 of file QuantizerTest.cpp.

References CompleteLeakyReluNetwork(), INetworkQuantizer::Create(), INetwork::Create(), CreateStartOfLeakyReluNetwork(), Float32, IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestReshapeQuantization : public TestLeakyReLuActivationQuantization
     {
     public:
         TestReshapeQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(inputShape, outputShape) {}
 
         TestReshapeQuantization(const QuantizerOptions& options,
                                 const TensorShape& inputShape,
                                 const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(options, inputShape, outputShape) {}
 
         virtual void VisitReshapeLayer(const IConnectableLayer* layer,
                                        const ReshapeDescriptor& reshapeDescriptor,
                                        const char* name = nullptr) override
         {
             IgnoreUnused(reshapeDescriptor, name);
             CheckForwardedQuantizationSettings(layer);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape shape{1U};
     TensorInfo info(shape, DataType::Float32);
 
     IConnectableLayer* activation = CreateStartOfLeakyReluNetwork(network.get(), info);
 
     // Add the layer under test
     ReshapeDescriptor descriptor({1, 2, 3, 4});
     IConnectableLayer* reshape = network->AddReshapeLayer(descriptor);
 
     CompleteLeakyReluNetwork(network.get(), activation, reshape, info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestReshapeQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestReshapeQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestReshapeQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestReshapeQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [75/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeSplitter )

Definition at line 2325 of file QuantizerTest.cpp.

References CompleteLeakyReluNetwork(), INetworkQuantizer::Create(), INetwork::Create(), CreateStartOfLeakyReluNetwork(), Float32, IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestSplitterQuantization : public TestLeakyReLuActivationQuantization
     {
     public:
         TestSplitterQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(inputShape, outputShape) {}
 
         TestSplitterQuantization(const QuantizerOptions& options,
                                  const TensorShape& inputShape,
                                  const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(options, inputShape, outputShape) {}
 
         virtual void VisitSplitterLayer(const IConnectableLayer* layer,
                                         const SplitterDescriptor& desc,
                                         const char* name = nullptr)
         {
             IgnoreUnused(desc, name);
             CheckForwardedQuantizationSettings(layer);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape shape{3U};
     TensorInfo info(shape, DataType::Float32);
 
     IConnectableLayer* activation = CreateStartOfLeakyReluNetwork(network.get(), info);
 
     // Add the layer under test
     ViewsDescriptor splitterDesc(2,4);
     IConnectableLayer* splitter = network->AddSplitterLayer(splitterDesc);
     CompleteLeakyReluNetwork(network.get(), activation, splitter, info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestSplitterQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestSplitterQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestSplitterQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestSplitterQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [76/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeResize )

Definition at line 2379 of file QuantizerTest.cpp.

References CompleteLeakyReluNetwork(), INetworkQuantizer::Create(), INetwork::Create(), CreateStartOfLeakyReluNetwork(), Float32, IgnoreUnused(), info, ResizeDescriptor::m_TargetHeight, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestResizeQuantization : public TestLeakyReLuActivationQuantization
     {
     public:
         TestResizeQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
                 : TestLeakyReLuActivationQuantization(inputShape, outputShape)
         {}
 
         TestResizeQuantization(const QuantizerOptions& options,
                                        const TensorShape& inputShape,
                                        const TensorShape& outputShape)
                 : TestLeakyReLuActivationQuantization(options, inputShape, outputShape)
         {}
 
         void VisitResizeLayer(const IConnectableLayer* layer,
                                       const ResizeDescriptor& resizeDescriptor,
                                       const char* name = nullptr) override
         {
             IgnoreUnused(resizeDescriptor, name);
             CheckForwardedQuantizationSettings(layer);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape shape{1U};
     TensorInfo info(shape, DataType::Float32);
 
     IConnectableLayer* activation = CreateStartOfLeakyReluNetwork(network.get(), info);
 
     // Add the layer under test
     ResizeDescriptor descriptor;
     descriptor.m_TargetHeight = 3;
     descriptor.m_TargetWidth  = 3;
     IConnectableLayer* resizeLayer = network->AddResizeLayer(descriptor);
 
     CompleteLeakyReluNetwork(network.get(), activation, resizeLayer, info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestResizeQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestResizeQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestResizeQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestResizeQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [77/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeStridedSlice )

Definition at line 2438 of file QuantizerTest.cpp.

References CompleteLeakyReluNetwork(), INetworkQuantizer::Create(), INetwork::Create(), CreateStartOfLeakyReluNetwork(), Float32, IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestStridedSliceQuantization : public TestLeakyReLuActivationQuantization
     {
     public:
         TestStridedSliceQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(inputShape, outputShape) {}
 
         TestStridedSliceQuantization(const QuantizerOptions& options,
                                      const TensorShape& inputShape,
                                      const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(options, inputShape, outputShape) {}
 
         virtual void VisitStridedSliceLayer(const IConnectableLayer* layer,
                                             const StridedSliceDescriptor& desc,
                                             const char* name = nullptr)
         {
             IgnoreUnused(desc, name);
             CheckForwardedQuantizationSettings(layer);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape shape{3U};
     TensorInfo info(shape, DataType::Float32);
 
     IConnectableLayer* activation = CreateStartOfLeakyReluNetwork(network.get(), info);
 
     // Add the layer under test
     StridedSliceDescriptor stridedSliceDesc;
     IConnectableLayer* stridedSlice = network->AddStridedSliceLayer(stridedSliceDesc);
 
     CompleteLeakyReluNetwork(network.get(), activation, stridedSlice, info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestStridedSliceQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestStridedSliceQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestStridedSliceQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestStridedSliceQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [78/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeBatchToSpace )

Definition at line 2493 of file QuantizerTest.cpp.

References CompleteLeakyReluNetwork(), INetworkQuantizer::Create(), INetwork::Create(), CreateStartOfLeakyReluNetwork(), Float32, IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestBatchToSpaceQuantization : public TestLeakyReLuActivationQuantization
     {
     public:
         TestBatchToSpaceQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(inputShape, outputShape) {}
 
         TestBatchToSpaceQuantization(const QuantizerOptions& options,
                                      const TensorShape& inputShape,
                                      const TensorShape& outputShape)
         : TestLeakyReLuActivationQuantization(options, inputShape, outputShape) {}
 
         void VisitBatchToSpaceNdLayer(const IConnectableLayer* layer,
                                       const BatchToSpaceNdDescriptor& batchToSpaceNdDescriptor,
                                       const char* name = nullptr) override
         {
             IgnoreUnused(batchToSpaceNdDescriptor, name);
             CheckForwardedQuantizationSettings(layer);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape shape{1U};
     TensorInfo info(shape, DataType::Float32);
 
     IConnectableLayer* activation = CreateStartOfLeakyReluNetwork(network.get(), info);
 
     // Add the layer under test
     BatchToSpaceNdDescriptor descriptor;
     IConnectableLayer* batchToSpace = network->AddBatchToSpaceNdLayer(descriptor);
 
     CompleteLeakyReluNetwork(network.get(), activation, batchToSpace, info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestBatchToSpaceQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestBatchToSpaceQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestBatchToSpaceQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestBatchToSpaceQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [79/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizePrelu )

Definition at line 2548 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IInputSlot::GetConnection(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), TensorInfo::GetShape(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestPreluQuantization : public TestQuantization
     {
     public:
         TestPreluQuantization(const TensorShape& inputShape,
                               const TensorShape& alphaShape,
                               const TensorShape& outputShape)
             : TestQuantization(inputShape, outputShape)
             , m_AlphaShape(alphaShape)
         {}
 
         TestPreluQuantization(const QuantizerOptions& options,
                               const TensorShape& inputShape,
                               const TensorShape& alphaShape,
                               const TensorShape& outputShape)
             : TestQuantization(options, inputShape, outputShape)
             , m_AlphaShape(alphaShape)
         {}
 
         void VisitInputLayer(const IConnectableLayer* layer,
                              LayerBindingId id,
                              const char* name = nullptr) override
         {
             IgnoreUnused(id, name);
             const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
 
             switch (id)
             {
             case 0: // Input
                 BOOST_TEST(m_InputShape == info.GetShape());
                 break;
             case 1: // Alpha
                 BOOST_TEST(m_AlphaShape == info.GetShape());
                 break;
             default:
                 throw InvalidArgumentException("Invalid layer binding id for PReLU layer");
             }
 
             // Based off current default [-15.0f, 15.0f]
             TestQuantizationParams(info,
                                    { 30.0f / g_AsymmU8QuantizationBase, 128 }, // QASymmU8
                                    { 30.0f / g_AsymmS8QuantizationBase,  0},   // QASymmS8
                                    { 15.0f / g_SymmS8QuantizationBase,  0},    // QSymmS8
                                    { 15.0f / g_SymmS16QuantizationBase, 0 });  // QSymmS16
         }
 
         void VisitOutputLayer(const IConnectableLayer* layer,
                               LayerBindingId id,
                               const char* name = nullptr) override
         {
             IgnoreUnused(id, name);
             const TensorInfo& info = layer->GetInputSlot(0).GetConnection()->GetTensorInfo();
             BOOST_TEST(m_OutputShape == info.GetShape());
         }
 
         void VisitPreluLayer(const IConnectableLayer* layer,
                              const char* name = nullptr) override
         {
             IgnoreUnused(name);
             const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
             TestQuantizationParams(info,
                                    { 30.0f / g_AsymmU8QuantizationBase, 128 }, // QASymmU8
                                    { 30.0f / g_AsymmS8QuantizationBase,  0},   // QAsymmS8
                                    { 15.0f / g_SymmS8QuantizationBase,  0},    // QSymmS8
                                    { 15.0f / g_SymmS16QuantizationBase, 0 });  // QSymmS16
         }
 
     private:
         TensorShape m_AlphaShape;
     };
 
     INetworkPtr network = INetwork::Create();
 
     const TensorShape inputShape{ 4, 1, 2 };
     const TensorShape alphaShape{ 5, 4, 3, 1 };
     const TensorShape outputShape{ 5, 4, 3, 2 };
     TensorInfo inputInfo(inputShape, DataType::Float32);
     TensorInfo alphaInfo(alphaShape, DataType::Float32);
     TensorInfo outputInfo(outputShape, DataType::Float32);
 
     // Add the input layers
     IConnectableLayer* input = network->AddInputLayer(0);
     IConnectableLayer* alpha = network->AddInputLayer(1);
 
     // Add the layer under test
     IConnectableLayer* prelu = network->AddPreluLayer("prelu");
 
     // Add the output layers
     IConnectableLayer* output = network->AddOutputLayer(0);
 
     // Establish connections
     input->GetOutputSlot(0).Connect(prelu->GetInputSlot(0));
     alpha->GetOutputSlot(0).Connect(prelu->GetInputSlot(1));
     prelu->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set tensor info
     input->GetOutputSlot(0).SetTensorInfo(inputInfo);
     alpha->GetOutputSlot(0).SetTensorInfo(alphaInfo);
     prelu->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestPreluQuantization validatorQAsymmU8(inputShape, alphaShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestPreluQuantization validatorQAsymmS8(qAsymmS8Options, inputShape, alphaShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestPreluQuantization validatorQSymmS8(qSymmS8Options, inputShape, alphaShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestPreluQuantization validatorQSymmS16(qSymmS16options, inputShape, alphaShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [80/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeTransposeConvolution2d )

Definition at line 2749 of file QuantizerTest.cpp.

References TestQuantizeTransposeConvolution2d().

 {
     TestQuantizeTransposeConvolution2d(false);
 }

◆ BOOST_AUTO_TEST_CASE() [81/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeTransposeConvolution2dWithBiases )

Definition at line 2754 of file QuantizerTest.cpp.

References TestQuantizeTransposeConvolution2d().

 {
     TestQuantizeTransposeConvolution2d(true);
 }

◆ BOOST_AUTO_TEST_CASE() [82/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeStack )

Definition at line 2759 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

 {
     class TestStackQuantization : public TestQuantization
     {
     public:
         TestStackQuantization(const TensorShape& inputShape,
                               const TensorShape& outputShape)
             : TestQuantization(inputShape, outputShape) {}
 
         TestStackQuantization(const QuantizerOptions& options,
                               const TensorShape& inputShape,
                               const TensorShape& outputShape)
             : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitInputLayer(const IConnectableLayer* layer,
                              LayerBindingId id,
                              const char* name = nullptr) override
         {
             IgnoreUnused(layer, id, name);
         }
         void VisitOutputLayer(const IConnectableLayer* layer,
                               LayerBindingId id,
                               const char* name = nullptr) override
         {
             IgnoreUnused(layer, id, name);
         }
 
         void VisitStackLayer(const IConnectableLayer* layer,
                              const StackDescriptor& descriptor,
                              const char* name = nullptr) override
         {
             IgnoreUnused(descriptor, name);
             TensorInfo outputInfo = layer->GetOutputSlot(0).GetTensorInfo();
 
             TestQuantizationParams(outputInfo,
                 { 30.0f / g_AsymmU8QuantizationBase, 128 },
                 { 30.0f / g_AsymmS8QuantizationBase, 0},
                 { 15.0f / g_SymmS8QuantizationBase,  0},
                 { 15.0f / g_SymmS16QuantizationBase, 0 });
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* input1 = network->AddInputLayer(1);
 
     const TensorShape inputShape{ 3, 4, 5 };
     const TensorShape outputShape{ 3, 4, 2, 5 };
 
     StackDescriptor descriptor(2, 2, inputShape);
     IConnectableLayer* stackLayer = network->AddStackLayer(descriptor);
 
     IConnectableLayer* output = network->AddOutputLayer(0);
 
     input0->GetOutputSlot(0).Connect(stackLayer->GetInputSlot(0));
     input1->GetOutputSlot(0).Connect(stackLayer->GetInputSlot(1));
     stackLayer->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestStackQuantization validatorQAsymmU8(inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestStackQuantization validatorQAsymmS8(qAsymmS8Options, inputShape, inputShape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestStackQuantization validatorQSymmS8(qSymmS8Options, inputShape, inputShape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestStackQuantization validatorQSymmS16(qSymmS16options, inputShape, outputShape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [83/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeSlice )

Definition at line 2838 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestSliceQuantization : public TestQuantization
     {
     public:
         TestSliceQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
             : TestQuantization(inputShape, outputShape)
         {}
 
         TestSliceQuantization(const QuantizerOptions& options,
                               const TensorShape& inputShape,
                               const TensorShape& outputShape)
             : TestQuantization(options, inputShape, outputShape)
         {}
 
         virtual void VisitSliceLayer(const IConnectableLayer* layer,
                                      const SliceDescriptor& desc,
                                      const char* name = nullptr)
         {
             IgnoreUnused(desc, name);
             const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
 
             const OffsetScalePair qAsymmU8Params{ 30.0f / g_AsymmU8QuantizationBase, 128 };
             const OffsetScalePair qAsymmS8Params{ 30.0f / g_AsymmS8QuantizationBase, 0 };
             const OffsetScalePair qSymmS8Params { 15.0f / g_SymmS8QuantizationBase,  0 };
             const OffsetScalePair qSymmS16Params{ 15.0f / g_SymmS16QuantizationBase, 0 };
 
             TestQuantizationParams(info, qAsymmU8Params, qAsymmS8Params, qSymmS8Params, qSymmS16Params);
         }
     };
 
     TensorShape shape{ 3 };
     TensorInfo info(shape, DataType::Float32);
 
     INetworkPtr network = INetwork::Create();
 
     IConnectableLayer* inputLayer  = network->AddInputLayer(0);
     IConnectableLayer* sliceLayer  = network->AddSliceLayer(SliceDescriptor());
     IConnectableLayer* outputLayer = network->AddOutputLayer(0);
 
     inputLayer->GetOutputSlot(0).Connect(sliceLayer->GetInputSlot(0));
     sliceLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(info);
     sliceLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     // test QAsymmU8 quantization
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestSliceQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     // test QASymmS8 quantization
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestSliceQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     // test QSymmS8 quantization
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestSliceQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     // test QSymmS16 quantization
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestSliceQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [84/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeInf )

Definition at line 2923 of file QuantizerTest.cpp.

References SetupQuantize().

 {
     BOOST_CHECK_EQUAL(SetupQuantize(std::numeric_limits<float>::infinity())[0], 255);
 }

◆ BOOST_AUTO_TEST_CASE() [85/90]

armnn::BOOST_AUTO_TEST_CASE ( QuantizeNegativeInf )

Definition at line 2928 of file QuantizerTest.cpp.

References IInputSlot::GetConnection(), TensorInfo::GetDataType(), GetDataTypeName(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), TensorInfo::GetShape(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, and SetupQuantize().

 {
     BOOST_CHECK_EQUAL(SetupQuantize(-1 * std::numeric_limits<float>::infinity())[0], 0);
 }

◆ BOOST_AUTO_TEST_CASE() [86/90]

armnn::BOOST_AUTO_TEST_CASE ( PreserveTypeFloat32 )

Definition at line 3028 of file QuantizerTest.cpp.

References Float32, and PreserveTypeTestImpl().

 {
     PreserveTypeTestImpl(DataType::Float32);
 }

◆ BOOST_AUTO_TEST_CASE() [87/90]

armnn::BOOST_AUTO_TEST_CASE ( PreserveTypeQAsymmU8 )

Definition at line 3033 of file QuantizerTest.cpp.

References PreserveTypeTestImpl(), and QAsymmU8.

 {
     PreserveTypeTestImpl(DataType::QAsymmU8);
 }

◆ BOOST_AUTO_TEST_CASE() [88/90]

armnn::BOOST_AUTO_TEST_CASE ( PreserveTypeQsymm8 )

Definition at line 3038 of file QuantizerTest.cpp.

References PreserveTypeTestImpl(), and QSymmS8.

 {
     PreserveTypeTestImpl(DataType::QSymmS8);
 }

◆ BOOST_AUTO_TEST_CASE() [89/90]

armnn::BOOST_AUTO_TEST_CASE ( PreserveTypeQsymm16 )

Definition at line 3043 of file QuantizerTest.cpp.

References PreserveTypeTestImpl(), and QSymmS16.

 {
     PreserveTypeTestImpl(DataType::QSymmS16);
 }

◆ BOOST_AUTO_TEST_CASE() [90/90]

armnn::BOOST_AUTO_TEST_CASE ( TestConnectionPreservationAfterDynamicQuant )

Definition at line 3048 of file QuantizerTest.cpp.

References BOOST_AUTO_TEST_SUITE_END(), IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, IInputSlot::GetConnection(), IConnectableLayer::GetGuid(), IConnectableLayer::GetInputSlot(), GetInputTensorInfo(), IConnectableLayer::GetName(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetOwningLayerGuid(), ActivationDescriptor::m_Function, ReLu, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

 {
     class TestConnectionPreservation : public LayerVisitorBase<VisitorNoThrowPolicy>
     {
     public:
         TestConnectionPreservation(const Graph& graph)
             : LayerVisitorBase<VisitorNoThrowPolicy>()
             , m_Graph(graph)
         {}
 
         void VisitAdditionLayer(const IConnectableLayer* layer, const char*) override
         {
             CheckLayerName(layer->GetInputSlot(0).GetConnection()->GetOwningLayerGuid(), "reLU1");
             CheckLayerName(layer->GetInputSlot(1).GetConnection()->GetOwningLayerGuid(), "reLU2");
         }
 
         void CheckLayerName(LayerGuid guid, std::string expectedName)
         {
             bool guidFound = false;
             for (Layer* layer : m_Graph)
             {
                 if (layer->GetGuid() == guid)
                 {
                     BOOST_CHECK_EQUAL(layer->GetName(), expectedName.c_str());
                     guidFound = true;
                     break;
                 }
             }
             if (!guidFound)
             {
                 BOOST_FAIL("No layer matching the GUID was found");
             }
         }
 
     private:
         Graph m_Graph;
     };
 
     INetworkPtr network = INetwork::Create();
 
     IConnectableLayer* inputLayer =  network->AddInputLayer(0,"inputLayer1");
     armnn::ActivationDescriptor ReLUDesc;
     ReLUDesc.m_Function = ActivationFunction::ReLu;
 
     IConnectableLayer* reLULayer1 = network->AddActivationLayer(ReLUDesc, "reLU1");
     IConnectableLayer* reLULayer2 = network->AddActivationLayer(ReLUDesc, "reLU2");
     IConnectableLayer* addLayer1 = network->AddAdditionLayer("addLayer1");
     IConnectableLayer* outputLayer = network->AddOutputLayer(0,"outPutLayer1");
 
     inputLayer->GetOutputSlot(0).Connect(reLULayer1->GetInputSlot(0));
     reLULayer1->GetOutputSlot(0).Connect(reLULayer2->GetInputSlot(0));
     reLULayer1->GetOutputSlot(0).Connect(addLayer1->GetInputSlot(0));
     reLULayer2->GetOutputSlot(0).Connect(addLayer1->GetInputSlot(1));
     addLayer1->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
 
     inputLayer->GetOutputSlot(0).SetTensorInfo(TensorInfo(TensorShape({1, 2, 2, 1}), DataType::Float32));
     reLULayer1->GetOutputSlot(0).SetTensorInfo(TensorInfo(TensorShape({1, 2, 2, 1}), DataType::Float32));
     reLULayer2->GetOutputSlot(0).SetTensorInfo(TensorInfo(TensorShape({1, 2, 2, 1}), DataType::Float32));
     addLayer1->GetOutputSlot(0).SetTensorInfo(TensorInfo(TensorShape({1, 2, 2, 1}), DataType::Float32));
 
     TestConnectionPreservation visitor1(PolymorphicDowncast<const Network*>(network.get())->GetGraph());
     VisitLayersTopologically(network.get(), visitor1);
 
     armnn::INetworkQuantizerPtr quantizer = armnn::INetworkQuantizer::Create(network.get());
 
     armnn::TensorInfo tensorInfo = GetInputTensorInfo(PolymorphicDowncast<const Network*>(network.get()));
 
     std::vector<float> inputData({0, 2, 0, 4});
     armnn::ConstTensor inputTensor(tensorInfo, inputData.data());
 
     InputTensors inputTensors;
     inputTensors.push_back(std::make_pair(0, inputTensor));
     quantizer->Refine(inputTensors);
 
     INetworkPtr quantNetwork = quantizer->ExportNetwork();
 
     TestConnectionPreservation visitor2(PolymorphicDowncast<const Network*>(quantNetwork.get())->GetGraph());
     VisitLayersTopologically(quantNetwork.get(), visitor2);
 }

◆ boost_test_print_type() [1/2]

std::ostream& armnn::boost_test_print_type	(	std::ostream &	ostr,
		const TensorInfo &	right
	)

Definition at line 14 of file TensorTest.cpp.

References TensorInfo::GetNumDimensions(), and TensorInfo::GetShape().

 {
     ostr << "TensorInfo[ "
     << right.GetNumDimensions() << ","
     << right.GetShape()[0] << ","
     << right.GetShape()[1] << ","
     << right.GetShape()[2] << ","
     << right.GetShape()[3]
     << " ]" << std::endl;
     return ostr;
 }

◆ boost_test_print_type() [2/2]

std::ostream& armnn::boost_test_print_type	(	std::ostream &	ostr,
		const TensorShape &	shape
	)

Definition at line 26 of file TensorTest.cpp.

References BOOST_AUTO_TEST_SUITE(), and TensorShape::GetNumDimensions().

 {
     ostr << "TensorShape[ "
         << shape.GetNumDimensions() << ","
         << shape[0] << ","
         << shape[1] << ","
         << shape[2] << ","
         << shape[3]
         << " ]" << std::endl;
     return ostr;
 }

◆ CalcLevel()

int armnn::CalcLevel ( const Event * eventPtr )

Definition at line 234 of file Profiling.cpp.

References Event::GetName(), and Event::GetParentEvent().

Referenced by Profiler::AnalyzeEventsAndWriteResults().

 {
     int level=0;
     while (eventPtr != nullptr)
     {
         eventPtr = eventPtr->GetParentEvent();
         level++;
     }
     return level;
 }

◆ CalculateEdgeStrategy()

EdgeStrategy armnn::CalculateEdgeStrategy	(	BackendsMap &	backends,
		ITensorHandleFactory::FactoryId	srcFactoryId,
		const Layer &	layer,
		const Layer &	connectedLayer,
		TensorHandleFactoryRegistry &	registry,
		bool	importEnabled
	)

Definition at line 860 of file Network.cpp.

References ARMNN_ASSERT_MSG, CopyToTarget, DirectCompatibility, ExportToTarget, Layer::GetBackendId(), ITensorHandleFactory::GetCapabilities(), ITensorHandleFactory::GetExportFlags(), TensorHandleFactoryRegistry::GetFactory(), ITensorHandleFactory::GetImportFlags(), Layer::GetType(), ITensorHandleFactory::LegacyFactoryId, Output, PaddingRequired, ITensorHandleFactory::SupportsMapUnmap(), and Undefined.

Referenced by SelectTensorHandleStrategy().

 {
     auto toBackend = backends.find(connectedLayer.GetBackendId());
     ARMNN_ASSERT_MSG(toBackend != backends.end(), "Backend id not found for the connected layer");
 
     auto dstPrefs = toBackend->second.get()->GetHandleFactoryPreferences();
 
     // Legacy API check for backward compatibility
     if (srcFactoryId == ITensorHandleFactory::LegacyFactoryId || dstPrefs.empty())
     {
         if (layer.GetBackendId() != connectedLayer.GetBackendId())
         {
             return EdgeStrategy::CopyToTarget;
         }
         else
         {
             return EdgeStrategy::DirectCompatibility;
         }
     }
 
     // TensorHandleFactory API present, so perform more sophisticated strategies.
     // Dst Output layers don't require copy because they use import or map/unmap
     if (connectedLayer.GetType() == LayerType::Output)
     {
         return EdgeStrategy::DirectCompatibility;
     }
 
     // Search for direct match in prefs
     for (auto&& pref : dstPrefs)
     {
         if (pref == srcFactoryId)
         {
             return EdgeStrategy::DirectCompatibility;
         }
     }
 
     // Search for export/import options
     ITensorHandleFactory* srcFactory = registry.GetFactory(srcFactoryId);
     if (srcFactory->GetExportFlags() != 0 && importEnabled)
     {
         for (auto&& pref : dstPrefs)
         {
             ITensorHandleFactory* dstFactory = registry.GetFactory(pref);
 
             // Handles cases when a destPref is not listed in TensorHandleFactoryRegistry
             if (!dstFactory) {
                 continue;
             }
 
             if ((dstFactory->GetImportFlags() & srcFactory->GetExportFlags()) != 0)
             {
                 auto srcCapability = srcFactory->GetCapabilities(&layer, &layer, CapabilityClass::PaddingRequired);
                 auto dstCapability = dstFactory->GetCapabilities(&connectedLayer,
                                                                  &connectedLayer,
                                                                  CapabilityClass::PaddingRequired);
                 // Do not require memory copy if the source and destination do not require padding.
                 if (srcCapability.empty() && dstCapability.empty())
                 {
                     return EdgeStrategy::ExportToTarget;
                 }
             }
         }
     }
 
     // Search for copy options via map/unmap
     if (srcFactory->SupportsMapUnmap())
     {
         for (auto&& pref : dstPrefs)
         {
             ITensorHandleFactory* dstFactory = registry.GetFactory(pref);
             if (dstFactory && dstFactory->SupportsMapUnmap())
             {
                 return EdgeStrategy::CopyToTarget;
             }
         }
     }
 
     return EdgeStrategy::Undefined;
 }

◆ CalculateSlotOption()

ITensorHandleFactory::FactoryId armnn::CalculateSlotOption	(	BackendsMap &	backends,
		OutputSlot &	outputSlot,
		TensorHandleFactoryRegistry &	registry
	)

Definition at line 751 of file Network.cpp.

References ARMNN_ASSERT_MSG, Layer::GetBackendId(), OutputSlot::GetConnections(), TensorHandleFactoryRegistry::GetFactory(), IBackendInternal::GetHandleFactoryPreferences(), OutputSlot::GetOwningLayer(), Layer::GetType(), ITensorHandleFactory::LegacyFactoryId, Output, RequiresCopy(), and ITensorHandleFactory::SupportsMapUnmap().

Referenced by SelectTensorHandleStrategy().

 {
     // First ensure the from backends can support the TensorHandeAPI
     Layer& layer = outputSlot.GetOwningLayer();
     auto frmBackend = backends.find(layer.GetBackendId());
     if (frmBackend == backends.end() ||
         !frmBackend->second->SupportsTensorAllocatorAPI())
     {
         return ITensorHandleFactory::LegacyFactoryId;
     }
 
     // Connections to Output Layers requires support for map/unmap on the TensorHandle.
     bool requiresMapUnmap = false;
     for (auto&& connection : outputSlot.GetConnections())
     {
         const Layer& connectedLayer = connection->GetOwningLayer();
         if (connectedLayer.GetType() == LayerType::Output)
         {
             requiresMapUnmap = true;
         }
     }
 
     IBackendInternal* srcBackend = frmBackend->second.get();
     auto srcPrefs = srcBackend->GetHandleFactoryPreferences();
 
     // Initialize the scores
     std::map<ITensorHandleFactory::FactoryId, int> factoryScores;
     for (auto&& pref : srcPrefs)
     {
         if (requiresMapUnmap) // Only consider factories that support map/unmap if required
         {
             ITensorHandleFactory* factory = registry.GetFactory(pref);
             if (!factory->SupportsMapUnmap())
             {
                 // The current tensor handle factory does not support the map/unmap strategy, move to the next one
                 continue;
             }
         }
 
         auto it = factoryScores.find(pref);
         if (it == factoryScores.end())
         {
             // Add new score to the table
             factoryScores[pref] = 0;
         }
     }
 
     // Score each handle factory based on how many times it requires copies on the slot connections
     for (auto&& connection : outputSlot.GetConnections())
     {
         const Layer& connectedLayer = connection->GetOwningLayer();
 
         auto toBackend = backends.find(connectedLayer.GetBackendId());
         ARMNN_ASSERT_MSG(toBackend != backends.end(), "Backend id not found for the connected layer");
 
         auto dstPrefs = toBackend->second.get()->GetHandleFactoryPreferences();
         for (auto&& src : srcPrefs)
         {
             if (factoryScores.find(src) == factoryScores.end()) // Don't consider excluded factories
             {
                 continue;
             }
 
             for (auto&& dst : dstPrefs)
             {
                 if (RequiresCopy(src, dst, registry))
                 {
                     // Copy avoided, increase the score
                     factoryScores[src]++;
                     break;
                 }
             }
         }
     }
 
     // Find the lowest score
     int minScore = std::numeric_limits<int>::max();
     for (auto it : factoryScores)
     {
         minScore = std::min(minScore, it.second);
     }
 
     // Collect factories matching the best(lowest) score
     std::vector<ITensorHandleFactory::FactoryId> optimalFactories;
     for (auto it : factoryScores)
     {
         if (it.second == minScore)
         {
             optimalFactories.push_back(it.first);
         }
     }
 
     // For all compatible Factories matching the best score, find the preferred one for the current layer.
     for (auto&& srcPref : srcPrefs)
     {
         for (auto&& comp : optimalFactories)
         {
             if (comp == srcPref)
             {
                 return comp;
             }
         }
     }
 
     return ITensorHandleFactory::LegacyFactoryId;
 }

◆ CalculateSlotOptionForInput()

ITensorHandleFactory::FactoryId armnn::CalculateSlotOptionForInput	(	BackendsMap &	backends,
		OutputSlot &	slot,
		TensorHandleFactoryRegistry &	registry
	)

Definition at line 659 of file Network.cpp.

References ARMNN_ASSERT, ARMNN_ASSERT_MSG, CheckFlag(), Layer::GetBackendId(), OutputSlot::GetConnections(), TensorHandleFactoryRegistry::GetFactory(), ITensorHandleFactory::GetImportFlags(), OutputSlot::GetOwningLayer(), Layer::GetType(), Input, ITensorHandleFactory::LegacyFactoryId, Malloc, and ITensorHandleFactory::SupportsMapUnmap().

Referenced by SelectTensorHandleStrategy().

 {
     Layer& layer = slot.GetOwningLayer();
     ARMNN_ASSERT(layer.GetType() == LayerType::Input);
 
     // Explicitly select the tensorhandle factory for InputLayer because the rules for it are slightly different. It
     // doesn't matter which backend it is assigned to because they all use the same implementation, which
     // requires Map/Unmap support. This means that, so long as the handle type supports map/unmap semantics, we can
     // select a factory with maximum compatibility with the layers connected to the InputLayer.
 
     // First ensure the from backends can support the TensorHandeAPI
     auto frmBackend = backends.find(layer.GetBackendId());
     if (frmBackend == backends.end() ||
         !frmBackend->second->SupportsTensorAllocatorAPI())
     {
         return ITensorHandleFactory::LegacyFactoryId;
     }
 
     // Go through all connections to the output slot and determine the TensorHandleFactory which results in the
     // fewest copies.
     std::map<ITensorHandleFactory::FactoryId, int> factoryScores;
     int topScore = 0;
     ITensorHandleFactory::FactoryId topChoice = ITensorHandleFactory::LegacyFactoryId;
 
     for (auto&& connection : slot.GetConnections())
     {
         const Layer& connectedLayer = connection->GetOwningLayer();
 
         auto toBackend = backends.find(connectedLayer.GetBackendId());
         ARMNN_ASSERT_MSG(toBackend != backends.end(), "Backend id not found for the connected layer");
 
         if (!toBackend->second.get()->SupportsTensorAllocatorAPI())
         {
             // The destination backend does not support the tensor allocator API, move to the next one
             continue;
         }
 
         auto dstPrefs = toBackend->second.get()->GetHandleFactoryPreferences();
         for (auto&& dst : dstPrefs)
         {
             // Input layers use the mem copy workload or import, so the selected factory must
             // support either the map/unmap API or Import API
             ITensorHandleFactory* factory = registry.GetFactory(dst);
             if (!factory->SupportsMapUnmap() &&
                 !CheckFlag(factory->GetImportFlags(), MemorySource::Malloc)) // Just support cpu mem imports for now
             {
                 // The current tensor handle factory does not support the map/unmap or import
                 // strategy, move to the next one
                 continue;
             }
 
             auto it = factoryScores.find(dst);
             if (it == factoryScores.end())
             {
                 // Add new score to the table
                 factoryScores[dst] = 0;
                 if (topChoice == ITensorHandleFactory::LegacyFactoryId)
                 {
                     topChoice = dst;
                 }
             }
             else
             {
                 // Increase the score
                 factoryScores[dst]++;
 
                 // Track the best option
                 if (factoryScores[dst] > topScore)
                 {
                     topScore = factoryScores[dst];
                     topChoice = dst;
                 }
             }
         }
     }
 
     return topChoice;
 }

◆ CalculateSlotOptionForOutput()

ITensorHandleFactory::FactoryId armnn::CalculateSlotOptionForOutput	(	BackendsMap &	backends,
		OutputSlot &	slot,
		TensorHandleFactoryRegistry &	registry
	)

Definition at line 741 of file Network.cpp.

References ITensorHandleFactory::DeferredFactoryId, and IgnoreUnused().

Referenced by SelectTensorHandleStrategy().

 {
     IgnoreUnused(backends, slot, registry);
     return ITensorHandleFactory::DeferredFactoryId;
 }

◆ CheckFlag()

bool armnn::CheckFlag	(	MemorySourceFlags	flags,
		MemorySource	source
	)

inline

Definition at line 47 of file MemorySources.hpp.

Referenced by CalculateSlotOptionForInput(), and LoadedNetwork::EnqueueWorkload().

 {
     return (static_cast<MemorySourceFlags>(source) & flags) != 0;
 }

◆ CheckLayerBindingId()

void armnn::CheckLayerBindingId	(	LayerBindingId	visitorId,
		LayerBindingId	id
	)

Definition at line 13 of file TestInputOutputLayerVisitor.hpp.

Referenced by TestInputLayerVisitor::VisitInputLayer(), and TestOutputLayerVisitor::VisitOutputLayer().

 {
     BOOST_CHECK_EQUAL(visitorId, id);
 }

◆ CheckScaleSetOnQuantizedType()

bool armnn::CheckScaleSetOnQuantizedType	(	Layer *	layer,
		Optional< std::vector< std::string > &>	errMessages
	)

Definition at line 115 of file Network.cpp.

References ARMNN_LOG, TensorInfo::GetDataType(), GetLayerTypeAsCString(), Layer::GetNameStr(), Layer::GetNumOutputSlots(), Layer::GetOutputSlot(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), OutputSlot::GetTensorInfo(), Layer::GetType(), info, QAsymmU8, ReportError(), TensorInfo::SetQuantizationOffset(), TensorInfo::SetQuantizationScale(), OutputSlot::SetTensorInfo(), Softmax, and warning.

Referenced by AssignBackends().

 {
     bool noErrors = true;
     unsigned int numOutputs = layer->GetNumOutputSlots();
     for (unsigned int i = 0; i < numOutputs; i++) {
         OutputSlot& outputSlot = layer->GetOutputSlot(i);
         TensorInfo info = outputSlot.GetTensorInfo();
         if (DataType::QAsymmU8 == info.GetDataType()) {
             if (0.f == info.GetQuantizationScale()) {
                 noErrors = false;
                 std::stringstream ss;
                 ss << "output " << i << " of layer " << GetLayerTypeAsCString(layer->GetType())
                    << " (" << layer->GetNameStr() << ") is of type"
                    << " Quantized 8 bit but its scale parameter has not been set";
                 ReportError(ss.str(), errMessages);
             }
             // Softmax under QuantisedAsymm8 must always be scale (1.0f/256.0f) and offset 0
             if ((info.GetQuantizationScale() != (1.0f / 256.0f) ||
                  info.GetQuantizationOffset() != 0) &&
                  layer->GetType() == armnn::LayerType::Softmax)
             {
                 std::stringstream ss;
                 ss << "Quantization parameters for Softmax layer (Scale: " <<
                 info.GetQuantizationScale() << " and Offset: " << info.GetQuantizationOffset() <<
                 ") are incorrect and have been updated to Scale: 0.00390625 and Offset: 0";
                 ARMNN_LOG(warning) << ss.str();
                 info.SetQuantizationScale((1.0f /256.0f));
                 info.SetQuantizationOffset(0);
                 outputSlot.SetTensorInfo(info);
             }
         }
     }
     return noErrors;
 }

◆ CheckSupportRule()

bool armnn::CheckSupportRule	(	F	rule,
		Optional< std::string &>	reasonIfUnsupported,
		const char *	reason
	)

Definition at line 39 of file LayerSupportRules.hpp.

References OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

 {
     bool supported = rule();
     if (!supported && reason)
     {
         reasonIfUnsupported.value() += std::string(reason) + "\n"; // Append the reason on a new line
     }
     return supported;
 }

◆ CheckTensorDataTypesEqual()

bool armnn::CheckTensorDataTypesEqual	(	const TensorInfo &	input0,
		const TensorInfo &	input1
	)

Definition at line 64 of file LayerSupport.cpp.

References TensorInfo::GetDataType().

Referenced by IsAdditionSupported().

 {
     return input0.GetDataType() == input1.GetDataType();
 }

◆ ClAbsWorkloadValidate()

arm_compute::Status ClAbsWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 21 of file ClAbsWorkload.cpp.

Referenced by ClLayerSupport::IsElementwiseUnarySupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLAbsLayer::validate(&aclInput, &aclOutput);
 }

◆ ClActivationWorkloadValidate()

arm_compute::Status ClActivationWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const ActivationDescriptor &	descriptor
	)

Definition at line 17 of file ClActivationWorkload.cpp.

Referenced by ClLayerSupport::IsActivationSupported().

 {
     const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     const arm_compute::ActivationLayerInfo activationLayerInfo =
         ConvertActivationDescriptorToAclActivationLayerInfo(descriptor);
 
     return arm_compute::CLActivationLayer::validate(&aclInput,
                                                     &aclOutput,
                                                     activationLayerInfo);
 }

◆ ClAdditionValidate()

arm_compute::Status ClAdditionValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 38 of file ClAdditionWorkload.cpp.

Referenced by ClLayerSupport::IsAdditionSupported().

 {
     const arm_compute::TensorInfo aclInput0Info = BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1Info = BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     const arm_compute::Status aclStatus = arm_compute::CLArithmeticAddition::validate(&aclInput0Info,
                                                                                       &aclInput1Info,
                                                                                       &aclOutputInfo,
                                                                                       g_AclConvertPolicy);
 
     return aclStatus;
 }

◆ ClArgMinMaxWorkloadValidate()

arm_compute::Status ClArgMinMaxWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const ArgMinMaxDescriptor &	descriptor
	)

Definition at line 30 of file ClArgMinMaxWorkload.cpp.

Referenced by ClLayerSupport::IsArgMinMaxSupported().

 {
     const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     auto numDims = input.GetNumDimensions();
     auto unsignedAxis = armnnUtils::GetUnsignedAxis(numDims, descriptor.m_Axis);
     int aclAxis = boost::numeric_cast<int>(CalcAclAxis(numDims, unsignedAxis));
 
     if (descriptor.m_Function == ArgMinMaxFunction::Max)
     {
         return arm_compute::CLArgMinMaxLayer::validate(&aclInput, aclAxis, &aclOutput,
                                                        arm_compute::ReductionOperation::ARG_IDX_MAX);
     }
     else
     {
         return arm_compute::CLArgMinMaxLayer::validate(&aclInput, aclAxis, &aclOutput,
                                                        arm_compute::ReductionOperation::ARG_IDX_MIN);
     }
 }

◆ ClBackendId()

constexpr const char* armnn::ClBackendId ( )

Definition at line 10 of file ClBackendId.hpp.

Referenced by ClBackend::GetIdStatic().

10 { return "GpuAcc"; }

◆ ClBatchNormalizationValidate()

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
	)

Definition at line 18 of file ClBatchNormalizationFloatWorkload.cpp.

Referenced by ClLayerSupport::IsBatchNormalizationSupported().

 {
     const arm_compute::TensorInfo aclInputInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(input, desc.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(output, desc.m_DataLayout);
     const arm_compute::TensorInfo aclMeanInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(mean, desc.m_DataLayout);
     const arm_compute::TensorInfo aclVarInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(var, desc.m_DataLayout);
     const arm_compute::TensorInfo aclBetaInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(beta, desc.m_DataLayout);
     const arm_compute::TensorInfo aclGammaInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(gamma, desc.m_DataLayout);
 
     return arm_compute::CLBatchNormalizationLayer::validate(&aclInputInfo,
                                                             &aclOutputInfo,
                                                             &aclMeanInfo,
                                                             &aclVarInfo,
                                                             &aclBetaInfo,
                                                             &aclGammaInfo,
                                                             desc.m_Eps);
 }

◆ ClBatchToSpaceNdWorkloadValidate()

arm_compute::Status ClBatchToSpaceNdWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const BatchToSpaceNdDescriptor &	desc
	)

Definition at line 45 of file ClBatchToSpaceNdWorkload.cpp.

References BatchToSpaceNdDescriptor::m_DataLayout.

Referenced by ClLayerSupport::IsBatchToSpaceNdSupported().

                                                                                            {
     DataLayout dataLayout = desc.m_DataLayout;
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, dataLayout);
 
     // ArmNN blockShape is [H, W] Cl asks for W, H
     int32_t blockHeight = boost::numeric_cast<int32_t>(desc.m_BlockShape[0]);
     int32_t blockWidth = boost::numeric_cast<int32_t>(desc.m_BlockShape[1]);
 
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, dataLayout);
 
     const arm_compute::Status aclStatus = arm_compute::CLBatchToSpaceLayer::validate(&aclInputInfo,
                                                                                      blockWidth,
                                                                                      blockHeight,
                                                                                      &aclOutputInfo);
     return aclStatus;
 }

◆ ClComparisonWorkloadValidate()

arm_compute::Status ClComparisonWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output,
		const ComparisonDescriptor &	descriptor
	)

Definition at line 24 of file ClComparisonWorkload.cpp.

Referenced by ClLayerSupport::IsComparisonSupported().

 {
     const arm_compute::TensorInfo aclInput0Info = BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1Info = BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     const arm_compute::ComparisonOperation comparisonOperation = ConvertComparisonOperationToAcl(descriptor);
 
     const arm_compute::Status aclStatus = arm_compute::CLComparison::validate(&aclInput0Info,
                                                                               &aclInput1Info,
                                                                               &aclOutputInfo,
                                                                               comparisonOperation);
     return aclStatus;
 }

◆ ClConcatWorkloadValidate()

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

Definition at line 28 of file ClConcatWorkload.cpp.

Referenced by ClLayerSupport::IsConcatSupported().

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

◆ ClConstantWorkloadValidate()

arm_compute::Status ClConstantWorkloadValidate ( const TensorInfo & output )

Definition at line 18 of file ClConstantWorkload.cpp.

Referenced by ClLayerSupport::IsConstantSupported().

 {
     const arm_compute::TensorInfo neonOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     std::array<arm_compute::DataType,8> supportedTypes = {
             arm_compute::DataType::F16,
             arm_compute::DataType::F32,
             arm_compute::DataType::QASYMM8,
             arm_compute::DataType::QASYMM8_SIGNED,
             arm_compute::DataType::QSYMM16,
             arm_compute::DataType::QSYMM8,
             arm_compute::DataType::QSYMM8_PER_CHANNEL,
             arm_compute::DataType::S32
     };
     auto it = std::find(begin(supportedTypes), end(supportedTypes), neonOutputInfo.data_type());
 
     if (it != end(supportedTypes))
     {
         return arm_compute::Status{};
     }
     else
     {
         return arm_compute::Status{arm_compute::ErrorCode::RUNTIME_ERROR, "Unsupported DataType"};
     }
 }

◆ ClConvertFp16ToFp32WorkloadValidate()

arm_compute::Status ClConvertFp16ToFp32WorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 35 of file ClConvertFp16ToFp32Workload.cpp.

References Float16, Float32, and TensorInfo::GetDataType().

Referenced by ClLayerSupport::IsConvertFp16ToFp32Supported().

 {
     if (input.GetDataType() != DataType::Float16)
     {
         return arm_compute::Status(arm_compute::ErrorCode::RUNTIME_ERROR, "Input should be Float16");
     }
     if (output.GetDataType() != DataType::Float32)
     {
         return arm_compute::Status(arm_compute::ErrorCode::RUNTIME_ERROR, "Output should be Float32");
     }
 
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     const arm_compute::Status aclStatus = arm_compute::CLDepthConvertLayer::validate(
         &aclInputInfo, &aclOutputInfo, g_AclConvertPolicy, 0);
 
     return aclStatus;
 }

◆ ClConvertFp32ToFp16WorkloadValidate()

arm_compute::Status ClConvertFp32ToFp16WorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 35 of file ClConvertFp32ToFp16Workload.cpp.

References Float16, Float32, and TensorInfo::GetDataType().

Referenced by ClLayerSupport::IsConvertFp32ToFp16Supported().

 {
     if (input.GetDataType() != DataType::Float32)
     {
         return arm_compute::Status(arm_compute::ErrorCode::RUNTIME_ERROR, "Input should be Float32");
     }
     if (output.GetDataType() != DataType::Float16)
     {
         return arm_compute::Status(arm_compute::ErrorCode::RUNTIME_ERROR, "Output should be Float16");
     }
 
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     const arm_compute::Status aclStatus = arm_compute::CLDepthConvertLayer::validate(
         &aclInputInfo, &aclOutputInfo, g_AclConvertPolicy, 0);
 
     return aclStatus;
 }

◆ ClConvolution2dWorkloadValidate()

arm_compute::Status ClConvolution2dWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const Convolution2dDescriptor &	descriptor,
		const TensorInfo &	weights,
		const Optional< TensorInfo > &	biases
	)

Definition at line 23 of file ClConvolution2dWorkload.cpp.

Referenced by ClLayerSupport::IsConvolution2dSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclWeightsInfo = BuildArmComputeTensorInfo(weights, descriptor.m_DataLayout);
 
     const arm_compute::Size2D aclDilationInfo = BuildArmComputeSize2D(descriptor.m_DilationX,
                                                                       descriptor.m_DilationY);
 
     arm_compute::TensorInfo aclBiasesInfo;
     arm_compute::TensorInfo *optionalAclBiasesInfo = nullptr;
 
     if (descriptor.m_BiasEnabled)
     {
         ARMNN_ASSERT(biases.has_value());
 
         aclBiasesInfo = BuildArmComputeTensorInfo(biases.value(), descriptor.m_DataLayout);
         optionalAclBiasesInfo = &aclBiasesInfo;
     }
 
     arm_compute::PadStrideInfo layerInfo = BuildArmComputePadStrideInfo(descriptor);
 
     return arm_compute::CLConvolutionLayer::validate(&aclInputInfo,
                                                      &aclWeightsInfo,
                                                      optionalAclBiasesInfo,
                                                      &aclOutputInfo,
                                                      layerInfo,
                                                      arm_compute::WeightsInfo(),
                                                      aclDilationInfo);
 }

◆ ClDepthToSpaceWorkloadValidate()

arm_compute::Status ClDepthToSpaceWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const DepthToSpaceDescriptor &	desc
	)

Definition at line 22 of file ClDepthToSpaceWorkload.cpp.

References SpaceToDepthDescriptor::m_DataLayout.

Referenced by ClLayerSupport::IsDepthToSpaceSupported().

 {
     DataLayout dataLayout = desc.m_DataLayout;
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, dataLayout);
 
     int32_t blockSize = boost::numeric_cast<int32_t>(desc.m_BlockSize);
 
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, dataLayout);
 
     const arm_compute::Status aclStatus = arm_compute::CLDepthToSpaceLayer::validate(&aclInputInfo,
                                                                                      &aclOutputInfo,
                                                                                      blockSize);
     return aclStatus;
 }

◆ ClDepthwiseConvolutionWorkloadValidate()

arm_compute::Status ClDepthwiseConvolutionWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const DepthwiseConvolution2dDescriptor &	descriptor,
		const TensorInfo &	weights,
		const Optional< TensorInfo > &	biases
	)

Definition at line 24 of file ClDepthwiseConvolutionWorkload.cpp.

Referenced by ClLayerSupport::IsDepthwiseConvolutionSupported(), and ClLayerSupport::IsDilatedDepthwiseConvolutionSupported().

 {
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input,  descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     // ArmNN's weight format is [ M, I, H, W ]
     const unsigned int aclDepthMultiplier = weights.GetShape()[0];
 
     // Convert the weight format from ArmNN's [ M, I, H, W ] (does NOT depend on the data layout) to either
     // [ 1, H, W, I * M ] (if NHWC) or [ 1, I * M, H, W ] (if NCHW), as required by the compute library
     TensorInfo weightsPermuted = ConvertWeightTensorInfoFromArmnnToAcl(weights, descriptor.m_DataLayout);
 
     // Convert the weights into the compute library format
     const arm_compute::TensorInfo aclWeightsInfo = BuildArmComputeTensorInfo(weightsPermuted, descriptor.m_DataLayout);
 
     arm_compute::TensorInfo aclBiasesInfo;
     arm_compute::TensorInfo *optionalAclBiasesInfo = nullptr;
 
     if (descriptor.m_BiasEnabled)
     {
         ARMNN_ASSERT(biases.has_value());
 
         aclBiasesInfo = BuildArmComputeTensorInfo(biases.value(), descriptor.m_DataLayout);
         optionalAclBiasesInfo = &aclBiasesInfo;
     }
 
     const arm_compute::PadStrideInfo aclPadStrideInfo = BuildArmComputePadStrideInfo(descriptor);
     const arm_compute::Size2D aclDilationInfo = BuildArmComputeSize2D(
             descriptor.m_DilationX,
             descriptor.m_DilationY);
 
     return arm_compute::CLDepthwiseConvolutionLayer::validate(&aclInputInfo,
                                                               &aclWeightsInfo,
                                                               optionalAclBiasesInfo,
                                                               &aclOutputInfo,
                                                               aclPadStrideInfo,
                                                               aclDepthMultiplier,
                                                               arm_compute::ActivationLayerInfo(),
                                                               aclDilationInfo);
 
 }

◆ ClDequantizeWorkloadValidate()

arm_compute::Status ClDequantizeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 22 of file ClDequantizeWorkload.cpp.

Referenced by ClLayerSupport::IsDequantizeSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLDequantizationLayer::validate(&aclInputInfo, &aclOutputInfo);
 }

◆ ClDivisionWorkloadValidate()

arm_compute::Status ClDivisionWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 15 of file ClDivisionFloatWorkload.cpp.

Referenced by ClLayerSupport::IsDivisionSupported().

 {
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput2 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLArithmeticDivision::validate(&aclInput1, &aclInput2, &aclOutput);
 }

◆ ClExpWorkloadValidate()

arm_compute::Status ClExpWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 20 of file ClExpWorkload.cpp.

Referenced by ClLayerSupport::IsElementwiseUnarySupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLExpLayer::validate(&aclInput, &aclOutput);
 }

◆ ClFloorWorkloadValidate()

arm_compute::Status ClFloorWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 14 of file ClFloorFloatWorkload.cpp.

Referenced by ClLayerSupport::IsFloorSupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLFloor::validate(&aclInput, &aclOutput);
 }

◆ ClFullyConnectedWorkloadValidate()

arm_compute::Status ClFullyConnectedWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const TensorInfo &	weights,
		const TensorInfo &	biases,
		const FullyConnectedDescriptor &	descriptor
	)

Definition at line 19 of file ClFullyConnectedWorkload.cpp.

Referenced by ClLayerSupport::IsFullyConnectedSupported().

 {
     const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output);
     const arm_compute::TensorInfo aclWeights = BuildArmComputeTensorInfo(weights);
 
     arm_compute::TensorInfo aclBiases;
     arm_compute::TensorInfo *optionalAclBiases = nullptr;
     if (descriptor.m_BiasEnabled)
     {
         aclBiases  = BuildArmComputeTensorInfo(biases);
         optionalAclBiases = &aclBiases;
     }
 
     const arm_compute::FullyConnectedLayerInfo fullyConnectedLayerInfo =
         ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor);
 
     return arm_compute::CLFullyConnectedLayer::validate(&aclInput,
                                                         &aclWeights,
                                                         optionalAclBiases,
                                                         &aclOutput,
                                                         fullyConnectedLayerInfo);
 }

◆ ClGatherWorkloadValidate()

arm_compute::Status ClGatherWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	indices,
		const TensorInfo &	output,
		const GatherDescriptor &	descriptor
	)

Definition at line 15 of file ClGatherWorkload.cpp.

Referenced by ClLayerSupport::IsGatherSupported().

 {
     const arm_compute::TensorInfo aclInput   = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclIndices = BuildArmComputeTensorInfo(indices);
     const arm_compute::TensorInfo aclOutput  = BuildArmComputeTensorInfo(output);
 
     int aclAxis = ComputeAclAxis(descriptor.m_Axis, input);
 
     return arm_compute::CLGather::validate(&aclInput, &aclIndices, &aclOutput, aclAxis);
 }

◆ ClInstanceNormalizationWorkloadValidate()

arm_compute::Status ClInstanceNormalizationWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const InstanceNormalizationDescriptor &	descriptor
	)

Definition at line 18 of file ClInstanceNormalizationWorkload.cpp.

Referenced by ClLayerSupport::IsInstanceNormalizationSupported().

 {
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     return arm_compute::CLInstanceNormalizationLayer::validate(&aclInputInfo,
                                                                &aclOutputInfo,
                                                                descriptor.m_Gamma,
                                                                descriptor.m_Beta,
                                                                descriptor.m_Eps);
 }

◆ ClL2NormalizationWorkloadValidate()

arm_compute::Status ClL2NormalizationWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const L2NormalizationDescriptor &	descriptor
	)

Definition at line 17 of file ClL2NormalizationFloatWorkload.cpp.

Referenced by ClLayerSupport::IsL2NormalizationSupported().

 {
     const arm_compute::TensorInfo aclInput  = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     int axis = (descriptor.m_DataLayout == DataLayout::NCHW) ? 2 : 0;
 
     return arm_compute::CLL2NormalizeLayer::validate(&aclInput, &aclOutput, axis, descriptor.m_Eps);
 }

◆ ClLogSoftmaxWorkloadValidate()

arm_compute::Status ClLogSoftmaxWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const LogSoftmaxDescriptor &	descriptor
	)

Definition at line 17 of file ClLogSoftmaxWorkload.cpp.

Referenced by ClLayerSupport::IsLogSoftmaxSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     int aclAxis_int = ComputeAclAxis(descriptor.m_Axis, input);
     unsigned int aclAxis = ComputePositiveAxis(aclAxis_int, input);
     return arm_compute::CLLogSoftmaxLayer::validate(&aclInputInfo, &aclOutputInfo, descriptor.m_Beta, aclAxis);
 }

◆ ClLstmFloatWorkloadValidate()

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
	)

Definition at line 256 of file ClLstmFloatWorkload.cpp.

Referenced by ClLayerSupport::IsLstmSupported().

 {
     arm_compute::LSTMParams<arm_compute::ITensorInfo> lstm_params_info;
 
     // The inputs and the outputs
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputStateInInfo = BuildArmComputeTensorInfo(outputStateIn);
     const arm_compute::TensorInfo aclCellStateInInfo = BuildArmComputeTensorInfo(cellStateIn);
     const arm_compute::TensorInfo aclScratchBufferInfo = BuildArmComputeTensorInfo(scratchBuffer);
     const arm_compute::TensorInfo aclOutputStateOutInfo = BuildArmComputeTensorInfo(outputStateOut);
     const arm_compute::TensorInfo aclCellStateOutInfo = BuildArmComputeTensorInfo(cellStateOut);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     // Basic parameters
     const arm_compute::TensorInfo aclInputToForgetWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToForgetWeights());
     const arm_compute::TensorInfo aclInputToCellWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToCellWeights());
     const arm_compute::TensorInfo aclInputToOutputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToOutputWeights());
     const arm_compute::TensorInfo aclRecurrentToForgetWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToForgetWeights());
     const arm_compute::TensorInfo aclRecurrentToCellWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToCellWeights());
     const arm_compute::TensorInfo aclRecurrentToOutputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToOutputWeights());
     const arm_compute::TensorInfo aclForgetGateBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetForgetGateBias());
     const arm_compute::TensorInfo aclCellBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellBias());
     const arm_compute::TensorInfo aclOutputGateBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetOutputGateBias());
 
     arm_compute::TensorInfo aclInputToInputWeightsInfo;
     arm_compute::TensorInfo aclRecurrentToInputWeightsInfo;
     arm_compute::TensorInfo aclCellToInputWeightsInfo;
     arm_compute::TensorInfo aclInputGateBiasInfo;
     arm_compute::TensorInfo aclProjectionWeightsInfo;
     arm_compute::TensorInfo aclProjectionBiasInfo;
     arm_compute::TensorInfo aclCellToForgetWeightsInfo;
     arm_compute::TensorInfo aclCellToOutputWeightsInfo;
     arm_compute::TensorInfo aclInputLayerNormWeightsInfo;
     arm_compute::TensorInfo aclForgetLayerNormWeightsInfo;
     arm_compute::TensorInfo aclCellLayerNormWeightsInfo;
     arm_compute::TensorInfo aclOutputLayerNormWeightsInfo;
 
     if (!descriptor.m_CifgEnabled)
     {
         aclInputToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputToInputWeights());
         aclRecurrentToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToInputWeights());
 
         if (paramsInfo.m_CellToInputWeights != nullptr)
         {
             aclCellToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToInputWeights());
         }
         aclInputGateBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputGateBias());
         lstm_params_info.set_cifg_params(&aclInputToInputWeightsInfo, &aclRecurrentToInputWeightsInfo,
                                          paramsInfo.m_CellToInputWeights != nullptr ?
                                          &aclCellToInputWeightsInfo: nullptr,
                                          &aclInputGateBiasInfo);
     }
 
     if (descriptor.m_ProjectionEnabled)
     {
         aclProjectionWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetProjectionWeights());
 
         if (paramsInfo.m_ProjectionBias != nullptr)
         {
             aclProjectionBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputGateBias());
         }
         lstm_params_info.set_projection_params(&aclProjectionWeightsInfo,
                                                paramsInfo.m_ProjectionBias != nullptr ?
                                                &aclProjectionBiasInfo: nullptr);
     }
 
     if (descriptor.m_PeepholeEnabled)
     {
         aclCellToForgetWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToForgetWeights());
         aclCellToOutputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToOutputWeights());
         lstm_params_info.set_peephole_params(&aclCellToForgetWeightsInfo, &aclCellToOutputWeightsInfo);
     }
 
     float cell_threshold = descriptor.m_ClippingThresCell;
     float projection_threshold = descriptor.m_ClippingThresProj;
 
     // for preparing the object for the class ActivationLayerInfo, we need to consider 5 situations
     arm_compute::ActivationLayerInfo activationLayerInfo;
     if (descriptor.m_ActivationFunc == 0)
     {
         // no activation, do nothing
     }
     else if (descriptor.m_ActivationFunc == 1)
     {
         activationLayerInfo = arm_compute::ActivationLayerInfo(
                 arm_compute::ActivationLayerInfo::ActivationFunction::RELU);
     }
     else if (descriptor.m_ActivationFunc == 3)
     {
         activationLayerInfo = arm_compute::ActivationLayerInfo(
                 arm_compute::ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.0);
     }
     else if (descriptor.m_ActivationFunc == 4)
     {
         activationLayerInfo =  arm_compute::ActivationLayerInfo(
                 arm_compute::ActivationLayerInfo::ActivationFunction::TANH, 1.0, 1.0);
     }
     else if (descriptor.m_ActivationFunc == 6)
     {
         activationLayerInfo =  arm_compute::ActivationLayerInfo(
                 arm_compute::ActivationLayerInfo::ActivationFunction::LOGISTIC);
     }
     else
     {
         throw armnn::Exception("Wrong Type of Activation Function!");
     }
 
     if (descriptor.m_LayerNormEnabled)
     {
         if (!descriptor.m_CifgEnabled)
         {
             aclInputLayerNormWeightsInfo  = BuildArmComputeTensorInfo(paramsInfo.GetInputLayerNormWeights());
         }
 
         aclForgetLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetForgetLayerNormWeights());
 
         aclCellLayerNormWeightsInfo   = BuildArmComputeTensorInfo(paramsInfo.GetCellLayerNormWeights());
 
         aclOutputLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetOutputLayerNormWeights());
 
         lstm_params_info.set_layer_normalization_params(descriptor.m_CifgEnabled ?
                                                         nullptr : &aclInputLayerNormWeightsInfo,
                                                         &aclForgetLayerNormWeightsInfo,
                                                         &aclCellLayerNormWeightsInfo,
                                                         &aclOutputLayerNormWeightsInfo);
     }
 
     return arm_compute::CLLSTMLayer::validate(&aclInputInfo, &aclInputToForgetWeightsInfo,
                                               &aclInputToCellWeightsInfo,
                                               &aclInputToOutputWeightsInfo,
                                               &aclRecurrentToForgetWeightsInfo,
                                               &aclRecurrentToCellWeightsInfo,
                                               &aclRecurrentToOutputWeightsInfo,
                                               &aclForgetGateBiasInfo,
                                               &aclCellBiasInfo,
                                               &aclOutputGateBiasInfo,
                                               &aclOutputStateInInfo, &aclCellStateInInfo,
                                               &aclScratchBufferInfo, &aclOutputStateOutInfo,
                                               &aclCellStateOutInfo, &aclOutputInfo,
                                               lstm_params_info, activationLayerInfo,
                                               cell_threshold, projection_threshold);
 }

◆ ClMaximumWorkloadValidate()

arm_compute::Status ClMaximumWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 24 of file ClMaximumWorkload.cpp.

Referenced by ClLayerSupport::IsMaximumSupported().

 {
     const arm_compute::TensorInfo aclInput0Info = BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1Info = BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     const arm_compute::Status aclStatus = arm_compute::CLElementwiseMax::validate(&aclInput0Info,
                                                                                   &aclInput1Info,
                                                                                   &aclOutputInfo);
 
     return aclStatus;
 }

◆ ClMeanValidate()

arm_compute::Status ClMeanValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const MeanDescriptor &	desc
	)

Definition at line 17 of file ClMeanWorkload.cpp.

Referenced by ClLayerSupport::IsMeanSupported().

 {
     const arm_compute::TensorInfo aclInputInfo  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     arm_compute::Coordinates coords = BuildArmComputeReductionCoordinates(aclInputInfo.num_dimensions(),
                                                                           input.GetNumDimensions(),
                                                                           desc.m_Axis);
 
     return arm_compute::CLReduceMean::validate(&aclInputInfo, coords, desc.m_KeepDims, &aclOutputInfo);
 }

◆ ClMinimumWorkloadValidate()

arm_compute::Status ClMinimumWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 24 of file ClMinimumWorkload.cpp.

Referenced by ClLayerSupport::IsMinimumSupported().

 {
     const arm_compute::TensorInfo aclInput0Info = BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1Info = BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     const arm_compute::Status aclStatus = arm_compute::CLElementwiseMin::validate(&aclInput0Info,
                                                                                   &aclInput1Info,
                                                                                   &aclOutputInfo);
 
     return aclStatus;
 }

◆ ClMultiplicationWorkloadValidate()

arm_compute::Status ClMultiplicationWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 14 of file ClMultiplicationWorkload.cpp.

Referenced by ClLayerSupport::IsMultiplicationSupported().

 {
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput2 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     // At the time of writing, configure() will fail if a rounding policy other than TO_ZERO is supplied to it,
     // when providing a scale of 1.0 for F32 tensors, even though the provided rounding policy appears to be
     // ignored for F32 tensors.
     return arm_compute::CLPixelWiseMultiplication::validate(&aclInput1,
                                                             &aclInput2,
                                                             &aclOutput,
                                                             1.0f,
                                                             arm_compute::ConvertPolicy::SATURATE,
                                                             arm_compute::RoundingPolicy::TO_ZERO);
 }

◆ ClNegWorkloadValidate()

arm_compute::Status ClNegWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 20 of file ClNegWorkload.cpp.

Referenced by ClLayerSupport::IsElementwiseUnarySupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLNegLayer::validate(&aclInput, &aclOutput);
 }

◆ ClNormalizationWorkloadValidate()

arm_compute::Status ClNormalizationWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const NormalizationDescriptor &	descriptor
	)

Definition at line 19 of file ClNormalizationFloatWorkload.cpp.

Referenced by ClLayerSupport::IsNormalizationSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     arm_compute::NormalizationLayerInfo layerInfo = BuildArmComputeNormalizationLayerInfo(descriptor);
 
     return arm_compute::CLNormalizationLayer::validate(&aclInputInfo, &aclOutputInfo, layerInfo);
 }

◆ ClPadValidate()

arm_compute::Status ClPadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const PadDescriptor &	descriptor
	)

Definition at line 45 of file ClPadWorkload.cpp.

Referenced by ClLayerSupport::IsPadSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     std::vector<std::pair<unsigned int, unsigned int>> reversed_PadList(descriptor.m_PadList.size());
 
     std::reverse_copy(std::begin(descriptor.m_PadList),
                       std::end(descriptor.m_PadList),
                       std::begin(reversed_PadList));
 
     arm_compute::PaddingList padList = static_cast<arm_compute::PaddingList>(reversed_PadList);
 
     const arm_compute::Status aclStatus = arm_compute::CLPadLayer::validate(&aclInputInfo,
                                                                             &aclOutputInfo,
                                                                             padList);
 
     return aclStatus;
 }

◆ ClPermuteWorkloadValidate()

arm_compute::Status ClPermuteWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const PermuteDescriptor &	descriptor
	)

Definition at line 17 of file ClPermuteWorkload.cpp.

Referenced by ClLayerSupport::IsPermuteSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
     const armnn::PermutationVector& mappings = descriptor.m_DimMappings;
 
     return arm_compute::CLPermute::validate(&aclInputInfo, &aclOutputInfo,
                                             armcomputetensorutils::BuildArmComputePermutationVector(mappings));
 }

◆ ClPooling2dWorkloadValidate()

arm_compute::Status ClPooling2dWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const Pooling2dDescriptor &	descriptor
	)

Definition at line 18 of file ClPooling2dWorkload.cpp.

Referenced by ClLayerSupport::IsPooling2dSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     arm_compute::PoolingLayerInfo layerInfo = BuildArmComputePoolingLayerInfo(descriptor);
 
     return arm_compute::CLPoolingLayer::validate(&aclInputInfo, &aclOutputInfo, layerInfo);
 }

◆ ClPreluWorkloadValidate()

arm_compute::Status ClPreluWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	alpha,
		const TensorInfo &	output
	)

Definition at line 16 of file ClPreluWorkload.cpp.

Referenced by ClLayerSupport::IsPreluSupported().

 {
     const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclAlpha = armcomputetensorutils::BuildArmComputeTensorInfo(alpha);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLPReluLayer::validate(&aclInput,
                                                &aclAlpha,
                                                &aclOutput);
 }

◆ ClQLstmWorkloadValidate()

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
	)

Definition at line 230 of file ClQLstmWorkload.cpp.

Referenced by ClLayerSupport::IsQLstmSupported().

 {
     arm_compute::LSTMParams<arm_compute::ITensorInfo> aclParamsInfo;
 
     // The inputs and outputs
     const arm_compute::TensorInfo aclInputInfo         = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputStateInInfo = BuildArmComputeTensorInfo(outputStateIn);
     const arm_compute::TensorInfo aclCellStateInInfo   = BuildArmComputeTensorInfo(cellStateIn);
 
     const arm_compute::TensorInfo aclOutputStateOutInfo = BuildArmComputeTensorInfo(outputStateOut);
     const arm_compute::TensorInfo aclCellStateOutInfo   = BuildArmComputeTensorInfo(cellStateOut);
     const arm_compute::TensorInfo aclOutputInfo         = BuildArmComputeTensorInfo(output);
 
     // Mandatory tensor info
     const arm_compute::TensorInfo aclInputToForgetWeightsInfo
         = BuildArmComputeTensorInfo(paramsInfo.GetInputToForgetWeights());
     const arm_compute::TensorInfo aclInputToCellWeightsInfo
         = BuildArmComputeTensorInfo(paramsInfo.GetInputToCellWeights());
     const arm_compute::TensorInfo aclInputToOutputWeightsInfo
         = BuildArmComputeTensorInfo(paramsInfo.GetInputToOutputWeights());
     const arm_compute::TensorInfo aclRecurrentToForgetWeightsInfo
         = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToForgetWeights());
     const arm_compute::TensorInfo aclRecurrentToCellWeightsInfo
         = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToCellWeights());
     const arm_compute::TensorInfo aclRecurrentToOutputWeightsInfo
         = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToOutputWeights());
     const arm_compute::TensorInfo aclForgetGateBiasInfo
         = BuildArmComputeTensorInfo(paramsInfo.GetForgetGateBias());
     const arm_compute::TensorInfo aclCellBiasInfo
         = BuildArmComputeTensorInfo(paramsInfo.GetCellBias());
     const arm_compute::TensorInfo aclOutputGateBiasInfo
         = BuildArmComputeTensorInfo(paramsInfo.GetOutputGateBias());
 
     // Optional tensor info
     arm_compute::TensorInfo aclInputToInputWeightsInfo;
     arm_compute::TensorInfo aclRecurrentToInputWeightsInfo;
     arm_compute::TensorInfo aclCellToInputWeightsInfo;
     arm_compute::TensorInfo aclCellToForgetWeightsInfo;
     arm_compute::TensorInfo aclCellToOutputWeightsInfo;
     arm_compute::TensorInfo aclInputGateBiasInfo;
     arm_compute::TensorInfo aclProjectionWeightsInfo;
     arm_compute::TensorInfo aclProjectionBiasInfo;
     arm_compute::TensorInfo aclInputLayerNormWeightsInfo;
     arm_compute::TensorInfo aclForgetLayerNormWeightsInfo;
     arm_compute::TensorInfo aclCellLayerNormWeightsInfo;
     arm_compute::TensorInfo aclOutputLayerNormWeightsInfo;
 
 
     if (descriptor.m_PeepholeEnabled)
     {
         if (!descriptor.m_CifgEnabled)
         {
             aclCellToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToInputWeights());
         }
 
         aclCellToForgetWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToForgetWeights());
         aclCellToOutputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToOutputWeights());
 
         aclParamsInfo.set_peephole_params(&aclCellToForgetWeightsInfo,
                                           &aclCellToOutputWeightsInfo);
     }
 
     if (descriptor.m_ProjectionEnabled)
     {
         aclProjectionWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetProjectionWeights());
 
         if (paramsInfo.m_ProjectionBias != nullptr)
         {
             aclProjectionBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetProjectionBias());
         }
 
         aclParamsInfo.set_projection_params(
             &aclProjectionWeightsInfo,
             paramsInfo.m_ProjectionBias != nullptr ? &aclProjectionBiasInfo : nullptr);
     }
 
     if (descriptor.m_LayerNormEnabled)
     {
         if (!descriptor.m_CifgEnabled)
         {
             aclInputLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputLayerNormWeights());
         }
 
         aclForgetLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetForgetLayerNormWeights());
         aclCellLayerNormWeightsInfo   = BuildArmComputeTensorInfo(paramsInfo.GetCellLayerNormWeights());
         aclOutputLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetOutputLayerNormWeights());
 
         aclParamsInfo.set_layer_normalization_params(
             paramsInfo.m_InputLayerNormWeights != nullptr ? &aclInputLayerNormWeightsInfo : nullptr,
             &aclForgetLayerNormWeightsInfo,
             &aclCellLayerNormWeightsInfo,
             &aclOutputLayerNormWeightsInfo);
     }
 
     if (!descriptor.m_CifgEnabled)
     {
         aclInputToInputWeightsInfo     = BuildArmComputeTensorInfo(paramsInfo.GetInputToInputWeights());
         aclRecurrentToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToInputWeights());
         aclInputGateBiasInfo           = BuildArmComputeTensorInfo(paramsInfo.GetInputGateBias());
 
 
         aclParamsInfo.set_cifg_params(
             &aclInputToInputWeightsInfo,
             &aclRecurrentToInputWeightsInfo,
             paramsInfo.m_CellToInputWeights      != nullptr ? &aclCellToInputWeightsInfo      : nullptr,
             &aclInputGateBiasInfo);
     }
 
     aclParamsInfo.set_cell_clip_params(descriptor.m_CellClip);
     aclParamsInfo.set_projection_clip_params(descriptor.m_ProjectionClip);
     aclParamsInfo.set_hidden_state_params(descriptor.m_HiddenStateZeroPoint, descriptor.m_HiddenStateScale);
     aclParamsInfo.set_matmul_scale_params(descriptor.m_InputIntermediateScale,
                                           descriptor.m_ForgetIntermediateScale,
                                           descriptor.m_CellIntermediateScale,
                                           descriptor.m_OutputIntermediateScale);
 
     return arm_compute::CLQLSTMLayer::validate(&aclInputInfo,
                                                &aclInputToForgetWeightsInfo,
                                                &aclInputToCellWeightsInfo,
                                                &aclInputToOutputWeightsInfo,
                                                &aclRecurrentToForgetWeightsInfo,
                                                &aclRecurrentToCellWeightsInfo,
                                                &aclRecurrentToOutputWeightsInfo,
                                                &aclForgetGateBiasInfo,
                                                &aclCellBiasInfo,
                                                &aclOutputGateBiasInfo,
                                                &aclCellStateInInfo,
                                                &aclOutputStateInInfo,
                                                &aclCellStateOutInfo,
                                                &aclOutputStateOutInfo,
                                                &aclOutputInfo,
                                                aclParamsInfo);
 }

◆ ClQuantizedLstmWorkloadValidate()

arm_compute::Status ClQuantizedLstmWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	previousCellStateIn,
		const TensorInfo &	previousOutputIn,
		const TensorInfo &	cellStateOut,
		const TensorInfo &	output,
		const QuantizedLstmInputParamsInfo &	paramsInfo
	)

Definition at line 18 of file ClQuantizedLstmWorkload.cpp.

Referenced by ClLayerSupport::IsQuantizedLstmSupported().

 {
     // Inputs
     const arm_compute::TensorInfo aclInputInfo               = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclPreviousCellStateInInfo = BuildArmComputeTensorInfo(previousCellStateIn);
     const arm_compute::TensorInfo aclPreviousOutputInInfo    = BuildArmComputeTensorInfo(previousOutputIn);
 
     // Outputs
     const arm_compute::TensorInfo aclCellStateOutInfo        = BuildArmComputeTensorInfo(cellStateOut);
     const arm_compute::TensorInfo aclOutputInfo              = BuildArmComputeTensorInfo(output);
 
     // Basic parameters
     const arm_compute::TensorInfo aclInputToInputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToInputWeights());
     const arm_compute::TensorInfo aclInputToForgetWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToForgetWeights());
     const arm_compute::TensorInfo aclInputToCellWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToCellWeights());
     const arm_compute::TensorInfo aclInputToOutputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToOutputWeights());
     const arm_compute::TensorInfo aclRecurrentToInputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToInputWeights());
     const arm_compute::TensorInfo aclRecurrentToForgetWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToForgetWeights());
     const arm_compute::TensorInfo aclRecurrentToCellWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToCellWeights());
     const arm_compute::TensorInfo aclRecurrentToOutputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToOutputWeights());
     const arm_compute::TensorInfo aclInputGateBiasInfo  = BuildArmComputeTensorInfo(paramsInfo.GetInputGateBias());
     const arm_compute::TensorInfo aclForgetGateBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetForgetGateBias());
     const arm_compute::TensorInfo aclCellBiasInfo       = BuildArmComputeTensorInfo(paramsInfo.GetCellBias());
     const arm_compute::TensorInfo aclOutputGateBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetOutputGateBias());
 
     return arm_compute::CLLSTMLayerQuantized::validate(&aclInputInfo, &aclInputToInputWeightsInfo,
                                                        &aclInputToForgetWeightsInfo, &aclInputToCellWeightsInfo,
                                                        &aclInputToOutputWeightsInfo, &aclRecurrentToInputWeightsInfo,
                                                        &aclRecurrentToForgetWeightsInfo, &aclRecurrentToCellWeightsInfo,
                                                        &aclRecurrentToOutputWeightsInfo, &aclInputGateBiasInfo,
                                                        &aclForgetGateBiasInfo, &aclCellBiasInfo, &aclOutputGateBiasInfo,
                                                        &aclPreviousCellStateInInfo, &aclPreviousOutputInInfo,
                                                        &aclCellStateOutInfo, &aclOutputInfo);
 }

◆ ClQuantizeWorkloadValidate()

arm_compute::Status ClQuantizeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 22 of file ClQuantizeWorkload.cpp.

Referenced by ClLayerSupport::IsQuantizeSupported().

 {
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLQuantizationLayer::validate(&aclInputInfo,
                                                       &aclOutputInfo);
 }

◆ ClReshapeWorkloadValidate()

arm_compute::Status ClReshapeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 15 of file ClReshapeWorkload.cpp.

Referenced by ClLayerSupport::IsReshapeSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLReshapeLayer::validate(&aclInputInfo, &aclOutputInfo);
 }

◆ ClResizeWorkloadValidate()

arm_compute::Status ClResizeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const ResizeDescriptor &	descriptor
	)

Definition at line 22 of file ClResizeWorkload.cpp.

Referenced by ClLayerSupport::IsResizeSupported().

 {
     arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input);
     arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     arm_compute::DataLayout aclDataLayout = ConvertDataLayout(descriptor.m_DataLayout);
     aclInputInfo.set_data_layout(aclDataLayout);
     aclOutputInfo.set_data_layout(aclDataLayout);
 
     arm_compute::InterpolationPolicy aclInterpolationPolicy =
         ConvertResizeMethodToAclInterpolationPolicy(descriptor.m_Method);
 
     arm_compute::SamplingPolicy samplingPolicy = descriptor.m_HalfPixelCenters ? arm_compute::SamplingPolicy::CENTER :
                                                                                  arm_compute::SamplingPolicy::TOP_LEFT;
 
     return arm_compute::CLScale::validate(&aclInputInfo,
                                           &aclOutputInfo,
                                           arm_compute::ScaleKernelInfo(aclInterpolationPolicy,
                                                                        arm_compute::BorderMode::REPLICATE,
                                                                        arm_compute::PixelValue(0.f),
                                                                        samplingPolicy,
                                                                        true,
                                                                        descriptor.m_AlignCorners));
 }

◆ ClRsqrtWorkloadValidate()

arm_compute::Status ClRsqrtWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 20 of file ClRsqrtWorkload.cpp.

Referenced by ClLayerSupport::IsElementwiseUnarySupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::CLRsqrtLayer::validate(&aclInput, &aclOutput);
 }

◆ ClSliceWorkloadValidate()

arm_compute::Status ClSliceWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const SliceDescriptor &	descriptor
	)

Definition at line 20 of file ClSliceWorkload.cpp.

Referenced by ClLayerSupport::IsSliceSupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     arm_compute::Coordinates starts;
     arm_compute::Coordinates ends;
 
     std::tie(starts, ends) = SetClSliceData(descriptor.m_Begin, descriptor.m_Size);
 
     return arm_compute::CLSlice::validate(&aclInput, &aclOutput, starts, ends);
 }

◆ ClSoftmaxWorkloadValidate()

arm_compute::Status ClSoftmaxWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const SoftmaxDescriptor &	descriptor
	)

Definition at line 17 of file ClSoftmaxWorkload.cpp.

Referenced by ClLayerSupport::IsSoftmaxSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     int aclAxis_int = ComputeAclAxis(descriptor.m_Axis, input);
     unsigned int aclAxis = ComputePositiveAxis(aclAxis_int, input);
     return arm_compute::CLSoftmaxLayer::validate(&aclInputInfo, &aclOutputInfo, descriptor.m_Beta, aclAxis);
 }

◆ ClSpaceToBatchNdWorkloadValidate()

arm_compute::Status ClSpaceToBatchNdWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const SpaceToBatchNdDescriptor &	descriptor
	)

Definition at line 22 of file ClSpaceToBatchNdWorkload.cpp.

Referenced by ClLayerSupport::IsSpaceToBatchNdSupported().

 {
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     // ArmNN blockShape is [H, W] Cl asks for W, H
     int32_t blockHeight = boost::numeric_cast<int32_t>(descriptor.m_BlockShape[0]);
     int32_t blockWidth  = boost::numeric_cast<int32_t>(descriptor.m_BlockShape[1]);
 
     arm_compute::Size2D paddingLeftTop = BuildArmComputeSize2D(
         descriptor.m_PadList[1].first, descriptor.m_PadList[0].first);
     arm_compute::Size2D paddingRightBottom  = BuildArmComputeSize2D(
         descriptor.m_PadList[1].second, descriptor.m_PadList[0].second);
 
     return arm_compute::CLSpaceToBatchLayer::validate(&aclInputInfo,
                                                       blockWidth,
                                                       blockHeight,
                                                       paddingLeftTop,
                                                       paddingRightBottom,
                                                       &aclOutputInfo);
 }

◆ ClSpaceToDepthWorkloadValidate()

arm_compute::Status ClSpaceToDepthWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const SpaceToDepthDescriptor &	desc
	)

Definition at line 43 of file ClSpaceToDepthWorkload.cpp.

References SpaceToDepthDescriptor::m_DataLayout.

Referenced by ClLayerSupport::IsSpaceToDepthSupported().

 {
     DataLayout dataLayout = desc.m_DataLayout;
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, dataLayout);
 
     int32_t blockSize = boost::numeric_cast<int32_t>(desc.m_BlockSize);
 
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, dataLayout);
 
     const arm_compute::Status aclStatus = arm_compute::CLSpaceToDepthLayer::validate(&aclInputInfo,
                                                                                      &aclOutputInfo,
                                                                                      blockSize);
     return aclStatus;
 }

◆ ClSplitterWorkloadValidate()

arm_compute::Status ClSplitterWorkloadValidate	(	const TensorInfo &	input,
		const std::vector< std::reference_wrapper< TensorInfo >> &	outputs,
		unsigned int	splitAxis
	)

Definition at line 32 of file ClSplitterWorkload.cpp.

Referenced by ClLayerSupport::IsSplitterSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input);
 
     size_t numOutputs = outputs.size();
 
     std::vector<arm_compute::TensorInfo> aclOutputs;
     aclOutputs.reserve(numOutputs);
 
     std::vector<arm_compute::ITensorInfo*> aclOutputPtr;
     aclOutputPtr.reserve(numOutputs);
 
     for (size_t i = 0u; i < outputs.size(); ++i)
     {
         aclOutputs.emplace_back(BuildArmComputeTensorInfo(outputs[i]));
         aclOutputPtr.emplace_back(&aclOutputs.back());
     }
 
     unsigned int aclAxis = CalcAclAxis(input.GetNumDimensions(), splitAxis);
     return arm_compute::CLSplit::validate(&aclInputInfo, aclOutputPtr, aclAxis);
 }

◆ ClStackWorkloadValidate()

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

Definition at line 30 of file ClStackWorkload.cpp.

Referenced by ClLayerSupport::IsStackSupported().

 {
     std::vector<arm_compute::ITensorInfo*> aclInputPtrs;
     arm_compute::TensorInfo aclInputInfo;
     for (const TensorInfo* input : inputs)
     {
         aclInputInfo = BuildArmComputeTensorInfo(*input);
         aclInputPtrs.emplace_back(&aclInputInfo);
     }
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     int aclAxis = CalcAxis(descriptor.m_Axis, descriptor.m_InputShape.GetNumDimensions());
 
     return arm_compute::CLStackLayer::validate(aclInputPtrs, aclAxis, &aclOutputInfo);
 }

◆ ClStridedSliceWorkloadValidate()

arm_compute::Status ClStridedSliceWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const StridedSliceDescriptor &	descriptor
	)

Definition at line 26 of file ClStridedSliceWorkload.cpp.

Referenced by ClLayerSupport::IsStridedSliceSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     arm_compute::Coordinates starts;
     arm_compute::Coordinates ends;
     arm_compute::Coordinates strides;
 
     std::tie(starts, ends, strides) = SetClStridedSliceData(descriptor.m_Begin, descriptor.m_End, descriptor.m_Stride);
 
     auto numDimensions       = boost::numeric_cast<int>(input.GetNumDimensions());
     int32_t begin_mask       = ConvertMaskToACLFormat(descriptor.m_BeginMask, numDimensions);
     int32_t end_mask         = ConvertMaskToACLFormat(descriptor.m_EndMask, numDimensions);
     int32_t shrink_axis_mask = ConvertMaskToACLFormat(descriptor.m_ShrinkAxisMask, numDimensions);
 
     return arm_compute::CLStridedSlice::validate(&aclInputInfo,
                                         &aclOutputInfo,
                                         starts,
                                         ends,
                                         strides,
                                         begin_mask,
                                         end_mask,
                                         shrink_axis_mask);
 }

◆ ClSubtractionValidate()

arm_compute::Status ClSubtractionValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 38 of file ClSubtractionWorkload.cpp.

Referenced by ClLayerSupport::IsSubtractionSupported().

 {
     const arm_compute::TensorInfo aclInput0Info = BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1Info = BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     const arm_compute::Status aclStatus = arm_compute::CLArithmeticSubtraction::validate(&aclInput0Info,
                                                                                          &aclInput1Info,
                                                                                          &aclOutputInfo,
                                                                                          g_AclConvertPolicy);
 
     return aclStatus;
 }

◆ ClTensorHandleFactoryId()

constexpr const char* armnn::ClTensorHandleFactoryId ( )

Definition at line 15 of file ClTensorHandleFactory.hpp.

Referenced by ClTensorHandleFactory::GetIdStatic().

15 { return "Arm/Cl/TensorHandleFactory"; }

◆ ClTransposeConvolution2dWorkloadValidate()

arm_compute::Status ClTransposeConvolution2dWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const TransposeConvolution2dDescriptor &	descriptor,
		const TensorInfo &	weights,
		const Optional< TensorInfo > &	biases
	)

Definition at line 26 of file ClTransposeConvolution2dWorkload.cpp.

Referenced by ClLayerSupport::IsTransposeConvolution2dSupported().

 {
     arm_compute::TensorInfo aclInputInfo   = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     arm_compute::TensorInfo aclOutputInfo  = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
     arm_compute::TensorInfo aclWeightsInfo = BuildArmComputeTensorInfo(weights, descriptor.m_DataLayout);
 
     arm_compute::TensorInfo aclBiasesInfo;
     arm_compute::TensorInfo *optionalAclBiasesInfo = nullptr;
 
     if (descriptor.m_BiasEnabled)
     {
         ARMNN_ASSERT(biases.has_value());
 
         aclBiasesInfo = BuildArmComputeTensorInfo(biases.value(), descriptor.m_DataLayout);
         optionalAclBiasesInfo = &aclBiasesInfo;
     }
 
     arm_compute::PadStrideInfo padStrideInfo = BuildArmComputePadStrideInfo(descriptor);
 
     return arm_compute::CLDeconvolutionLayer::validate(&aclInputInfo,
                                                        &aclWeightsInfo,
                                                        optionalAclBiasesInfo,
                                                        &aclOutputInfo,
                                                        padStrideInfo);
 }

◆ ClTransposeWorkloadValidate()

arm_compute::Status ClTransposeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const TransposeDescriptor &	descriptor
	)

Definition at line 17 of file ClTransposeWorkload.cpp.

Referenced by ClLayerSupport::IsTransposeSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
     const armnn::PermutationVector& mappings = descriptor.m_DimMappings;
 
     return arm_compute::CLPermute::validate(&aclInputInfo, &aclOutputInfo,
                                             armcomputetensorutils::BuildArmComputeTransposeVector(mappings));
 }

◆ Combine() [1/2]

MemorySourceFlags armnn::Combine	(	Arg	sourceA,
		Arg	sourceB
	)

Definition at line 36 of file MemorySources.hpp.

Referenced by Combine().

 {
     return static_cast<MemorySourceFlags>(sourceA) | static_cast<MemorySourceFlags>(sourceB);
 }

◆ Combine() [2/2]

MemorySourceFlags armnn::Combine	(	Arg	source,
		Args...	rest
	)

Definition at line 42 of file MemorySources.hpp.

References Combine().

 {
     return static_cast<MemorySourceFlags>(source) | Combine(rest...);
 }

◆ CompatibleTypes()

bool armnn::CompatibleTypes ( DataType )

Definition at line 17 of file CompatibleTypes.hpp.

 {
     return false;
 }

◆ CompatibleTypes< BFloat16 >()

bool armnn::CompatibleTypes< BFloat16 > ( DataType dataType )

inline

Definition at line 35 of file CompatibleTypes.hpp.

References BFloat16.

 {
     return dataType == DataType::BFloat16;
 }

◆ CompatibleTypes< float >()

bool armnn::CompatibleTypes< float > ( DataType dataType )

inline

Definition at line 23 of file CompatibleTypes.hpp.

References Float32.

 {
     return dataType == DataType::Float32;
 }

◆ CompatibleTypes< Half >()

bool armnn::CompatibleTypes< Half > ( DataType dataType )

inline

Definition at line 29 of file CompatibleTypes.hpp.

References Float16.

 {
     return dataType == DataType::Float16;
 }

◆ CompatibleTypes< int16_t >()

bool armnn::CompatibleTypes< int16_t > ( DataType dataType )

inline

Definition at line 57 of file CompatibleTypes.hpp.

References QSymmS16.

 {
     return dataType == DataType::QSymmS16;
 }

◆ CompatibleTypes< int32_t >()

bool armnn::CompatibleTypes< int32_t > ( DataType dataType )

inline

Definition at line 63 of file CompatibleTypes.hpp.

References Signed32.

 {
     return dataType == DataType::Signed32;
 }

◆ CompatibleTypes< int8_t >()

bool armnn::CompatibleTypes< int8_t > ( DataType dataType )

inline

Definition at line 47 of file CompatibleTypes.hpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, QAsymmS8, QSymmS8, and QuantizedSymm8PerAxis.

 {
     ARMNN_NO_DEPRECATE_WARN_BEGIN
     return dataType == DataType::QSymmS8
         || dataType == DataType::QuantizedSymm8PerAxis
         || dataType == DataType::QAsymmS8;
     ARMNN_NO_DEPRECATE_WARN_END
 }

◆ CompatibleTypes< uint8_t >()

bool armnn::CompatibleTypes< uint8_t > ( DataType dataType )

inline

Definition at line 41 of file CompatibleTypes.hpp.

References Boolean, and QAsymmU8.

 {
     return dataType == DataType::Boolean || dataType == DataType::QAsymmU8;
 }

◆ CompleteLeakyReluNetwork()

void armnn::CompleteLeakyReluNetwork	(	INetwork *	network,
		IConnectableLayer *	activation,
		IConnectableLayer *	layerUnderTest,
		const TensorInfo &	info
	)

Definition at line 1676 of file QuantizerTest.cpp.

References INetwork::AddOutputLayer(), IOutputSlot::Connect(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), and IOutputSlot::SetTensorInfo().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     // Add the output Layer
     IConnectableLayer* output = network->AddOutputLayer(3);
 
     // Establish connections
     activation->GetOutputSlot(0).Connect(layerUnderTest->GetInputSlot(0));
     layerUnderTest->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     //Set TensorInfo
     layerUnderTest->GetOutputSlot(0).SetTensorInfo(info);
 }

◆ ComputeAclAxis()

int armnn::ComputeAclAxis	(	const int &	armnnAxis,
		const armnn::TensorInfo &	tensor
	)

inline

Function to convert ArmNN axis (left to right) to ACL axis (right to left) ranging from [-rank, rank)

Definition at line 193 of file ArmComputeUtils.hpp.

References ARMNN_ASSERT, and TensorInfo::GetNumDimensions().

Referenced by ClGatherWorkload::ClGatherWorkload(), ClLogSoftmaxWorkload::ClLogSoftmaxWorkload(), ClSoftmaxWorkload::ClSoftmaxWorkload(), NeonGatherWorkload::NeonGatherWorkload(), NeonLogSoftmaxWorkload::NeonLogSoftmaxWorkload(), and NeonSoftmaxWorkload::NeonSoftmaxWorkload().

 {
     int rank = static_cast<int>(tensor.GetNumDimensions());
 
     ARMNN_ASSERT(rank != 0);
     ARMNN_ASSERT((-1 * rank) <= armnnAxis);
     ARMNN_ASSERT(armnnAxis < rank);
 
     int sign = (armnnAxis < 0) ? -1 : 1;
     int aclAxis = sign * rank - 1  - armnnAxis;
 
     return aclAxis;
 }

◆ ComputePositiveAxis()

unsigned int armnn::ComputePositiveAxis	(	const int &	axis,
		const armnn::TensorInfo &	tensor
	)

inline

Function to convert axis to its positive equivalent value.

[-rank, rank) –> [0, rank)

Definition at line 209 of file ArmComputeUtils.hpp.

References ARMNN_ASSERT, and TensorInfo::GetNumDimensions().

Referenced by ClLogSoftmaxWorkload::ClLogSoftmaxWorkload(), ClSoftmaxWorkload::ClSoftmaxWorkload(), NeonLogSoftmaxWorkload::NeonLogSoftmaxWorkload(), and NeonSoftmaxWorkload::NeonSoftmaxWorkload().

 {
     int rank = static_cast<int>(tensor.GetNumDimensions());
 
     ARMNN_ASSERT(rank != 0);
     ARMNN_ASSERT((-1 * rank) <= axis);
     ARMNN_ASSERT(axis < rank);
 
     int positiveAxis = (axis < 0) ? rank + axis : axis;
     return static_cast<unsigned int>(positiveAxis);
 }

◆ ComputeSoftmaxAclAxis()

T armnn::ComputeSoftmaxAclAxis	(	const SoftmaxDescriptor &	softmaxDesc,
		const armnn::TensorInfo &	tensor
	)

inline

Definition at line 154 of file ArmComputeUtils.hpp.

References ARMNN_ASSERT, TensorInfo::GetNumDimensions(), and SoftmaxDescriptor::m_Axis.

 {
     // Detect the Android default value of -1 and return the ACL default value of 0.
     if (softmaxDesc.m_Axis == -1)
     {
         return 0;
     }
 
     unsigned int dim = tensor.GetNumDimensions();
 
     ARMNN_ASSERT(dim != 0);
 
     // Currently ArmNN support axis 1.
     auto aclAxis = (static_cast<T>(dim) - 1);
     aclAxis = aclAxis > 0 ? aclAxis -1 : aclAxis;
 
     return aclAxis;
 }

◆ ComputeSplitAxis()

std::set<unsigned int> armnn::ComputeSplitAxis	(	const armnn::SplitterDescriptor &	desc,
		const TensorShape &	input
	)

inline

Definition at line 173 of file ArmComputeUtils.hpp.

References ViewsDescriptor::GetNumDimensions(), ViewsDescriptor::GetNumViews(), and ViewsDescriptor::GetViewSizes().

Referenced by ClSplitterWorkload::ClSplitterWorkload(), SplitterLayer::CreateWorkload(), ClLayerSupport::IsSplitterSupported(), NeonLayerSupport::IsSplitterSupported(), and NeonSplitterWorkload::NeonSplitterWorkload().

 {
     unsigned int numSplit = desc.GetNumViews();
     unsigned int numDimensions = desc.GetNumDimensions();
     std::set<unsigned int> splitAxis;
 
     for (unsigned int i = 0; i < numSplit; ++i)
     {
         for (unsigned int dimIdx = 0; dimIdx < numDimensions; ++dimIdx)
         {
             if (desc.GetViewSizes(i)[dimIdx] != input[dimIdx])
             {
                 splitAxis.insert(dimIdx);
             }
         }
     }
     return splitAxis;
 }

◆ Concatenate()

void Concatenate ( const ConcatQueueDescriptor & data )

Definition at line 14 of file Concatenate.cpp.

References ARMNN_ASSERT, TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), GetTensorInfo(), QueueDescriptor::m_Inputs, ConcatQueueDescriptor::ViewOrigin::m_Origin, QueueDescriptor::m_Outputs, ConcatQueueDescriptor::m_ViewOrigins, and MaxNumOfTensorDimensions.

Referenced by RefConcatWorkload::Execute().

 {
     const TensorInfo& outputInfo0 = GetTensorInfo(data.m_Outputs[0]);
 
     std::unique_ptr<Encoder<float>> encoderPtr = MakeEncoder<float>(outputInfo0, data.m_Outputs[0]->Map());
     Encoder<float>& encoder = *encoderPtr;
 
     for (unsigned int index = 0 ; index < outputInfo0.GetNumElements(); ++index)
     {
         unsigned int indices[MaxNumOfTensorDimensions] = { 0 };
 
         unsigned int indexRemainder = index;
         unsigned int dimensionStride = outputInfo0.GetNumElements();
 
         for (unsigned int i = 0; i < outputInfo0.GetNumDimensions(); i++)
         {
             dimensionStride /= outputInfo0.GetShape()[i];
             indices[i] = indexRemainder / dimensionStride; // Use integer division to round down.
             indexRemainder -= indices[i] * dimensionStride;
         }
 
         for (unsigned int viewIdx = 0; viewIdx < data.m_ViewOrigins.size(); ++viewIdx)
         {
             ConcatQueueDescriptor::ViewOrigin const& view = data.m_ViewOrigins[viewIdx];
 
             //Split view extents are defined by the size of (the corresponding) input tensor.
             const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[viewIdx]);
             ARMNN_ASSERT(inputInfo.GetNumDimensions() == outputInfo0.GetNumDimensions());
 
             // Check all dimensions to see if this element is inside the given input view.
             bool insideView = true;
             for (unsigned int i = 0; i < inputInfo.GetNumDimensions(); i++)
             {
                 if (indices[i] < view.m_Origin[i])
                 {
                     insideView = false;
                 }
                 if (indices[i] >= view.m_Origin[i] + inputInfo.GetShape()[i])
                 {
                     insideView = false;
                 }
             }
 
             if (insideView)
             {
                 std::unique_ptr<Decoder<float>> decoderPtr =
                     MakeDecoder<float>(inputInfo, data.m_Inputs[viewIdx]->Map());
                 Decoder<float>& decoder = *decoderPtr;
                 unsigned int inIndex = 0;
                 unsigned int dimensionStride = 1;
 
                 for (unsigned int i = inputInfo.GetNumDimensions(); i-- > 0;)
                 {
                     inIndex += dimensionStride * (indices[i] - view.m_Origin[i]);
                     dimensionStride *= inputInfo.GetShape()[i];
                 }
                 decoder += inIndex;
                 encoder.Set(decoder.Get());
 
                 //What should we do if input views overlap on the output tensor?
                 //We could error, take the average, or shm else...
                 //For now just stop after finding first view (input) that matches.
                 break;
             }
         }
         ++encoder;
     }
 }

◆ ConditionalThrow() [1/2]

void armnn::ConditionalThrow	(	bool	condition,
		const std::string &	message
	)

Definition at line 159 of file Exceptions.hpp.

 {
     if (!condition)
     {
         throw ExceptionType(message);
     }
 }

◆ ConditionalThrow() [2/2]

void armnn::ConditionalThrow ( bool condition )

Definition at line 168 of file Exceptions.hpp.

 {
     if (!condition)
     {
         throw ExceptionType();
     }
 }

◆ ConditionalThrowIfNotEqual()

void armnn::ConditionalThrowIfNotEqual	(	const std::string &	message,
		const ComparedType &	leftHandSide,
		const ComparedType &	rightHandSide
	)

ComparedType must support: operator==(const ComparedType&) operator<<(ostream&, const ComparedType&)

Definition at line 183 of file Exceptions.hpp.

 {
     if (!(leftHandSide == rightHandSide))
     {
         std::stringstream ss;
         ss << message << " : " << leftHandSide << " != " << rightHandSide;
         throw ExceptionType(ss.str());
     }
 }

◆ ConfigureLogging()

void ConfigureLogging	(	bool	printToStandardOutput,
		bool	printToDebugOutput,
		LogSeverity	severity
	)

Configures the logging behaviour of the ARMNN library.

printToStandardOutput: Set to true if log messages should be printed to the standard output. printToDebugOutput: Set to true if log messages be printed to a platform-specific debug output (where supported). severity: All log messages that are at this severity level or higher will be printed, others will be ignored.

Definition at line 10 of file Utils.cpp.

References SetAllLoggingSinks(), SetLogFilter(), and Trace.

Referenced by ConfigureLoggingTest(), armnn::test::InferenceTestMain(), LogLevelSwapper::LogLevelSwapper(), main(), and LogLevelSwapper::~LogLevelSwapper().

 {
     SetAllLoggingSinks(printToStandardOutput, printToDebugOutput, false);
     SetLogFilter(severity);
 }

◆ ConfigureTuner()

void armnn::ConfigureTuner	(	arm_compute::CLTuner &	tuner,
		TuningLevel	level
	)

Definition at line 131 of file ClBackendContext.cpp.

References Exhaustive, None, Normal, and Rapid.

Referenced by ClBackendContext::ClBackendContext().

 {
     tuner.set_tune_new_kernels(true); // Turn on tuning initially.
 
     switch (level)
     {
         case TuningLevel::Rapid:
             tuner.set_tuner_mode(arm_compute::CLTunerMode::RAPID);
             break;
         case TuningLevel::Normal:
             tuner.set_tuner_mode(arm_compute::CLTunerMode::NORMAL);
             break;
         case TuningLevel::Exhaustive:
             tuner.set_tuner_mode(arm_compute::CLTunerMode::EXHAUSTIVE);
             break;
         case TuningLevel::None:
         default:
             tuner.set_tune_new_kernels(false); // Turn off tuning. Set to "use" only mode.
             break;
     }
 }

◆ ConvertActivationDescriptorToAclActivationLayerInfo()

arm_compute::ActivationLayerInfo armnn::ConvertActivationDescriptorToAclActivationLayerInfo ( const ActivationDescriptor & actDesc )

inline

Definition at line 74 of file ArmComputeUtils.hpp.

References ConvertActivationFunctionToAclActivationFunction(), ActivationDescriptor::m_A, ActivationDescriptor::m_B, and ActivationDescriptor::m_Function.

Referenced by ClActivationWorkload::ClActivationWorkload(), and NeonActivationWorkload::NeonActivationWorkload().

 {
     return arm_compute::ActivationLayerInfo(ConvertActivationFunctionToAclActivationFunction(actDesc.m_Function),
         actDesc.m_A, actDesc.m_B);
 }

◆ ConvertActivationFunctionToAclActivationFunction()

arm_compute::ActivationLayerInfo::ActivationFunction armnn::ConvertActivationFunctionToAclActivationFunction ( ActivationFunction armnnFunction )

inline

Definition at line 50 of file ArmComputeUtils.hpp.

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

Referenced by ConvertActivationDescriptorToAclActivationLayerInfo().

 {
     using AclActivationFunction = arm_compute::ActivationLayerInfo::ActivationFunction;
 
     switch (armnnFunction)
     {
         case ActivationFunction::Linear:        return AclActivationFunction::LINEAR;
         // Arm compute's 'logistic' function is non-parameterized, so it is exactly a sigmoid function.
         case ActivationFunction::Sigmoid:       return AclActivationFunction::LOGISTIC;
         case ActivationFunction::ReLu:          return AclActivationFunction::RELU;
         case ActivationFunction::BoundedReLu:   return AclActivationFunction::LU_BOUNDED_RELU;
         case ActivationFunction::SoftReLu:      return AclActivationFunction::SOFT_RELU;
         case ActivationFunction::LeakyReLu:     return AclActivationFunction::LEAKY_RELU;
         case ActivationFunction::Abs:           return AclActivationFunction::ABS;
         case ActivationFunction::Sqrt:          return AclActivationFunction::SQRT;
         case ActivationFunction::Square:        return AclActivationFunction::SQUARE;
         case ActivationFunction::TanH:          return AclActivationFunction::TANH;
         case ActivationFunction::Elu:           return AclActivationFunction::ELU;
         case ActivationFunction::HardSwish:     return AclActivationFunction::HARD_SWISH;
         default:                                throw InvalidArgumentException("Unsupported activation function");
     }
 }

◆ ConvertBf16ToFp32Weight()

LayerT* armnn::ConvertBf16ToFp32Weight ( Layer * l )

Definition at line 151 of file Network.cpp.

References BFloat16, FloatingPointConverter::ConvertBFloat16ToFloat32(), Convolution2d, Float32, FullyConnected, TensorInfo::GetDataType(), TensorInfo::GetNumElements(), TensorInfo::GetShape(), and info.

 {
     LayerT* layer = PolymorphicDowncast<LayerT*>(l);
     if ((layer->GetType() == LayerType::Convolution2d || layer->GetType() == LayerType::FullyConnected)
          && layer->m_Weight)
     {
         const TensorInfo& info = layer->m_Weight->GetTensorInfo();
 
         if (info.GetDataType() == DataType::BFloat16)
         {
             std::vector<float> newValues(info.GetNumElements());
 
             armnnUtils::FloatingPointConverter::ConvertBFloat16ToFloat32(
                 layer->m_Weight->template GetTensor<armnn::BFloat16>(), info.GetNumElements(), newValues.data());
 
             TensorInfo newInfo(info.GetShape(), DataType::Float32);
             ConstTensor newInput(newInfo, newValues);
             layer->m_Weight.reset(new ScopedCpuTensorHandle(newInput));
         }
     }
     return layer;
 }

◆ ConvertComparisonOperationToAcl()

arm_compute::ComparisonOperation armnn::ConvertComparisonOperationToAcl ( const ComparisonDescriptor & descriptor )

inline

Definition at line 80 of file ArmComputeUtils.hpp.

References Equal, Greater, GreaterOrEqual, Less, LessOrEqual, ComparisonDescriptor::m_Operation, and NotEqual.

Referenced by ClComparisonWorkload::ClComparisonWorkload(), and NeonComparisonWorkload::NeonComparisonWorkload().

 {
     switch (descriptor.m_Operation)
     {
         case ComparisonOperation::Greater:         return arm_compute::ComparisonOperation::Greater;
         case ComparisonOperation::GreaterOrEqual:  return arm_compute::ComparisonOperation::GreaterEqual;
         case ComparisonOperation::Less:            return arm_compute::ComparisonOperation::Less;
         case ComparisonOperation::LessOrEqual:     return arm_compute::ComparisonOperation::LessEqual;
         case ComparisonOperation::Equal:           return arm_compute::ComparisonOperation::Equal;
         case ComparisonOperation::NotEqual:        return arm_compute::ComparisonOperation::NotEqual;
         default:                                   throw InvalidArgumentException("Unsupported comparison function");
     }
 }

◆ ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo()

arm_compute::FullyConnectedLayerInfo armnn::ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo ( const FullyConnectedDescriptor & fullyConnectedDesc )

inline

Definition at line 133 of file ArmComputeUtils.hpp.

References FullyConnectedDescriptor::m_TransposeWeightMatrix.

 {
     arm_compute::FullyConnectedLayerInfo fc_info;
     fc_info.transpose_weights = fullyConnectedDesc.m_TransposeWeightMatrix;
     return fc_info;
 }

◆ ConvertLogSeverity()

constexpr LogSeverity armnn::ConvertLogSeverity ( BoostLogSeverityMapping severity )

Definition at line 157 of file Logging.hpp.

 {
     return static_cast<LogSeverity>(severity);
 }

◆ ConvertMaskToACLFormat()

int32_t ConvertMaskToACLFormat	(	int32_t	mask,
		int32_t	numDim
	)

Definition at line 194 of file WorkloadUtils.cpp.

Referenced by ClStridedSliceWorkload::ClStridedSliceWorkload(), GatherTensorHandlePairs(), and NeonStridedSliceWorkload::NeonStridedSliceWorkload().

 {
     int32_t reversedMask = 0;
     for (unsigned int i = 0; i < boost::numeric_cast<unsigned int>(numDim); ++i)
     {
         // Check if bit set in mask for each dimension
         int32_t bit = (mask & 1 << i) != 0;
         // Increment the new mask with the bits reversed
         reversedMask += (bit << std::max(numDim-(boost::numeric_cast<int>(i)+1), 0));
     }
 
     return reversedMask;
 }

◆ ConvertNormalizationAlgorithmChannelToAclNormType()

arm_compute::NormType armnn::ConvertNormalizationAlgorithmChannelToAclNormType ( NormalizationAlgorithmChannel channelType )

inline

Definition at line 121 of file ArmComputeUtils.hpp.

References Across, and Within.

 {
     using arm_compute::NormType;
     switch (channelType)
     {
         case NormalizationAlgorithmChannel::Across: return NormType::CROSS_MAP;
         case NormalizationAlgorithmChannel::Within: return NormType::IN_MAP_2D;
         default:    throw InvalidArgumentException("Unsupported normalization algorithm channel type");
     }
 }

◆ ConvertOutputShapeRoundingToAclDimensionRoundingType()

arm_compute::DimensionRoundingType armnn::ConvertOutputShapeRoundingToAclDimensionRoundingType ( OutputShapeRounding rounding )

inline

Definition at line 107 of file ArmComputeUtils.hpp.

References Ceiling, and Floor.

 {
     using arm_compute::DimensionRoundingType;
 
     switch (rounding)
     {
         case OutputShapeRounding::Ceiling:  return DimensionRoundingType::CEIL;
         case OutputShapeRounding::Floor:    return DimensionRoundingType::FLOOR;
         default:                            throw InvalidArgumentException("Unsupported Output Shape Rounding type");
     }
 }

◆ ConvertPoolingAlgorithmToAclPoolingType()

arm_compute::PoolingType armnn::ConvertPoolingAlgorithmToAclPoolingType ( PoolingAlgorithm poolingAlgorithm )

inline

Definition at line 94 of file ArmComputeUtils.hpp.

References Average, L2, and Max.

 {
     using arm_compute::PoolingType;
 
     switch (poolingAlgorithm)
     {
         case PoolingAlgorithm::Max:             return PoolingType::MAX;
         case PoolingAlgorithm::Average:         return PoolingType::AVG;
         case PoolingAlgorithm::L2:              return PoolingType::L2;
         default:                                throw InvalidArgumentException("Unsupported pooling algorithm");
     }
 }

◆ ConvertResizeMethodToAclInterpolationPolicy()

arm_compute::InterpolationPolicy armnn::ConvertResizeMethodToAclInterpolationPolicy ( ResizeMethod resizeMethod )

inline

Definition at line 140 of file ArmComputeUtils.hpp.

References Bilinear, and NearestNeighbor.

 {
     switch (resizeMethod)
     {
         case ResizeMethod::Bilinear:
             return arm_compute::InterpolationPolicy::BILINEAR;
         case ResizeMethod::NearestNeighbor:
             return arm_compute::InterpolationPolicy::NEAREST_NEIGHBOR;
         default:
             throw InvalidArgumentException("Unsupported resize method");
     }
 }

◆ ConvertWeightTensorFromArmnnToAcl()

armnn::ConstTensor ConvertWeightTensorFromArmnnToAcl	(	const ConstCpuTensorHandle *	weightTensor,
		DataLayout	dataLayout,
		void *	permuteBuffer
	)

Definition at line 134 of file WorkloadUtils.cpp.

References ARMNN_ASSERT_MSG, ARMNN_FALLTHROUGH, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, Float16, Float32, BaseTensor< MemoryType >::GetDataType(), BaseTensor< MemoryType >::GetInfo(), TensorInfo::GetShape(), ConstCpuTensorHandle::GetTensorInfo(), NCHW, NHWC, PermuteTensor(), QAsymmS8, QAsymmU8, QSymmS8, QuantizedSymm8PerAxis, and ReshapeWeightsForAcl().

Referenced by ClDepthwiseConvolutionWorkload::ClDepthwiseConvolutionWorkload(), GatherTensorHandlePairs(), and NeonDepthwiseConvolutionWorkload::NeonDepthwiseConvolutionWorkload().

 {
     ARMNN_ASSERT_MSG(weightTensor, "Invalid input tensor");
     ARMNN_ASSERT_MSG(permuteBuffer, "Invalid permute buffer");
 
     auto multiplier    = weightTensor->GetTensorInfo().GetShape()[0];
     auto inputChannels = weightTensor->GetTensorInfo().GetShape()[1];
 
     // Convert the weight format from ArmNN's [ M, I, H, W ] (does NOT depend on the data layout) to either
     // [ 1, H, W, I * M ] (if NHWC) or [ 1, I * M, H, W ] (if NCHW), as required by the compute library
 
     // 1. Permute the weights if necessary
     // If the data layout is NCHW no permutation is necessary, as a reshape to [ 1, I * M, H, W ] can be better done
     // starting from the current shape of [ M, I, H, W ]
     // If no permutation is necessary, leave the permutation vector empty
     PermutationVector permutationVector{};
     if (dataLayout == DataLayout::NHWC)
     {
         // The data layout is NHWC, then permute the weights from [ M, I, H, W ] to [ H, W, I, M ]
         permutationVector = { 3, 2, 0, 1 };
     }
     ConstTensor weightPermuted = PermuteTensor(weightTensor, permutationVector, permuteBuffer);
 
     // Shuffle the weights data to obtain the channel order needed used by Acl
     if (multiplier > 1 && inputChannels > 1 && dataLayout == DataLayout::NCHW)
     {
         switch (weightPermuted.GetDataType())
         {
             case DataType::Float32:
                 weightPermuted = ReorderWeightChannelsForAcl<float>(weightPermuted, dataLayout, permuteBuffer);
                 break;
             case DataType::Float16:
                 weightPermuted =
                     ReorderWeightChannelsForAcl<half_float::half>(weightPermuted, dataLayout, permuteBuffer);
                 break;
             case DataType::QAsymmS8:
             case DataType::QAsymmU8:
                 weightPermuted = ReorderWeightChannelsForAcl<uint8_t>(weightPermuted, dataLayout, permuteBuffer);
                 break;
             ARMNN_NO_DEPRECATE_WARN_BEGIN
             case DataType::QuantizedSymm8PerAxis:
                 ARMNN_FALLTHROUGH;
             case DataType::QSymmS8:
                 weightPermuted = ReorderWeightChannelsForAcl<int8_t>(weightPermuted, dataLayout, permuteBuffer);
                 break;
             ARMNN_NO_DEPRECATE_WARN_END
             default:
                 break;
         }
     }
 
     // 2. Reshape the weights
     ReshapeWeightsForAcl(weightPermuted.GetInfo(), dataLayout);
 
     // 3. Return both the tensor and the allocated storage to ensure that the data stays alive
     return weightPermuted;
 }

◆ ConvertWeightTensorInfoFromArmnnToAcl()

TensorInfo ConvertWeightTensorInfoFromArmnnToAcl	(	const TensorInfo &	weightInfo,
		DataLayout	dataLayout
	)

Definition at line 111 of file WorkloadUtils.cpp.

References NHWC, armnnUtils::Permuted(), and ReshapeWeightsForAcl().

Referenced by GatherTensorHandlePairs().

 {
     // Convert the weight format from ArmNN's [ M, I, H, W ] (does NOT depend on the data layout) to either
     // [ 1, H, W, I * M ] (if NHWC) or [ 1, I * M, H, W ] (if NCHW), as required by the compute library
 
     // 1. Permute the weights if necessary
     // If the data layout is NCHW no permutation is necessary, as a reshape to [ 1, I * M, H, W ] can be better done
     // starting from the current shape of [ M, I, H, W ]
     TensorInfo weightPermutedInfo(weightInfo);
     if (dataLayout == DataLayout::NHWC)
     {
         // The data layout is NHWC, then permute the weights from [ M, I, H, W ] to [ H, W, I, M ]
         PermutationVector permutationVector{ 3, 2, 0, 1 };
         weightPermutedInfo = armnnUtils::Permuted(weightInfo, permutationVector);
     }
 
     // 2. Reshape the weights
     ReshapeWeightsForAcl(weightPermutedInfo, dataLayout);
 
     // 3. Return the permuted weight info
     return weightPermutedInfo;
 }

◆ Convolve()

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
	)

Definition at line 71 of file ConvImpl.cpp.

References Decoder< IType >::Get(), DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), DataLayoutIndexed::GetIndex(), DataLayoutIndexed::GetWidthIndex(), NHWC, Encoder< IType >::Set(), and BaseIterator::SetIndex().

Referenced by RefDepthwiseConvolution2dWorkload::Execute(), and RefConvolution2dWorkload::Execute().

 {
     if (biasEnabled && !pBiasDecoder)
     {
         throw InvalidArgumentException("Bias is enabled but the bias data is invalid");
     }
     const armnnUtils::DataLayoutIndexed dataLayoutIndexed(dataLayout);
 
     const unsigned int channelsIndex = dataLayoutIndexed.GetChannelsIndex();
     const unsigned int heightIndex   = dataLayoutIndexed.GetHeightIndex();
     const unsigned int widthIndex    = dataLayoutIndexed.GetWidthIndex();
 
     unsigned int depthMultiplier = depthwise ? rFilterShape[0] : 1;
     unsigned int inputChannels   = depthwise ? rFilterShape[1] : rFilterShape[channelsIndex];
     unsigned int outputChannels  = depthwise ? inputChannels * depthMultiplier : rFilterShape[0];
 
     unsigned int batchSize    = rOutputShape[0];
     unsigned int outputHeight = rOutputShape[heightIndex];
     unsigned int outputWidth  = rOutputShape[widthIndex];
     unsigned int inputHeight  = rInputShape[heightIndex];
     unsigned int inputWidth   = rInputShape[widthIndex];
 
     unsigned int filterHeight = depthwise ? rFilterShape[2] : rFilterShape[heightIndex];
     unsigned int filterWidth  = depthwise ? rFilterShape[3] : rFilterShape[widthIndex];
 
     for (unsigned int batchIdx = 0; batchIdx < batchSize; batchIdx++)
     {
         for (unsigned int cOutput = 0; cOutput < outputChannels; cOutput++)
         {
             for (unsigned int yOutput = 0; yOutput < outputHeight; yOutput++)
             {
                 for (unsigned int xOutput = 0; xOutput < outputWidth; xOutput++)
                 {
                     // This loop goes over each output element.
                     float sum =  0.0f;
 
                     // For depthwise, each output channel corresponds to exactly one input channel.
                     // For normal, must loop over each input channel.
                     for (unsigned int cInput = 0; cInput < (depthwise ? 1 : inputChannels); cInput++)
                     {
                         unsigned int depthwiseMultiplierIdx = 0;
                         if (depthwise)
                         {
                             cInput = cOutput / depthMultiplier;
                             depthwiseMultiplierIdx = cOutput % depthMultiplier;
                         }
 
                         for (unsigned int yFilter = 0; yFilter < filterHeight; yFilter++)
                         {
                             for (unsigned int xFilter = 0; xFilter < filterWidth; xFilter++)
                             {
                                 // This loop goes over each input element for each output element.
                                 unsigned int filterIndex = 0;
 
                                 // Since dimensionality of kernel depends on depthwiseness, so does index.
                                 if (depthwise)
                                 {
                                     filterIndex = depthwiseMultiplierIdx * filterWidth * filterHeight * inputChannels +
                                                   cInput * filterWidth * filterHeight +
                                                   yFilter * filterWidth +
                                                   xFilter;
                                 }
                                 else
                                 {
                                     // Keep this implementation, as using DataLayoutIndexed::GetIndex causes great
                                     // performance regression.
                                     if (dataLayout == DataLayout::NHWC)
                                     {
                                         filterIndex = cOutput * filterHeight * filterWidth * inputChannels +
                                                       yFilter * filterWidth * inputChannels +
                                                       xFilter * inputChannels +
                                                       cInput;
                                     }
                                     else
                                     {
                                         filterIndex = cOutput * filterWidth * filterHeight * inputChannels +
                                                       cInput  * filterWidth * filterHeight +
                                                       yFilter * filterWidth +
                                                       xFilter;
                                     }
                                 }
 
                                 rFilterDecoder.SetIndex(filterIndex, cOutput);
                                 float filterValue = rFilterDecoder.Get();
 
                                 unsigned int yInput = yOutput * yStride + yFilter * yDilation;
                                 unsigned int xInput = xOutput * xStride + xFilter * xDilation;
 
                                 float inputValue;
 
                                 // Check if we're in the padding.
                                 if (yInput < paddingTop || yInput >= inputHeight + paddingTop ||
                                     xInput < paddingLeft || xInput >= inputWidth + paddingLeft )
                                 {
                                     inputValue = 0.0f;
                                 }
                                 else
                                 {
                                     unsigned int inputIndex = 0;
 
                                     // Keep this implementation, as using DataLayoutIndexed::GetIndex causes great
                                     // performance regression.
                                     if (dataLayout == DataLayout::NHWC)
                                     {
                                         inputIndex = batchIdx * inputHeight * inputWidth  * inputChannels +
                                                      (yInput - paddingTop) * inputWidth * inputChannels +
                                                      (xInput - paddingLeft) * inputChannels +
                                                      cInput;
                                     }
                                     else
                                     {
                                         inputIndex = batchIdx * inputWidth * inputHeight * inputChannels +
                                                      inputWidth * inputHeight * cInput +
                                                      inputWidth * (yInput - paddingTop) +
                                                      xInput - paddingLeft;
                                     }
 
                                     rInputDecoder[inputIndex];
                                     inputValue = rInputDecoder.Get();
                                 }
 
                                 sum += filterValue * inputValue;
                             }
                         }
                     }
 
                     if (biasEnabled)
                     {
                         (*pBiasDecoder).SetIndex(cOutput, cOutput);
                         sum += pBiasDecoder->Get();
                     }
 
                     unsigned int outIdx = dataLayoutIndexed.GetIndex(rOutputShape, batchIdx, cOutput, yOutput, xOutput);
 
                     rOutputEncoder[outIdx];
                     rOutputEncoder.Set(sum);
                 }
             }
         }
     }
 }

◆ CopyArmComputeClTensorData()

void armnn::CopyArmComputeClTensorData	(	arm_compute::CLTensor &	dstTensor,
		const T *	srcData
	)

Definition at line 30 of file ClWorkloadUtils.hpp.

References ARMNN_SCOPED_PROFILING_EVENT_CL.

Referenced by ClConstantWorkload::Execute().

 {
     {
         ARMNN_SCOPED_PROFILING_EVENT_CL("MapClTensorForWriting");
         dstTensor.map(true);
     }
 
     {
         ARMNN_SCOPED_PROFILING_EVENT_CL("CopyToClTensor");
         armcomputetensorutils::CopyArmComputeITensorData<T>(srcData, dstTensor);
     }
 
     dstTensor.unmap();
 }

◆ CopyArmComputeTensorData()

void armnn::CopyArmComputeTensorData	(	arm_compute::Tensor &	dstTensor,
		const T *	srcData
	)

Definition at line 29 of file NeonWorkloadUtils.hpp.

Referenced by InitializeArmComputeTensorData().

 {
     InitialiseArmComputeTensorEmpty(dstTensor);
     CopyArmComputeITensorData(srcData, dstTensor);
 }

◆ CopyTensorContentsGeneric()

void armnn::CopyTensorContentsGeneric	(	const ITensorHandle *	srcTensor,
		ITensorHandle *	dstTensor,
		CopyFunc	copy
	)

Definition at line 47 of file WorkloadUtils.hpp.

References ARMNN_ASSERT, ARMNN_SCOPED_PROFILING_EVENT, TensorShape::GetNumDimensions(), ITensorHandle::GetShape(), ITensorHandle::GetStrides(), IgnoreUnused(), ITensorHandle::Map(), MaxNumOfTensorDimensions, Undefined, and ITensorHandle::Unmap().

Referenced by NeonConvertBf16ToFp32Workload::Execute(), NeonConvertFp32ToFp16Workload::Execute(), NeonConvertFp32ToBf16Workload::Execute(), NeonConvertFp16ToFp32Workload::Execute(), and CopyMemGenericWorkload::Execute().

 {
     // For ease of understanding, names are assigned to the dimensions
     // of the tensor as if NHWC, however this routine works with any 5D tensor
     static_assert(MaxNumOfTensorDimensions == 5, "Please update CopyTensorContents");
 
     TensorShape srcStrides      = srcTensor->GetStrides();
     const TensorShape& srcShape = srcTensor->GetShape();
     const auto srcSize          = srcTensor->GetStrides()[0] * srcShape[0];
     IgnoreUnused(srcSize);  // Only used for asserts
     TensorShape dstStrides      = dstTensor->GetStrides();
     const TensorShape& dstShape = dstTensor->GetShape();
     const auto dstSize          = dstTensor->GetStrides()[0] * dstShape[0];
     IgnoreUnused(dstSize);  // Only used for asserts
 
     size_t srcDepth    = 1;
     size_t srcBatches  = 1;
     size_t srcHeight   = 1;
     size_t srcWidth    = 1;
     size_t srcChannels = 1;
     AssignValues(srcShape.GetNumDimensions(),
                  0,
                  srcShape,
                  srcChannels,
                  srcWidth,
                  srcHeight,
                  srcBatches,
                  srcDepth);
 
     size_t srcDepthStride   = 0;
     size_t srcBatchStride   = 0;
     size_t srcHeightStride  = 0;
     size_t srcWidthStride   = 0;
     size_t srcChannelStride = 0;
     AssignValues(srcStrides.GetNumDimensions(),
                  0,
                  srcStrides,
                  srcChannelStride,
                  srcWidthStride,
                  srcHeightStride,
                  srcBatchStride,
                  srcDepthStride);
 
     size_t dstDepth    = 1;
     size_t dstBatches  = 1;
     size_t dstHeight   = 1;
     size_t dstWidth    = 1;
     size_t dstChannels = 1;
     AssignValues(dstShape.GetNumDimensions(),
                  0,
                  dstShape,
                  dstChannels,
                  dstWidth,
                  dstHeight,
                  dstBatches,
                  dstDepth);
 
     size_t dstDepthStride   = 0;
     size_t dstBatchStride   = 0;
     size_t dstHeightStride  = 0;
     size_t dstWidthStride   = 0;
     size_t dstChannelStride = 0;
     AssignValues(dstStrides.GetNumDimensions(),
                  0,
                  dstStrides,
                  dstChannelStride,
                  dstWidthStride,
                  dstHeightStride,
                  dstBatchStride,
                  dstDepthStride);
 
     const unsigned char* srcDataStart;
     unsigned char* dstDataStart;
     {
         ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, "Synchronize buffers");
         srcDataStart = static_cast<const uint8_t*>(srcTensor->Map());
         dstDataStart = static_cast<uint8_t*>(dstTensor->Map());
     }
 
     size_t copyLength  = std::min(srcChannels * srcChannelStride, dstChannels * dstChannelStride);
     size_t copyWidth   = std::min(srcWidth, dstWidth);
     size_t copyHeight  = std::min(srcHeight, dstHeight);
     size_t copyBatches = std::min(srcBatches, dstBatches);
     size_t copyDepth   = std::min(srcDepth, dstDepth);
 
     // Coalesce inner dimensions where possible
     // to reduce overheard calling copy() and to
     // allow for memory bandwidth optimisations
     if (copyLength == srcWidthStride &&
         copyLength == dstWidthStride)
     {
         // There is no special padding between rows,
         // and sizes are compatible, so copy whole rows
         copyLength *= copyWidth;
         copyWidth = 1;
 
         if (copyLength == srcHeightStride &&
             copyLength == dstHeightStride)
         {
             // There is no special padding between batches
             // and sizes are compatible so copy whole batches
             copyLength *= copyHeight;
             copyHeight = 1;
         }
     }
 
     const unsigned char* srcData = srcDataStart;
     unsigned char* dstData = dstDataStart;
     for (unsigned int d = 0; d < copyDepth; ++d)
     {
         auto srcPtrDepth = srcData;
         auto dstPtrDepth = dstData;
         for (unsigned int b = 0; b < copyBatches; ++b)
         {
             auto srcPtrBatch = srcData;
             auto dstPtrBatch = dstData;
             for (unsigned int h = 0; h < copyHeight; ++h)
             {
                 auto srcPtrChannel = srcData;
                 auto dstPtrChannel = dstData;
                 for (unsigned int w = 0; w < copyWidth; ++w)
                 {
                     ARMNN_ASSERT(srcData >= srcDataStart && srcData + copyLength <= srcDataStart + srcSize);
                     ARMNN_ASSERT(dstData >= dstDataStart && dstData + copyLength <= dstDataStart + dstSize);
                     copy(dstData, srcData, copyLength);
                     dstData += dstWidthStride;
                     srcData += srcWidthStride;
                 }
                 dstData += (static_cast<long>(dstHeightStride) - (dstData - dstPtrChannel));
                 srcData += (static_cast<long>(srcHeightStride) - (srcData - srcPtrChannel));
             }
             dstData += (static_cast<long>(dstBatchStride) - (dstData - dstPtrBatch));
             srcData += (static_cast<long>(srcBatchStride) - (srcData - srcPtrBatch));
         }
         dstData += (static_cast<long>(dstDepthStride) - (dstData - dstPtrDepth));
         srcData += (static_cast<long>(srcDepthStride) - (srcData - srcPtrDepth));
     }
 
     srcTensor->Unmap();
     dstTensor->Unmap();
 }

◆ CreateAclNormalizationLayerInfoForL2Normalization()

arm_compute::NormalizationLayerInfo armnn::CreateAclNormalizationLayerInfoForL2Normalization	(	const armnn::TensorInfo &	tensorInfo,
		armnn::DataLayout	dataLayout
	)

inline

Definition at line 17 of file ArmComputeUtils.hpp.

References TensorInfo::GetShape(), and NCHW.

 {
     unsigned int depthDimension = dataLayout == armnn::DataLayout::NCHW ? 1 : 3;
     const unsigned int depth = tensorInfo.GetShape()[depthDimension];
 
     // At the time of writing, {CL|Neon}L2Normalization performs the reduction only along dimension 0. This version of
     // L2 Normalization always performs the reduction along the depth axis, though. Thus, we repurpose
     // {CL|Neon}NormalizationLayers to act as depthwise L2 normalizations by carefully chosing the normalization
     // parameters.
     //
     // Please refer to both the reference implementation of the normalization layer and the implementation of
     // {CL|Neon}NormalizationLayer when checking the derivations for the parameter values below.
 
     // Make sure normalization covers the entire depth range. ACL requires the normalization size to be odd.
     // CL: This does not result in extra kernel threads not doing any work: See usage of the RADIUS parameter in
     // ACL's normalization_layer_cross_map() CL function.
     const uint32_t normSize = depth * 2u + 1u;
 
     // See ACL's NormalizationLayerInfo::scale_coeff() definition.
     // For the reference implementation, to make alpha_ become 1, we'd have to use alpha = normSize instead.
     const float alpha = 1.0f;
 
     // Don't offset the reduction.
     const float kappa = 0.0f;
 
     // pow(reduction, -0.5) = 1 / sqrt(reduction)
     const float beta = 0.5f;
 
     return arm_compute::NormalizationLayerInfo(arm_compute::NormType::CROSS_MAP, normSize, alpha, beta, kappa, false);
 }

◆ CreateDescriptorForConcatenation()

OriginsDescriptor armnn::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.

Definition at line 250 of file Descriptors.hpp.

References OriginsDescriptor::SetConcatAxis(), and OriginsDescriptor::SetViewOriginCoord().

Referenced by BOOST_AUTO_TEST_CASE(), ConcatDifferentInputOutputQParamTest(), CreateDescriptorForConcat(), and CreateMergerDescriptorForConcatenation().

 {
     auto numInputs = std::distance(first, last);
 
     if (numInputs < 2)
     {
         throw InvalidArgumentException("Concatenation requires at least 2 inputs");
     }
 
     const auto& firstInputShape = *first;
 
     const unsigned int numDimensions = firstInputShape.GetNumDimensions();
     for (auto it = first + 1; it != last; ++it)
     {
         if (it->GetNumDimensions() != numDimensions)
         {
             throw InvalidArgumentException("All inputs to concatenation must have the same number of dimensions");
         }
     }
 
     if (concatenationDimension >= numDimensions)
     {
         throw InvalidArgumentException("concatenationDimension must be between 0 and the number of dimensions.");
     }
 
     for (auto it = first; it != last; ++it)
     {
         for (unsigned int d = 0; d < numDimensions; ++d)
         {
             const bool dimSizeOk = (d == concatenationDimension) || (firstInputShape[d] == (*it)[d]);
             if (!dimSizeOk)
             {
                 throw InvalidArgumentException("All inputs to concatenation must be the same size along all dimensions "
                     " except the concatenation dimension");
             }
         }
     }
 
     OriginsDescriptor viewsDescriptor(static_cast<uint32_t>(numInputs), numDimensions);
     viewsDescriptor.SetConcatAxis(concatenationDimension);
 
     uint32_t viewIndex = 0u;
     uint32_t coordAlongConcatDim = 0u;
     for (auto it = first; it != last; ++it)
     {
         const auto& inputShape = *it;
 
         for (unsigned int i = 0; i < concatenationDimension; ++i)
         {
             viewsDescriptor.SetViewOriginCoord(viewIndex, i, 0);
         }
 
         viewsDescriptor.SetViewOriginCoord(viewIndex, concatenationDimension, coordAlongConcatDim);
         unsigned int dimSize = inputShape[concatenationDimension];
         coordAlongConcatDim += dimSize;
 
 
         for (unsigned int i = concatenationDimension + 1; i < numDimensions; ++i)
         {
             viewsDescriptor.SetViewOriginCoord(viewIndex, i, 0);
         }
 
         ++viewIndex;
     }
 
     return viewsDescriptor;
 }

◆ CreateMergerDescriptorForConcatenation()

OriginsDescriptor armnn::CreateMergerDescriptorForConcatenation	(	TensorShapeIt	first,
		TensorShapeIt	last,
		unsigned int	concatenationDimension
	)

Definition at line 240 of file Descriptors.hpp.

References CreateDescriptorForConcatenation().

 {
     return CreateDescriptorForConcatenation(first, last, concatenationDimension);
 }

◆ CreateNetworkWithActivationLayer()

INetworkPtr armnn::CreateNetworkWithActivationLayer	(	const ActivationDescriptor &	descriptor,
		const TensorShape &	shape
	)

Definition at line 296 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetwork::Create(), Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), info, and IOutputSlot::SetTensorInfo().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     INetworkPtr network = INetwork::Create();
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* activation = network->AddActivationLayer(descriptor);
     IConnectableLayer* output = network->AddOutputLayer(2);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(activation->GetInputSlot(0));
     activation->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set TensorInfo
     TensorInfo info(shape, DataType::Float32);
     input0->GetOutputSlot(0).SetTensorInfo(info);
     activation->GetOutputSlot(0).SetTensorInfo(info);
 
     return network;
 }

◆ CreateNetworkWithFullyConnectedLayer()

INetworkPtr armnn::CreateNetworkWithFullyConnectedLayer	(	const bool	biasEnabled,
		const TensorShape &	inputShape,
		const TensorShape &	outputShape
	)

Definition at line 1061 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetwork::Create(), Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), info, FullyConnectedDescriptor::m_BiasEnabled, and IOutputSlot::SetTensorInfo().

Referenced by ValidateFullyConnectedLayer().

 {
     FullyConnectedDescriptor desc;
     desc.m_BiasEnabled = biasEnabled;
     INetworkPtr network = INetwork::Create();
 
     const TensorInfo info(inputShape, DataType::Float32);
     const TensorInfo outputInfo(outputShape, DataType::Float32);
 
     std::vector<float> weightsData{-1.0f, 1.5f, 2.0f};
     ConstTensor weights(info, weightsData);
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* fullyConnected;
     Optional<ConstTensor> optionalBias;
     std::vector<float> biasData{10.0f, 20.0f, 30.0f};
     if (desc.m_BiasEnabled)
     {
         ConstTensor bias(info, biasData);
         optionalBias = Optional<ConstTensor>(bias);
     }
     fullyConnected = network->AddFullyConnectedLayer(desc, weights, optionalBias);
     IConnectableLayer* output = network->AddOutputLayer(1);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(fullyConnected->GetInputSlot(0));
     fullyConnected->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set TensorInfo
     input0->GetOutputSlot(0).SetTensorInfo(info);
     fullyConnected->GetOutputSlot(0).SetTensorInfo(outputInfo);
 
     return network;
 }

◆ CreateNetworkWithInputOutputLayers()

INetworkPtr armnn::CreateNetworkWithInputOutputLayers ( )

Definition at line 317 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetwork::Create(), Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), info, and IOutputSlot::SetTensorInfo().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     INetworkPtr network = INetwork::Create();
 
     // Add input/output layers
     IConnectableLayer* inputLayer = network->AddInputLayer(0);
     IConnectableLayer* output = network->AddOutputLayer(1);
 
     // Establish connections
     inputLayer->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set TensorInfo
     TensorShape shape{8U};
     TensorInfo info(shape, DataType::Float32);
     inputLayer->GetOutputSlot(0).SetTensorInfo(info);
 
     return network;
 }

◆ CreateNetworkWithSoftmaxLayer()

INetworkPtr armnn::CreateNetworkWithSoftmaxLayer	(	const SoftmaxDescriptor &	descriptor,
		const TensorShape &	shape
	)

Definition at line 1538 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetwork::Create(), Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), info, and IOutputSlot::SetTensorInfo().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     INetworkPtr network = INetwork::Create();
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* softmax = network->AddSoftmaxLayer(descriptor);
     IConnectableLayer* output = network->AddOutputLayer(2);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(softmax->GetInputSlot(0));
     softmax->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set TensorInfo
     TensorInfo info(shape, DataType::Float32);
     input0->GetOutputSlot(0).SetTensorInfo(info);
     softmax->GetOutputSlot(0).SetTensorInfo(info);
 
     return network;
 }

◆ CreateQuantizedConst()

ConstTensor CreateQuantizedConst	(	const ConstTensor &	tensor,
		std::vector< uint8_t > &	backing
	)

Definition at line 15 of file NetworkQuantizerUtils.cpp.

References ARMNN_ASSERT_MSG, Float32, TensorInfo::GetDataType(), BaseTensor< MemoryType >::GetInfo(), BaseTensor< MemoryType >::GetMemoryArea(), TensorInfo::GetNumElements(), TensorInfo::GetShape(), QAsymmU8, and QuantizeConstant().

Referenced by QuantizeConstant(), QuantizerVisitor::VisitBatchNormalizationLayer(), QuantizerVisitor::VisitConstantLayer(), QuantizerVisitor::VisitConvolution2dLayer(), QuantizerVisitor::VisitDepthwiseConvolution2dLayer(), QuantizerVisitor::VisitFullyConnectedLayer(), and QuantizerVisitor::VisitTransposeConvolution2dLayer().

 {
     float scale = 0.0f;
     int offset = 0;
 
     // Reserve the backing memory
     backing.resize(tensor.GetInfo().GetNumElements());
 
     DataType type = tensor.GetInfo().GetDataType();
     switch(type)
     {
         case DataType::Float32:
         {
             QuantizeConstant(static_cast<const float*>(tensor.GetMemoryArea()),
                              backing.data(),
                              backing.size(),
                              scale,
                              offset);
         }
             break;
         default:
             ARMNN_ASSERT_MSG(false, "Can't quantize unsupported data type");
     }
 
     TensorInfo qInfo(tensor.GetInfo().GetShape(), DataType::QAsymmU8, scale, offset);
     return ConstTensor(qInfo, backing);
 }

◆ CreateStartOfLeakyReluNetwork()

IConnectableLayer* armnn::CreateStartOfLeakyReluNetwork	(	INetwork *	network,
		const TensorInfo &	info
	)

Definition at line 1655 of file QuantizerTest.cpp.

References INetwork::AddActivationLayer(), INetwork::AddInputLayer(), IOutputSlot::Connect(), IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), LeakyReLu, ActivationDescriptor::m_A, ActivationDescriptor::m_B, ActivationDescriptor::m_Function, and IOutputSlot::SetTensorInfo().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     ActivationDescriptor activationDescriptor;
     activationDescriptor.m_Function = ActivationFunction::LeakyReLu;
     activationDescriptor.m_A        = 3.5f;
     activationDescriptor.m_B        = -10.0f;
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* activation = network->AddActivationLayer(activationDescriptor);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(activation->GetInputSlot(0));
 
     // Set TensorInfo
     input0->GetOutputSlot(0).SetTensorInfo(info);
     activation->GetOutputSlot(0).SetTensorInfo(info);
 
     return activation;
 }

◆ CreateSupportedBackends()

BackendsMap CreateSupportedBackends	(	TensorHandleFactoryRegistry &	handleFactoryRegistry,
		BackendSettings &	backendSettings
	)

Definition at line 522 of file Network.cpp.

References ARMNN_ASSERT, BackendRegistryInstance(), and BackendSettings::m_SupportedBackends.

Referenced by Optimize().

 {
     BackendsMap backends;
     auto const& backendRegistry = BackendRegistryInstance();
     for (auto&& selectedBackend : backendSettings.m_SupportedBackends)
     {
         auto backendFactory = backendRegistry.GetFactory(selectedBackend);
         auto backendObjPtr = backendFactory();
         ARMNN_ASSERT(backendObjPtr);
 
         backendObjPtr->RegisterTensorHandleFactories(handleFactoryRegistry);
 
         backends[backendObjPtr->GetId()] = std::move(backendObjPtr);
     }
 
     return backends;
 }

◆ Debug()

void Debug	(	const TensorInfo &	inputInfo,
		const T *	inputData,
		LayerGuid	guid,
		const std::string &	layerName,
		unsigned int	slotIndex
	)

Definition at line 20 of file Debug.cpp.

References Debug< BFloat16 >(), Debug< float >(), Debug< Half >(), Debug< int16_t >(), Debug< int32_t >(), Debug< int8_t >(), Debug< uint8_t >(), TensorInfo::GetNumDimensions(), TensorInfo::GetNumElements(), TensorInfo::GetShape(), and numeric_cast().

Referenced by RefDebugWorkload< DataType >::Execute().

 {
     const unsigned int numDims = inputInfo.GetNumDimensions();
     const unsigned int numElements = inputInfo.GetNumElements();
     const TensorShape& inputShape = inputInfo.GetShape();
 
     std::vector<unsigned int> strides(numDims, 0);
     strides[numDims - 1] = inputShape[numDims - 1];
 
     for (unsigned int i = 2; i <= numDims; i++)
     {
         strides[numDims - i] = strides[numDims - i + 1] * inputShape[numDims - i];
     }
 
     std::cout << "{ ";
     std::cout << "\"layerGuid\": " << guid << ", ";
     std::cout << "\"layerName\": \"" << layerName << "\", ";
     std::cout << "\"outputSlot\": " << slotIndex << ", ";
     std::cout << "\"shape\": ";
 
     std::cout << "[";
     for (unsigned int i = 0; i < numDims; i++)
     {
         std::cout << inputShape[i];
         if (i != numDims - 1)
         {
             std::cout << ", ";
         }
     }
     std::cout << "], ";
 
     std::cout << "\"min\": "
         << boost::numeric_cast<float>(*std::min_element(inputData, inputData + numElements)) << ", ";
 
     std::cout << "\"max\": "
         << boost::numeric_cast<float>(*std::max_element(inputData, inputData + numElements)) << ", ";
 
     std::cout << "\"data\": ";
 
     for (unsigned int i = 0; i < numElements; i++)
     {
         for (unsigned int j = 0; j < numDims; j++)
         {
             if (i % strides[j] == 0)
             {
                 std::cout << "[" ;
             }
         }
 
         std::cout << boost::numeric_cast<float>(inputData[i]);
 
         for (unsigned int j = 0; j < numDims; j++)
         {
             if ((i+1) % strides[j] == 0)
             {
                 std::cout << "]" ;
             }
         }
 
         if (i != numElements - 1)
         {
             std::cout << ", ";
         }
     }
 
     std::cout << " }" << std::endl;
 }

◆ Debug< BFloat16 >()

template void armnn::Debug< BFloat16 >	(	const TensorInfo &	inputInfo,
		const BFloat16 *	inputData,
		LayerGuid	guid,
		const std::string &	layerName,
		unsigned int	slotIndex
	)

Referenced by Debug().

◆ Debug< float >()

template void armnn::Debug< float >	(	const TensorInfo &	inputInfo,
		const float *	inputData,
		LayerGuid	guid,
		const std::string &	layerName,
		unsigned int	slotIndex
	)

Referenced by Debug().

◆ Debug< Half >()

template void armnn::Debug< Half >	(	const TensorInfo &	inputInfo,
		const Half *	inputData,
		LayerGuid	guid,
		const std::string &	layerName,
		unsigned int	slotIndex
	)

Referenced by Debug().

◆ Debug< int16_t >()

template void armnn::Debug< int16_t >	(	const TensorInfo &	inputInfo,
		const int16_t *	inputData,
		LayerGuid	guid,
		const std::string &	layerName,
		unsigned int	slotIndex
	)

Referenced by Debug().

◆ Debug< int32_t >()

template void armnn::Debug< int32_t >	(	const TensorInfo &	inputInfo,
		const int32_t *	inputData,
		LayerGuid	guid,
		const std::string &	layerName,
		unsigned int	slotIndex
	)

Referenced by Debug().

◆ Debug< int8_t >()

template void armnn::Debug< int8_t >	(	const TensorInfo &	inputInfo,
		const int8_t *	inputData,
		LayerGuid	guid,
		const std::string &	layerName,
		unsigned int	slotIndex
	)

Referenced by Debug().

◆ Debug< uint8_t >()

template void armnn::Debug< uint8_t >	(	const TensorInfo &	inputInfo,
		const uint8_t *	inputData,
		LayerGuid	guid,
		const std::string &	layerName,
		unsigned int	slotIndex
	)

Referenced by Debug().

◆ DepthToSpace()

void DepthToSpace	(	const TensorInfo &	inputInfo,
		const DepthToSpaceDescriptor &	descriptor,
		const void *	inputData,
		void *	outputData,
		unsigned int	dataTypeSize
	)

Definition at line 18 of file DepthToSpace.cpp.

References ARMNN_ASSERT, DepthToSpace(), DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), TensorShape::GetNumElements(), TensorInfo::GetShape(), DataLayoutIndexed::GetWidthIndex(), SpaceToDepthDescriptor::m_BlockSize, SpaceToDepthDescriptor::m_DataLayout, NCHW, and armnnUtils::Permute().

Referenced by BOOST_AUTO_TEST_CASE(), and DepthToSpace().

 {
     const unsigned int blockSize = descriptor.m_BlockSize;
     ARMNN_ASSERT(blockSize != 0u);
 
     const TensorShape& inputShape = inputInfo.GetShape();
     const unsigned int batches = inputShape[0];
 
     armnnUtils::DataLayoutIndexed dataLayoutIndexed(descriptor.m_DataLayout);
     const unsigned int inDepth  = inputShape[dataLayoutIndexed.GetChannelsIndex()];
     const unsigned int inHeight = inputShape[dataLayoutIndexed.GetHeightIndex()];
     const unsigned int inWidth  = inputShape[dataLayoutIndexed.GetWidthIndex()];
 
     const unsigned int outDepth = inDepth / (blockSize * blockSize);
 
     // The 4D input data can be interpreted as 6D (implicitly reshaped) as follows:
     //
     // [batch, block size, block size, inDepth, inHeight, inWidth] for NCHW and
     // [batch, inHeight, inWidth, blockSize, blockSize, outDepth] for NHWC.
     //
     // DepthToSpace can then be implemented as a permutation in 6D resulting in
     // the following shapes:
     //
     // [batch, outDepth, inHeight, blockSize, inWidth, blockSize] for NCHW and
     // [batch, inHeight, blockSize, inWidth, blockSize, outDepth] for NHWC.
     //
     // NOTE:
     // Since 6D tensors are not currently supported, in practice we need to handle each
     // batch separately and execute 5D permutations
 
     TensorShape permDestShape;
     PermutationVector permVector{};
     if (descriptor.m_DataLayout == DataLayout::NCHW)
     {
         permDestShape = TensorShape({ outDepth, inHeight, blockSize, inWidth, blockSize });
         permVector    = { 2, 4, 0, 1, 3 };
     }
     else
     {
         permDestShape = TensorShape({ inHeight, blockSize, inWidth, blockSize, outDepth });
         permVector    = { 0, 2, 1, 3, 4 };
     }
 
     const unsigned int numElementsPerBatch = inputShape.GetNumElements() / batches;
 
     for (unsigned int batchIndex = 0u; batchIndex < batches; ++batchIndex)
     {
         const uintptr_t batchDataOffset = batchIndex * (numElementsPerBatch * dataTypeSize);
 
         armnnUtils::Permute(permDestShape,
                             permVector,
                             static_cast<const void*>(reinterpret_cast<const uint8_t*>(inputData) + batchDataOffset),
                             static_cast<void*>(reinterpret_cast<uint8_t*>(outputData) + batchDataOffset),
                             dataTypeSize);
     }
 }

◆ Dequantize() [1/4]

void Dequantize	(	Decoder< float > &	inputDecoder,
		Encoder< float > &	outputEncoder,
		const TensorInfo &	inputInfo,
		const TensorInfo &	outputInfo
	)

Definition at line 13 of file Dequantize.cpp.

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

 {
     IgnoreUnused(outputInfo);
     ARMNN_ASSERT(inputInfo.GetNumElements() == outputInfo.GetNumElements());
     for (unsigned int i = 0; i < inputInfo.GetNumElements(); i++)
     {
         // inputDecoder.Get() dequantizes the data element from whatever
         // type is given by inputInfo to fp32 (If MakeDecoder supports that dequantization)
         // outputEncoder.Set() transforms the data element to whatever type is
         // given by outputInfo (if MakeEncoder supports that transformation)
         outputEncoder.Set(inputDecoder.Get());
         ++outputEncoder;
         ++inputDecoder;
     }
 }

◆ Dequantize() [2/4]

std::vector<float> armnn::Dequantize	(	const T *	quant,
		const TensorInfo &	info
	)

u8 helpers

Definition at line 89 of file RefWorkloadUtils.hpp.

References Dequantize(), TensorInfo::GetNumElements(), TensorInfo::GetQuantizationOffset(), and TensorInfo::GetQuantizationScale().

 {
     std::vector<float> ret(info.GetNumElements());
     for (size_t i = 0; i < info.GetNumElements(); i++)
     {
         ret[i] = armnn::Dequantize(quant[i], info.GetQuantizationScale(), info.GetQuantizationOffset());
     }
     return ret;
 }

◆ Dequantize() [3/4]

void armnn::Dequantize	(	const T *	inputData,
		float *	outputData,
		const TensorInfo &	info
	)

inline

Definition at line 100 of file RefWorkloadUtils.hpp.

References TensorInfo::GetNumElements(), TensorInfo::GetQuantizationOffset(), and TensorInfo::GetQuantizationScale().

 {
     for (unsigned int i = 0; i < info.GetNumElements(); i++)
     {
         outputData[i] = Dequantize<T>(inputData[i], info.GetQuantizationScale(), info.GetQuantizationOffset());
     }
 }

◆ Dequantize() [4/4]

float Dequantize	(	QuantizedType	value,
		float	scale,
		int32_t	offset
	)

Dequantize an 8-bit data type into a floating point data type.

Parameters

value	- The value to dequantize.
scale	- The scale (must be non-zero).
offset	- The offset.

Returns: - The dequantized value calculated as (value-offset)*scale.

Definition at line 47 of file TypesUtils.cpp.

References ARMNN_ASSERT, and numeric_cast().

Referenced by BOOST_AUTO_TEST_CASE(), SelectiveQuantizer< T, DoQuantize >::Dequantize(), and Dequantize().

 {
     static_assert(IsQuantizedType<QuantizedType>(), "Not an integer type.");
     ARMNN_ASSERT(scale != 0.f);
     ARMNN_ASSERT(!IsNan(value));
     float dequantized = boost::numeric_cast<float>(value - offset) * scale;
     return dequantized;
 }

◆ DetectionPostProcess()

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
	)

Definition at line 141 of file DetectionPostProcess.cpp.

Referenced by DetectionPostProcessTestImpl().

 {
     IgnoreUnused(anchorsInfo, detectionClassesInfo, detectionScoresInfo, numDetectionsInfo);
 
     // Transform center-size format which is (ycenter, xcenter, height, width) to box-corner format,
     // which represents the lower left corner and the upper right corner (ymin, xmin, ymax, xmax)
     std::vector<float> boxCorners(boxEncodingsInfo.GetNumElements());
 
     const unsigned int numBoxes  = boxEncodingsInfo.GetShape()[1];
     const unsigned int numScores = scoresInfo.GetNumElements();
 
     for (unsigned int i = 0; i < numBoxes; ++i)
     {
         // Y
         float boxEncodingY = boxEncodings.Get();
         float anchorY      = anchors.Get();
 
         ++boxEncodings;
         ++anchors;
 
         // X
         float boxEncodingX = boxEncodings.Get();
         float anchorX      = anchors.Get();
 
         ++boxEncodings;
         ++anchors;
 
         // H
         float boxEncodingH = boxEncodings.Get();
         float anchorH      = anchors.Get();
 
         ++boxEncodings;
         ++anchors;
 
         // W
         float boxEncodingW = boxEncodings.Get();
         float anchorW      = anchors.Get();
 
         ++boxEncodings;
         ++anchors;
 
         float yCentre = boxEncodingY / desc.m_ScaleY * anchorH + anchorY;
         float xCentre = boxEncodingX / desc.m_ScaleX * anchorW + anchorX;
 
         float halfH = 0.5f * expf(boxEncodingH / desc.m_ScaleH) * anchorH;
         float halfW = 0.5f * expf(boxEncodingW / desc.m_ScaleW) * anchorW;
 
         unsigned int indexY = i * 4;
         unsigned int indexX = indexY + 1;
         unsigned int indexH = indexX + 1;
         unsigned int indexW = indexH + 1;
 
         // ymin
         boxCorners[indexY] = yCentre - halfH;
         // xmin
         boxCorners[indexX] = xCentre - halfW;
         // ymax
         boxCorners[indexH] = yCentre + halfH;
         // xmax
         boxCorners[indexW] = xCentre + halfW;
 
         ARMNN_ASSERT(boxCorners[indexY] < boxCorners[indexH]);
         ARMNN_ASSERT(boxCorners[indexX] < boxCorners[indexW]);
     }
 
     unsigned int numClassesWithBg = desc.m_NumClasses + 1;
 
     // Decode scores
     std::vector<float> decodedScores;
     decodedScores.reserve(numScores);
 
     for (unsigned int i = 0u; i < numScores; ++i)
     {
         decodedScores.emplace_back(scores.Get());
         ++scores;
     }
 
     // Perform Non Max Suppression.
     if (desc.m_UseRegularNms)
     {
         // Perform Regular NMS.
         // For each class, perform NMS and select max detection numbers of the highest score across all classes.
         std::vector<float> classScores(numBoxes);
 
         std::vector<unsigned int> selectedBoxesAfterNms;
         selectedBoxesAfterNms.reserve(numBoxes);
 
         std::vector<float> selectedScoresAfterNms;
         selectedBoxesAfterNms.reserve(numScores);
 
         std::vector<unsigned int> selectedClasses;
 
         for (unsigned int c = 0; c < desc.m_NumClasses; ++c)
         {
             // For each boxes, get scores of the boxes for the class c.
             for (unsigned int i = 0; i < numBoxes; ++i)
             {
                 classScores[i] = decodedScores[i * numClassesWithBg + c + 1];
             }
             std::vector<unsigned int> selectedIndices = NonMaxSuppression(numBoxes,
                                                                           boxCorners,
                                                                           classScores,
                                                                           desc.m_NmsScoreThreshold,
                                                                           desc.m_DetectionsPerClass,
                                                                           desc.m_NmsIouThreshold);
 
             for (unsigned int i = 0; i < selectedIndices.size(); ++i)
             {
                 selectedBoxesAfterNms.push_back(selectedIndices[i]);
                 selectedScoresAfterNms.push_back(classScores[selectedIndices[i]]);
                 selectedClasses.push_back(c);
             }
         }
 
         // Select max detection numbers of the highest score across all classes
         unsigned int numSelected = boost::numeric_cast<unsigned int>(selectedBoxesAfterNms.size());
         unsigned int numOutput = std::min(desc.m_MaxDetections,  numSelected);
 
         // Sort the max scores among the selected indices.
         std::vector<unsigned int> outputIndices = GenerateRangeK(numSelected);
         TopKSort(numOutput, outputIndices.data(), selectedScoresAfterNms.data(), numSelected);
 
         AllocateOutputData(detectionBoxesInfo.GetShape()[1], numOutput, boxCorners, outputIndices,
                            selectedBoxesAfterNms, selectedClasses, selectedScoresAfterNms,
                            detectionBoxes, detectionScores, detectionClasses, numDetections);
     }
     else
     {
         // Perform Fast NMS.
         // Select max scores of boxes and perform NMS on max scores,
         // select max detection numbers of the highest score
         unsigned int numClassesPerBox = std::min(desc.m_MaxClassesPerDetection, desc.m_NumClasses);
         std::vector<float> maxScores;
         std::vector<unsigned int>boxIndices;
         std::vector<unsigned int>maxScoreClasses;
 
         for (unsigned int box = 0; box < numBoxes; ++box)
         {
             unsigned int scoreIndex = box * numClassesWithBg + 1;
 
             // Get the max scores of the box.
             std::vector<unsigned int> maxScoreIndices = GenerateRangeK(desc.m_NumClasses);
             TopKSort(numClassesPerBox, maxScoreIndices.data(),
                 decodedScores.data() + scoreIndex, desc.m_NumClasses);
 
             for (unsigned int i = 0; i < numClassesPerBox; ++i)
             {
                 maxScores.push_back(decodedScores[scoreIndex + maxScoreIndices[i]]);
                 maxScoreClasses.push_back(maxScoreIndices[i]);
                 boxIndices.push_back(box);
             }
         }
 
         // Perform NMS on max scores
         std::vector<unsigned int> selectedIndices = NonMaxSuppression(numBoxes, boxCorners, maxScores,
                                                                       desc.m_NmsScoreThreshold,
                                                                       desc.m_MaxDetections,
                                                                       desc.m_NmsIouThreshold);
 
         unsigned int numSelected = boost::numeric_cast<unsigned int>(selectedIndices.size());
         unsigned int numOutput = std::min(desc.m_MaxDetections,  numSelected);
 
         AllocateOutputData(detectionBoxesInfo.GetShape()[1], numOutput, boxCorners, selectedIndices,
                            boxIndices, maxScoreClasses, maxScores,
                            detectionBoxes, detectionScores, detectionClasses, numDetections);
     }
 }

◆ ExtractJsonObjects()

void armnn::ExtractJsonObjects	(	unsigned int	inferenceIndex,
		const Event *	parentEvent,
		JsonChildObject &	parentObject,
		std::map< const Event , std::vector< const Event >>	descendantsMap
	)

Definition at line 284 of file Profiling.cpp.

References JsonChildObject::AddChild(), JsonChildObject::AddMeasurement(), ARMNN_ASSERT, Event, JsonChildObject::GetChild(), Event::GetMeasurements(), Measurement, JsonChildObject::NumChildren(), JsonChildObject::SetType(), and JsonChildObject::SetUnit().

Referenced by Profiler::Print().

 {
     ARMNN_ASSERT(parentEvent);
     std::vector<Measurement> instrumentMeasurements = parentEvent->GetMeasurements();
     unsigned int childIdx=0;
     for(size_t measurementIndex = 0; measurementIndex < instrumentMeasurements.size(); ++measurementIndex, ++childIdx)
     {
         if (inferenceIndex == 0)
         {
             // Only add kernel measurement once, in case of multiple inferences
             JsonChildObject measurementObject{instrumentMeasurements[measurementIndex].m_Name};
             measurementObject.SetUnit(instrumentMeasurements[measurementIndex].m_Unit);
             measurementObject.SetType(JsonObjectType::Measurement);
 
             ARMNN_ASSERT(parentObject.NumChildren() == childIdx);
             parentObject.AddChild(measurementObject);
         }
 
         parentObject.GetChild(childIdx).AddMeasurement(instrumentMeasurements[measurementIndex].m_Value);
     }
 
 
     auto childEventsIt = descendantsMap.find(parentEvent);
     if (childEventsIt != descendantsMap.end())
     {
         for (auto childEvent : childEventsIt->second)
         {
             if (inferenceIndex == 0)
             {
                 // Only add second level once, in case of multiple inferences
                 JsonChildObject childObject{childEvent->GetName()};
                 childObject.SetType(JsonObjectType::Event);
                 parentObject.AddChild(childObject);
             }
 
             // Recursively process children. In reality this won't be very deep recursion. ~4-6 levels deep.
             ExtractJsonObjects(inferenceIndex, childEvent, parentObject.GetChild(childIdx), descendantsMap);
 
             childIdx++;
         }
     }
 }

◆ FakeQuantization()

void armnn::FakeQuantization	(	const float *	inputData,
		float *	outputData,
		uint32_t	numElements,
		float	min,
		float	max
	)

Definition at line 17 of file RefFakeQuantizationFloat32Workload.cpp.

References numeric_cast().

 {
     float scale = (max - min) / 255.f;
     int32_t offset = boost::numeric_cast<int32_t>((-min * 255.f) / (max - min));
 
     for (uint32_t i = 0; i < numElements; i++)
     {
         outputData[i] = static_cast<float>(armnn::Quantize<uint8_t>(inputData[i], scale, offset));
     }
 
 }

◆ FalseFunc()

bool armnn::FalseFunc	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 62 of file LayerSupportCommon.hpp.

References IgnoreUnused().

 {
     IgnoreUnused(reasonIfUnsupported);
     IgnoreUnused(params...);
     return false;
 }

◆ FalseFuncF16()

bool armnn::FalseFuncF16	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 70 of file LayerSupportCommon.hpp.

References IgnoreUnused(), and SetValueChecked().

 {
     IgnoreUnused(params...);
     SetValueChecked(reasonIfUnsupported, "Layer is not supported with float16 data type");
     return false;
 }

◆ FalseFuncF32()

bool armnn::FalseFuncF32	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 78 of file LayerSupportCommon.hpp.

References IgnoreUnused(), and SetValueChecked().

 {
     IgnoreUnused(params...);
     SetValueChecked(reasonIfUnsupported, "Layer is not supported with float32 data type");
     return false;
 }

◆ FalseFuncI32()

bool armnn::FalseFuncI32	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 94 of file LayerSupportCommon.hpp.

References IgnoreUnused(), and SetValueChecked().

 {
     IgnoreUnused(params...);
     SetValueChecked(reasonIfUnsupported, "Layer is not supported with int32 data type");
     return false;
 }

◆ FalseFuncU8()

bool armnn::FalseFuncU8	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 86 of file LayerSupportCommon.hpp.

References IgnoreUnused(), and SetValueChecked().

 {
     IgnoreUnused(params...);
     SetValueChecked(reasonIfUnsupported, "Layer is not supported with 8-bit data type");
     return false;
 }

◆ FalseInputFuncF16()

bool armnn::FalseInputFuncF16	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 110 of file LayerSupportCommon.hpp.

References IgnoreUnused(), and SetValueChecked().

 {
     IgnoreUnused(params...);
     SetValueChecked(reasonIfUnsupported, "Layer is not supported with float16 data type input");
     return false;
 }

◆ FalseInputFuncF32()

bool armnn::FalseInputFuncF32	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 102 of file LayerSupportCommon.hpp.

References IgnoreUnused(), and SetValueChecked().

 {
     IgnoreUnused(params...);
     SetValueChecked(reasonIfUnsupported, "Layer is not supported with float32 data type input");
     return false;
 }

◆ FalseOutputFuncF16()

bool armnn::FalseOutputFuncF16	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 126 of file LayerSupportCommon.hpp.

References IgnoreUnused(), and SetValueChecked().

 {
     IgnoreUnused(params...);
     SetValueChecked(reasonIfUnsupported, "Layer is not supported with float16 data type output");
     return false;
 }

◆ FalseOutputFuncF32()

bool armnn::FalseOutputFuncF32	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 118 of file LayerSupportCommon.hpp.

References IgnoreUnused(), and SetValueChecked().

 {
     IgnoreUnused(params...);
     SetValueChecked(reasonIfUnsupported, "Layer is not supported with float32 data type output");
     return false;
 }

◆ Fill()

void Fill	(	Encoder< float > &	output,
		const TensorShape &	desiredOutputShape,
		const float	value
	)

Creates a tensor and fills it with a scalar value.

Definition at line 13 of file Fill.cpp.

References TensorShape::GetNumElements(), and Encoder< IType >::Set().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     for(unsigned int i = 0; i < desiredOutputShape.GetNumElements(); ++i)
     {
         output[i];
         output.Set(value);
     }
 }

◆ FindKernelMeasurements()

std::vector<Measurement> armnn::FindKernelMeasurements ( const Event * event )

Definition at line 63 of file Profiling.cpp.

References ARMNN_ASSERT, FindMeasurement(), Event::GetMeasurements(), Measurement::m_Value, and WallClockTimer::WALL_CLOCK_TIME.

 {
     ARMNN_ASSERT(event != nullptr);
 
     std::vector<Measurement> measurements;
 
     // Search through the measurements.
     for (const auto& measurement : event->GetMeasurements())
     {
         if (measurement.m_Name.rfind("OpenClKernelTimer", 0) == 0
             || measurement.m_Name.rfind("NeonKernelTimer", 0) == 0)
         {
             // Measurement found.
             measurements.push_back(measurement);
         }
     }
 
     return measurements;
 }

◆ FindMeasurement()

Measurement armnn::FindMeasurement	(	const std::string &	name,
		const Event *	event
	)

Definition at line 44 of file Profiling.cpp.

References ARMNN_ASSERT, and Event::GetMeasurements().

Referenced by Profiler::AnalyzeEventSequenceAndWriteResults(), and FindKernelMeasurements().

 {
 
     ARMNN_ASSERT(event != nullptr);
 
     // Search though the measurements.
     for (const auto& measurement : event->GetMeasurements())
     {
         if (measurement.m_Name == name)
         {
             // Measurement found.
             return measurement;
         }
     }
 
     // Measurement not found.
     return Measurement{ "", 0.f, Measurement::Unit::TIME_MS };
 }

◆ ForEachLayerInput()

void armnn::ForEachLayerInput	(	LayerSelectionInfo::LayerInfoContainer &	layerInfos,
		LayerSelectionInfo &	layerInfo,
		Delegate	function
	)

Definition at line 263 of file SubgraphViewSelector.cpp.

References ARMNN_ASSERT_MSG, and Layer::GetInputSlots().

Referenced by AssignSplitId(), and IsReadyForSplitAssignment().

 {
     Layer& layer = *layerInfo.m_Layer;
 
     for (auto inputSlot : layer.GetInputSlots())
     {
         auto connectedInput = PolymorphicDowncast<OutputSlot*>(inputSlot.GetConnection());
         ARMNN_ASSERT_MSG(connectedInput, "Dangling input slot detected.");
         Layer& inputLayer = connectedInput->GetOwningLayer();
 
         auto parentInfo = layerInfos.find(&inputLayer);
         if (parentInfo != layerInfos.end())
         {
             function(parentInfo->second);
         }
     }
 }

◆ ForEachLayerOutput()

void armnn::ForEachLayerOutput	(	LayerSelectionInfo::LayerInfoContainer &	layerInfos,
		LayerSelectionInfo &	layerInfo,
		Delegate	function
	)

Definition at line 284 of file SubgraphViewSelector.cpp.

References Layer::GetOutputSlots().

Referenced by SubgraphViewSelector::SelectSubgraphs().

 {
     Layer& layer= *layerInfo.m_Layer;
 
     for (auto& outputSlot : layer.GetOutputSlots())
     {
         for (auto& output : outputSlot.GetConnections())
         {
             Layer& childLayer = output->GetOwningLayer();
 
             auto childInfo = layerInfos.find(&childLayer);
             if (childInfo != layerInfos.end())
             {
                 function(childInfo->second);
             }
         }
     }
 }

◆ FullyConnected()

void FullyConnected	(	const TensorShape &	rInputShape,
		Decoder< float > &	rInputDecoder,
		const TensorShape &	rOutputShape,
		Encoder< float > &	rOutputEncoder,
		Decoder< float > &	rWeightDecoder,
		Decoder< float > &	rBiasDecoder,
		const bool	biasEnabled,
		const unsigned int	K,
		const bool	transposeWeights
	)

Performs a matrix multiplication and optionally adds a bias.

Definition at line 13 of file FullyConnected.cpp.

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

 {
     // Perform FullyConnected implementation
     unsigned int outputSize = rOutputShape[1];
 
     for (unsigned int n = 0; n < rInputShape[0]; n++)
     {
         for (unsigned int channelOutput = 0; channelOutput < outputSize; channelOutput++)
         {
             float outval = 0.f;
 
             for (unsigned int channelInput = 0; channelInput < K; channelInput++)
             {
                 float weight;
                 if (transposeWeights)
                 {
                     rWeightDecoder[channelOutput * K + channelInput];
                     weight = rWeightDecoder.Get();
                 }
                 else
                 {
                     rWeightDecoder[channelInput * outputSize + channelOutput];
                     weight = rWeightDecoder.Get();
                 }
 
                 rInputDecoder[n * K + channelInput];
                 outval += weight * rInputDecoder.Get();
             }
 
             if (biasEnabled)
             {
                 rBiasDecoder[channelOutput];
                 outval += rBiasDecoder.Get();
             }
 
             rOutputEncoder[n * outputSize + channelOutput];
             rOutputEncoder.Set(outval);
         }
     }
 }

◆ Gather()

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
	)

Definition at line 18 of file Gather.cpp.

References ARMNN_ASSERT, Decoder< IType >::Get(), TensorInfo::GetNumDimensions(), TensorInfo::GetNumElements(), TensorInfo::GetShape(), IgnoreUnused(), numeric_cast(), and Encoder< IType >::Set().

 {
     IgnoreUnused(outputInfo);
     IgnoreUnused(axis);
 
     const TensorShape& paramsShape = paramsInfo.GetShape();
 
     unsigned int paramsProduct = 1;
     for (unsigned int i = 1; i < paramsInfo.GetNumDimensions(); ++i)
     {
         paramsProduct = paramsProduct * paramsShape[i];
     }
 
     unsigned int outIndex = 0;
     for (unsigned int i = 0; i < indicesInfo.GetNumElements(); ++i)
     {
         unsigned int indx = boost::numeric_cast<unsigned int>(indices[i]);
 
         ARMNN_ASSERT(indices[i] >= 0 && indx < paramsShape[0]);
 
         unsigned int startOffset = indx * paramsProduct;
         unsigned int endOffset = startOffset + paramsProduct;
 
         for (unsigned int j = startOffset; j < endOffset; ++j)
         {
             params[j];
             float outputValue = params.Get();
             output[outIndex];
             output.Set(outputValue);
             ++outIndex;
         }
     }
 
     ARMNN_ASSERT(outIndex == outputInfo.GetNumElements());
 }

◆ GatherTensorHandlePairs()

void armnn::GatherTensorHandlePairs	(	const DescriptorType &	descriptor,
		std::vector< std::pair< SrcTensorHandleType , DstTensorHandleType >> &	tensorHandlePairs
	)

Definition at line 190 of file WorkloadUtils.hpp.

References ConvertMaskToACLFormat(), ConvertWeightTensorFromArmnnToAcl(), ConvertWeightTensorInfoFromArmnnToAcl(), PermuteTensor(), and ReshapeWeightsForAcl().

Referenced by CopyMemGenericWorkload::CopyMemGenericWorkload(), NeonConvertBf16ToFp32Workload::NeonConvertBf16ToFp32Workload(), NeonConvertFp16ToFp32Workload::NeonConvertFp16ToFp32Workload(), NeonConvertFp32ToBf16Workload::NeonConvertFp32ToBf16Workload(), and NeonConvertFp32ToFp16Workload::NeonConvertFp32ToFp16Workload().

 {
     const unsigned int numInputs = static_cast<unsigned int>(descriptor.m_Inputs.size());
     tensorHandlePairs.reserve(numInputs);
 
     for (unsigned int i = 0; i < numInputs; ++i)
     {
         SrcTensorHandleType* const srcTensorHandle =
             PolymorphicDowncast<SrcTensorHandleType*>(descriptor.m_Inputs[i]);
         DstTensorHandleType* const dstTensorHandle =
             PolymorphicDowncast<DstTensorHandleType*>(descriptor.m_Outputs[i]);
 
         tensorHandlePairs.emplace_back(srcTensorHandle, dstTensorHandle);
     }
 }

◆ GenerateRangeK()

std::vector<unsigned int> armnn::GenerateRangeK ( unsigned int k )

Definition at line 18 of file DetectionPostProcess.cpp.

Referenced by DetectionPostProcess(), and NonMaxSuppression().

 {
     std::vector<unsigned int> range(k);
     std::iota(range.begin(), range.end(), 0);
     return range;
 }

◆ GetActivationFunctionAsCString()

constexpr char const* armnn::GetActivationFunctionAsCString ( ActivationFunction activation )

Definition at line 27 of file TypesUtils.hpp.

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

Referenced by StringifyLayerParameters< ActivationDescriptor >::Serialize().

 {
     switch (activation)
     {
         case ActivationFunction::Sigmoid:       return "Sigmoid";
         case ActivationFunction::TanH:          return "TanH";
         case ActivationFunction::Linear:        return "Linear";
         case ActivationFunction::ReLu:          return "ReLu";
         case ActivationFunction::BoundedReLu:   return "BoundedReLu";
         case ActivationFunction::SoftReLu:      return "SoftReLu";
         case ActivationFunction::LeakyReLu:     return "LeakyReLu";
         case ActivationFunction::Abs:           return "Abs";
         case ActivationFunction::Sqrt:          return "Sqrt";
         case ActivationFunction::Square:        return "Square";
         case ActivationFunction::Elu:           return "Elu";
         case ActivationFunction::HardSwish:     return "HardSwish";
         default:                                return "Unknown";
     }
 }

◆ GetArgMinMaxFunctionAsCString()

constexpr char const* armnn::GetArgMinMaxFunctionAsCString ( ArgMinMaxFunction function )

Definition at line 47 of file TypesUtils.hpp.

References Max, and Min.

 {
     switch (function)
     {
         case ArgMinMaxFunction::Max:    return "Max";
         case ArgMinMaxFunction::Min:    return "Min";
         default:                        return "Unknown";
     }
 }

◆ GetBiasDataType()

DataType GetBiasDataType ( DataType inputDataType )

Definition at line 25 of file WorkloadData.cpp.

References ARMNN_ASSERT_MSG, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, BFloat16, CHECK_LOCATION, TensorInfo::GetDataType(), GetDataTypeName(), TensorInfo::GetNumDimensions(), TensorInfo::GetNumElements(), TensorInfo::GetQuantizationDim(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::GetQuantizationScales(), TensorInfo::GetShape(), OptionalBase::has_value(), TensorInfo::HasMultipleQuantizationScales(), TensorInfo::HasPerAxisQuantization(), info, TensorInfo::IsQuantized(), IsQuantized8BitType(), TensorInfo::IsTypeSpaceMatch(), WorkloadInfo::m_InputTensorInfos, WorkloadInfo::m_OutputTensorInfos, OptionalReferenceSwitch< IsReference, T >::value(), and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by BOOST_AUTO_TEST_CASE(), CompareDepthwiseConvolution2dTestImpl(), FullyConnectedQueueDescriptor::Validate(), Convolution2dQueueDescriptor::Validate(), DepthwiseConvolution2dQueueDescriptor::Validate(), and TransposeConvolution2dQueueDescriptor::Validate().

 {
     switch (inputDataType)
     {
         case DataType::Float16:
             return DataType::Float16;
         case DataType::BFloat16:
         case DataType::Float32:
             return DataType::Float32;
         case DataType::QAsymmS8:
             return DataType::Signed32;
         case DataType::QAsymmU8:
             return DataType::Signed32;
         case DataType::QSymmS8:
             return DataType::Signed32;
         case DataType::QSymmS16:
             return DataType::Signed32;
         default:
             ARMNN_ASSERT_MSG(false, "Invalid input data type");
             return DataType::Float32;
     }
 }

◆ GetBiasTypeFromWeightsType()

armnn::Optional<armnn::DataType> armnn::GetBiasTypeFromWeightsType ( armnn::Optional< armnn::DataType > weightsType )

inline

Definition at line 14 of file LayerSupportRules.hpp.

References ARMNN_ASSERT_MSG, Float16, Float32, QAsymmS8, QAsymmU8, QSymmS16, Signed32, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by BiasAndWeightsTypesCompatible::BiasAndWeightsTypesCompatible(), BiasAndWeightsTypesMatch::BiasAndWeightsTypesMatch(), FullyConnectedTest(), and IWorkloadFactory::IsLayerSupported().

 {
     if (!weightsType)
     {
         return weightsType;
     }
 
     switch(weightsType.value())
     {
         case armnn::DataType::Float16:
         case armnn::DataType::Float32:
             return weightsType;
         case armnn::DataType::QAsymmU8:
             return armnn::DataType::Signed32;
         case armnn::DataType::QSymmS16:
             return armnn::DataType::Signed32;
         case armnn::DataType::QAsymmS8:
             return armnn::DataType::Signed32;
         default:
             ARMNN_ASSERT_MSG(false, "GetBiasTypeFromWeightsType(): Unsupported data type.");
     }
     return armnn::EmptyOptional();
 }

◆ GetComparisonOperationAsCString()

constexpr char const* armnn::GetComparisonOperationAsCString ( ComparisonOperation operation )

Definition at line 57 of file TypesUtils.hpp.

References Equal, Greater, GreaterOrEqual, Less, LessOrEqual, and NotEqual.

Referenced by RefComparisonWorkload::Execute().

 {
     switch (operation)
     {
         case ComparisonOperation::Equal:          return "Equal";
         case ComparisonOperation::Greater:        return "Greater";
         case ComparisonOperation::GreaterOrEqual: return "GreaterOrEqual";
         case ComparisonOperation::Less:           return "Less";
         case ComparisonOperation::LessOrEqual:    return "LessOrEqual";
         case ComparisonOperation::NotEqual:       return "NotEqual";
         default:                                  return "Unknown";
     }
 }

◆ GetComputeDeviceAsCString()

constexpr char const* armnn::GetComputeDeviceAsCString ( Compute compute )

Deprecated function that will be removed together with the Compute enum.

Definition at line 34 of file BackendId.hpp.

References CpuAcc, CpuRef, and GpuAcc.

Referenced by BOOST_AUTO_TEST_CASE(), GetSuitableBackendRegistered(), and operator<<().

 {
     switch (compute)
     {
         case armnn::Compute::CpuRef: return "CpuRef";
         case armnn::Compute::CpuAcc: return "CpuAcc";
         case armnn::Compute::GpuAcc: return "GpuAcc";
         default:                     return "Unknown";
     }
 }

◆ GetDataLayoutName()

constexpr const char* armnn::GetDataLayoutName ( DataLayout dataLayout )

Definition at line 190 of file TypesUtils.hpp.

References NCHW, and NHWC.

 {
     switch (dataLayout)
     {
         case DataLayout::NCHW: return "NCHW";
         case DataLayout::NHWC: return "NHWC";
         default:               return "Unknown";
     }
 }

◆ GetDataTypeName()

constexpr const char* armnn::GetDataTypeName ( DataType dataType )

Definition at line 168 of file TypesUtils.hpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, BFloat16, Boolean, Float16, Float32, QAsymmS8, QAsymmU8, QSymmS16, QSymmS8, QuantizedSymm8PerAxis, and Signed32.

Referenced by AttemptBackendAssignment(), BOOST_AUTO_TEST_CASE(), BOOST_AUTO_TEST_CASE(), GetBiasDataType(), TfLiteParser::GetBuffer(), RefPermuteWorkload< DataType >::GetName(), RefTransposeWorkload< DataType >::GetName(), RefDebugWorkload< DataType >::GetName(), armnnUtils::GetPerAxisParams(), and VerifyTensorInfoDataType().

 {
     switch (dataType)
     {
         case DataType::Float16:               return "Float16";
         case DataType::Float32:               return "Float32";
         case DataType::QAsymmU8:              return "QAsymmU8";
         case DataType::QAsymmS8:              return "QAsymmS8";
         case DataType::QSymmS8:               return "QSymmS8";
         ARMNN_NO_DEPRECATE_WARN_BEGIN
         case DataType::QuantizedSymm8PerAxis: return "QSymm8PerAxis";
         ARMNN_NO_DEPRECATE_WARN_END
         case DataType::QSymmS16:              return "QSymm16";
         case DataType::Signed32:              return "Signed32";
         case DataType::Boolean:               return "Boolean";
         case DataType::BFloat16:              return "BFloat16";
 
         default:
             return "Unknown";
     }
 }

◆ GetDataTypeSize()

constexpr unsigned int armnn::GetDataTypeSize ( DataType dataType )

Definition at line 115 of file TypesUtils.hpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, BFloat16, Boolean, Float16, Float32, QAsymmS8, QAsymmU8, QSymmS16, QSymmS8, QuantizedSymm8PerAxis, and Signed32.

Referenced by BOOST_AUTO_TEST_CASE(), armnnTfParser::ConvertTfTensorDataType(), RefStridedSliceWorkload::Execute(), RefDepthToSpaceWorkload::Execute(), RefSliceWorkload::Execute(), TensorInfo::GetNumBytes(), GetUnpaddedTensorStrides(), and PermuteTensor().

 {
     switch (dataType)
     {
         case DataType::BFloat16:
         case DataType::Float16:               return 2U;
         case DataType::Float32:
         case DataType::Signed32:              return 4U;
         case DataType::QAsymmU8:              return 1U;
         case DataType::QAsymmS8:              return 1U;
         case DataType::QSymmS8:               return 1U;
         ARMNN_NO_DEPRECATE_WARN_BEGIN
         case DataType::QuantizedSymm8PerAxis: return 1U;
         ARMNN_NO_DEPRECATE_WARN_END
         case DataType::QSymmS16:              return 2U;
         case DataType::Boolean:               return 1U;
         default:                              return 0U;
     }
 }

◆ GetEventPtr() [1/2]

const Event* armnn::GetEventPtr ( const Event * ptr )

Definition at line 110 of file Profiling.cpp.

Referenced by Profiler::AnalyzeEventSequenceAndWriteResults().

110 { return ptr;}

◆ GetEventPtr() [2/2]

const Event* armnn::GetEventPtr ( const std::unique_ptr< Event > & ptr )

Definition at line 111 of file Profiling.cpp.

111 {return ptr.get(); }

◆ GetILayerSupportByBackendId()

std::shared_ptr< ILayerSupport > GetILayerSupportByBackendId ( const armnn::BackendId & backend )

Convenience function to retrieve the ILayerSupport for a backend.

Definition at line 14 of file BackendHelper.cpp.

References BackendRegistryInstance(), BackendRegistry::GetFactory(), and BackendRegistry::IsBackendRegistered().

 {
     BackendRegistry& backendRegistry = armnn::BackendRegistryInstance();
 
     if (!backendRegistry.IsBackendRegistered(backend))
     {
         return nullptr;
     }
 
     auto factoryFunc = backendRegistry.GetFactory(backend);
     auto backendObject = factoryFunc();
     return backendObject->GetLayerSupport();
 }

◆ GetInputTensorData()

const DataType* armnn::GetInputTensorData	(	unsigned int	idx,
		const PayloadType &	data
	)

Definition at line 35 of file RefWorkloadUtils.hpp.

References ITensorHandle::Map().

 {
     const ITensorHandle* tensorHandle = data.m_Inputs[idx];
     return reinterpret_cast<const DataType*>(tensorHandle->Map());
 }

◆ GetInputTensorDataBFloat16()

const BFloat16* armnn::GetInputTensorDataBFloat16	(	unsigned int	idx,
		const PayloadType &	data
	)

Definition at line 73 of file RefWorkloadUtils.hpp.

Referenced by RefConvertBf16ToFp32Workload::Execute().

 {
     return GetInputTensorData<BFloat16>(idx, data);
 }

◆ GetInputTensorDataFloat()

const float* armnn::GetInputTensorDataFloat	(	unsigned int	idx,
		const PayloadType &	data
	)

Definition at line 49 of file RefWorkloadUtils.hpp.

Referenced by RefConvertFp32ToBf16Workload::Execute(), RefFakeQuantizationFloat32Workload::Execute(), and RefConvertFp32ToFp16Workload::Execute().

 {
     return GetInputTensorData<float>(idx, data);
 }

◆ GetInputTensorDataHalf()

const Half* armnn::GetInputTensorDataHalf	(	unsigned int	idx,
		const PayloadType &	data
	)

Definition at line 61 of file RefWorkloadUtils.hpp.

Referenced by RefConvertFp16ToFp32Workload::Execute().

 {
     return GetInputTensorData<Half>(idx, data);
 }

◆ GetInputTensorInfo()

TensorInfo armnn::GetInputTensorInfo ( const Network * network )

Definition at line 336 of file QuantizerTest.cpp.

References ARMNN_ASSERT_MSG, Network::GetGraph(), and Graph::GetInputLayers().

Referenced by BOOST_AUTO_TEST_CASE(), BoundedReLuUint8UpperAndLowerBoundTest(), and LoadedNetwork::~LoadedNetwork().

 {
     for (auto&& inputLayer : network->GetGraph().GetInputLayers())
     {
         ARMNN_ASSERT_MSG(inputLayer->GetNumOutputSlots() == 1, "Input layer should have exactly 1 output slot");
         return inputLayer->GetOutputSlot(0).GetTensorInfo();
     }
     throw InvalidArgumentException("Network has no input layers");
 }

◆ GetLayerTypeAsCString()

const char * GetLayerTypeAsCString ( LayerType type )

Definition at line 13 of file InternalTypes.cpp.

References ARMNN_ASSERT_MSG, and LIST_OF_LAYER_TYPE.

Referenced by AttemptBackendAssignment(), CheckScaleSetOnQuantizedType(), Layer::InferOutputShapes(), Graph::InferTensorInfos(), Graph::Print(), ReturnWithError(), Layer::SerializeLayerParameters(), Graph::SerializeToDot(), ElementwiseBaseLayer::ValidateTensorShapesFromInputs(), ElementwiseUnaryLayer::ValidateTensorShapesFromInputs(), and Layer::VerifyLayerConnections().

 {
     switch (type)
     {
 #define X(name) case LayerType::name: return #name;
       LIST_OF_LAYER_TYPE
 #undef X
         default:
             ARMNN_ASSERT_MSG(false, "Unknown layer type");
             return "Unknown";
     }
 }

◆ GetNormalizationAlgorithmChannelAsCString()

constexpr const char* armnn::GetNormalizationAlgorithmChannelAsCString ( NormalizationAlgorithmChannel channel )

Definition at line 200 of file TypesUtils.hpp.

References Across, and Within.

Referenced by StringifyLayerParameters< NormalizationDescriptor >::Serialize().

 {
     switch (channel)
     {
         case NormalizationAlgorithmChannel::Across: return "Across";
         case NormalizationAlgorithmChannel::Within: return "Within";
         default:                                    return "Unknown";
     }
 }

◆ GetNormalizationAlgorithmMethodAsCString()

constexpr const char* armnn::GetNormalizationAlgorithmMethodAsCString ( NormalizationAlgorithmMethod method )

Definition at line 210 of file TypesUtils.hpp.

References LocalBrightness, and LocalContrast.

Referenced by StringifyLayerParameters< NormalizationDescriptor >::Serialize().

 {
     switch (method)
     {
         case NormalizationAlgorithmMethod::LocalBrightness: return "LocalBrightness";
         case NormalizationAlgorithmMethod::LocalContrast:   return "LocalContrast";
         default:                                            return "Unknown";
     }
 }

◆ GetOffset()

unsigned int armnn::GetOffset	(	const TensorShape &	shape,
		unsigned int	b,
		unsigned int	h,
		unsigned int	w,
		unsigned int	c,
		const DataLayoutIndexed &	dataLayout
	)

Definition at line 15 of file SpaceToBatchNd.cpp.

References DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetDataLayout(), DataLayoutIndexed::GetHeightIndex(), DataLayoutIndexed::GetWidthIndex(), and NHWC.

Referenced by SpaceToBatchNd(), and SpaceToDepth().

 {
     if (dataLayout.GetDataLayout() == DataLayout::NHWC)
     {
         return ((b * shape[dataLayout.GetHeightIndex()] + h) * shape[dataLayout.GetWidthIndex()] + w) *
                shape[dataLayout.GetChannelsIndex()] + c;
     }
     else
     {
         return ((b * shape[dataLayout.GetChannelsIndex()] + c) * shape[dataLayout.GetHeightIndex()] + h) *
                shape[dataLayout.GetWidthIndex()] + w;
     }
 }

◆ GetOutputShapeRoundingAsCString()

constexpr char const* armnn::GetOutputShapeRoundingAsCString ( OutputShapeRounding rounding )

Definition at line 95 of file TypesUtils.hpp.

References Ceiling, and Floor.

Referenced by StringifyLayerParameters< Pooling2dDescriptor >::Serialize().

 {
     switch (rounding)
     {
         case OutputShapeRounding::Ceiling:  return "Ceiling";
         case OutputShapeRounding::Floor:    return "Floor";
         default:                            return "Unknown";
     }
 }

◆ GetOutputTensorData()

DataType* armnn::GetOutputTensorData	(	unsigned int	idx,
		const PayloadType &	data
	)

Definition at line 42 of file RefWorkloadUtils.hpp.

References ITensorHandle::Map().

 {
     ITensorHandle* tensorHandle = data.m_Outputs[idx];
     return reinterpret_cast<DataType*>(tensorHandle->Map());
 }

◆ GetOutputTensorDataBFloat16()

BFloat16* armnn::GetOutputTensorDataBFloat16	(	unsigned int	idx,
		const PayloadType &	data
	)

Definition at line 79 of file RefWorkloadUtils.hpp.

Referenced by RefConvertFp32ToBf16Workload::Execute().

 {
     return GetOutputTensorData<BFloat16>(idx, data);
 }

◆ GetOutputTensorDataFloat()

float* armnn::GetOutputTensorDataFloat	(	unsigned int	idx,
		const PayloadType &	data
	)

Definition at line 55 of file RefWorkloadUtils.hpp.

Referenced by RefConvertBf16ToFp32Workload::Execute(), RefFakeQuantizationFloat32Workload::Execute(), and RefConvertFp16ToFp32Workload::Execute().

 {
     return GetOutputTensorData<float>(idx, data);
 }

◆ GetOutputTensorDataHalf()

Half* armnn::GetOutputTensorDataHalf	(	unsigned int	idx,
		const PayloadType &	data
	)

Definition at line 67 of file RefWorkloadUtils.hpp.

Referenced by RefConvertFp32ToFp16Workload::Execute().

 {
     return GetOutputTensorData<Half>(idx, data);
 }

◆ GetPaddingMethodAsCString()

constexpr char const* armnn::GetPaddingMethodAsCString ( PaddingMethod method )

Definition at line 105 of file TypesUtils.hpp.

References Exclude, and IgnoreValue.

Referenced by StringifyLayerParameters< Pooling2dDescriptor >::Serialize().

 {
     switch (method)
     {
         case PaddingMethod::Exclude:       return "Exclude";
         case PaddingMethod::IgnoreValue:   return "IgnoreValue";
         default:                           return "Unknown";
     }
 }

◆ GetPoolingAlgorithmAsCString()

constexpr char const* armnn::GetPoolingAlgorithmAsCString ( PoolingAlgorithm pooling )

Definition at line 84 of file TypesUtils.hpp.

References Average, L2, and Max.

Referenced by StringifyLayerParameters< Pooling2dDescriptor >::Serialize().

 {
     switch (pooling)
     {
         case PoolingAlgorithm::Average:  return "Average";
         case PoolingAlgorithm::Max:      return "Max";
         case PoolingAlgorithm::L2:       return "L2";
         default:                         return "Unknown";
     }
 }

◆ GetProfilerEventSequenceSize()

size_t armnn::GetProfilerEventSequenceSize ( armnn::Profiler * profiler )

Definition at line 22 of file ProfilerTests.cpp.

References BOOST_AUTO_TEST_SUITE(), ProfilerManager::GetInstance(), ProfilerManager::GetProfiler(), and ProfilerManager::RegisterProfiler().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     if (!profiler)
     {
         return static_cast<size_t>(-1);
     }
 
     return profiler->m_EventSequence.size();
 }

◆ GetProfilingService()

profiling::ProfilingService & GetProfilingService ( armnn::Runtime * runtime )

Definition at line 25 of file TestUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), CheckRelatedLayers(), and VerifyPostOptimisationStructureTestImpl().

 {
     return runtime->m_ProfilingService;
 }

◆ GetResizeMethodAsCString()

constexpr const char* armnn::GetResizeMethodAsCString ( ResizeMethod method )

Definition at line 220 of file TypesUtils.hpp.

References Bilinear, and NearestNeighbor.

Referenced by StringifyLayerParameters< ResizeDescriptor >::Serialize().

 {
     switch (method)
     {
         case ResizeMethod::Bilinear:        return "Bilinear";
         case ResizeMethod::NearestNeighbor: return "NearestNeighbour";
         default:                            return "Unknown";
     }
 }

◆ GetStatusAsCString()

constexpr char const* armnn::GetStatusAsCString ( Status status )

Definition at line 17 of file TypesUtils.hpp.

References Failure, and Success.

Referenced by operator<<().

 {
     switch (status)
     {
         case armnn::Status::Success: return "Status::Success";
         case armnn::Status::Failure: return "Status::Failure";
         default:                     return "Unknown";
     }
 }

◆ GetTensorInfo()

const TensorInfo& armnn::GetTensorInfo ( const ITensorHandle * tensorHandle )

inline

float32 helpers

Definition at line 26 of file RefWorkloadUtils.hpp.

References RefTensorHandle::GetTensorInfo().

 {
     // We know that reference workloads use RefTensorHandles for inputs and outputs
     const RefTensorHandle* refTensorHandle =
         PolymorphicDowncast<const RefTensorHandle*>(tensorHandle);
     return refTensorHandle->GetTensorInfo();
 }

◆ GetTimeDuration()

std::chrono::duration<double, std::milli> armnn::GetTimeDuration ( std::chrono::high_resolution_clock::time_point start_time )

inline

Definition at line 19 of file Timer.hpp.

References GetTimeNow().

Referenced by InferenceModel< IParser, TDataType >::InferenceModel(), InferenceModel< IParser, TDataType >::Run(), RunCLTuning(), Runtime::Runtime(), and Runtime::~Runtime().

 {
     return std::chrono::duration<double, std::milli>(GetTimeNow() - start_time);
 }

◆ GetTimeNow()

std::chrono::high_resolution_clock::time_point armnn::GetTimeNow ( )

inline

Definition at line 14 of file Timer.hpp.

Referenced by GetTimeDuration(), InferenceModel< IParser, TDataType >::InferenceModel(), InferenceModel< IParser, TDataType >::Run(), RunCLTuning(), Runtime::Runtime(), and Runtime::~Runtime().

 {
     return std::chrono::high_resolution_clock::now();
 }

◆ GetUnaryOperationAsCString()

constexpr char const* armnn::GetUnaryOperationAsCString ( UnaryOperation operation )

Definition at line 71 of file TypesUtils.hpp.

References Abs, Exp, Neg, Rsqrt, and Sqrt.

Referenced by RefElementwiseUnaryWorkload::Execute().

 {
     switch (operation)
     {
         case UnaryOperation::Abs:   return "Abs";
         case UnaryOperation::Exp:   return "Exp";
         case UnaryOperation::Sqrt:  return "Sqrt";
         case UnaryOperation::Rsqrt: return "Rsqrt";
         case UnaryOperation::Neg:   return "Neg";
         default:                    return "Unknown";
     }
 }

◆ GetUnpaddedTensorStrides()

TensorShape GetUnpaddedTensorStrides ( const TensorInfo & tensorInfo )

Definition at line 15 of file CpuTensorHandle.cpp.

References TensorInfo::GetDataType(), GetDataTypeSize(), and TensorInfo::GetShape().

Referenced by RefTensorHandle::GetStrides(), SampleTensorHandle::GetStrides(), and ConstCpuTensorHandle::GetStrides().

 {
     TensorShape shape(tensorInfo.GetShape());
     auto size = GetDataTypeSize(tensorInfo.GetDataType());
     auto runningSize = size;
     std::vector<unsigned int> strides(shape.GetNumDimensions());
     auto lastIdx = shape.GetNumDimensions()-1;
     for (unsigned int i=0; i < lastIdx ; i++)
     {
         strides[lastIdx-i] = runningSize;
         runningSize *= shape[lastIdx-i];
     }
     strides[0] = runningSize;
     return TensorShape(shape.GetNumDimensions(), strides.data());
 }

◆ IgnoreUnused()

void armnn::IgnoreUnused ( Ts && ... )

inline

Definition at line 14 of file IgnoreUnused.hpp.

14 {}

◆ InitializeArmComputeClTensorData()

void armnn::InitializeArmComputeClTensorData	(	arm_compute::CLTensor &	clTensor,
		const ConstCpuTensorHandle *	handle
	)

inline

Definition at line 90 of file ClWorkloadUtils.hpp.

References ARMNN_ASSERT.

 {
     ARMNN_ASSERT(handle);
 
     armcomputetensorutils::InitialiseArmComputeTensorEmpty(clTensor);
     switch(handle->GetTensorInfo().GetDataType())
     {
         case DataType::Float16:
             CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<armnn::Half>());
             break;
         case DataType::Float32:
             CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<float>());
             break;
         case DataType::QAsymmS8:
         case DataType::QAsymmU8:
             CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<uint8_t>());
             break;
         ARMNN_NO_DEPRECATE_WARN_BEGIN
         case DataType::QuantizedSymm8PerAxis:
             ARMNN_FALLTHROUGH;
         case DataType::QSymmS8:
             CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<int8_t>());
             break;
         case DataType::QSymmS16:
             CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<int16_t>());
             break;
         ARMNN_NO_DEPRECATE_WARN_END
         case DataType::Signed32:
             CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<int32_t>());
             break;
         default:
             ARMNN_ASSERT_MSG(false, "Unexpected tensor type.");
     }
 };

◆ InitializeArmComputeTensorData()

void armnn::InitializeArmComputeTensorData	(	arm_compute::Tensor &	tensor,
		const ConstCpuTensorHandle *	handle
	)

inline

Definition at line 35 of file NeonWorkloadUtils.hpp.

References ARMNN_ASSERT, ARMNN_ASSERT_MSG, ARMNN_FALLTHROUGH, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, CopyArmComputeTensorData(), Float16, Float32, ConstCpuTensorHandle::GetConstTensor(), TensorInfo::GetDataType(), ConstCpuTensorHandle::GetTensorInfo(), QAsymmS8, QAsymmU8, QSymmS16, QSymmS8, QuantizedSymm8PerAxis, and Signed32.

 {
     ARMNN_ASSERT(handle);
 
     switch(handle->GetTensorInfo().GetDataType())
     {
         case DataType::Float16:
             CopyArmComputeTensorData(tensor, handle->GetConstTensor<armnn::Half>());
             break;
         case DataType::Float32:
             CopyArmComputeTensorData(tensor, handle->GetConstTensor<float>());
             break;
         case DataType::QAsymmU8:
             CopyArmComputeTensorData(tensor, handle->GetConstTensor<uint8_t>());
             break;
         ARMNN_NO_DEPRECATE_WARN_BEGIN
         case DataType::QuantizedSymm8PerAxis:
             ARMNN_FALLTHROUGH;
         case DataType::QSymmS8:
         case DataType::QAsymmS8:
             CopyArmComputeTensorData(tensor, handle->GetConstTensor<int8_t>());
             break;
         ARMNN_NO_DEPRECATE_WARN_END
         case DataType::Signed32:
             CopyArmComputeTensorData(tensor, handle->GetConstTensor<int32_t>());
             break;
         case DataType::QSymmS16:
             CopyArmComputeTensorData(tensor, handle->GetConstTensor<int16_t>());
             break;
         default:
             ARMNN_ASSERT_MSG(false, "Unexpected tensor type.");
     }
 };

◆ InsertConvertBf16ToFp32LayersBefore()

std::vector< ConvertBf16ToFp32Layer * > InsertConvertBf16ToFp32LayersBefore	(	Graph &	graph,
		Layer &	layer,
		bool	expectCorrectInputType
	)

Definition at line 51 of file NetworkUtils.cpp.

References Layer::BeginInputSlots(), BFloat16, Layer::EndInputSlots(), Float32, InputSlot::GetConnectedOutputSlot(), TensorInfo::GetDataType(), Layer::GetInputSlot(), Layer::GetName(), Layer::GetNumInputSlots(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), Graph::InsertNewLayer(), TensorInfo::SetDataType(), and OutputSlot::SetTensorInfo().

Referenced by AttemptBackendAssignment().

 {
     std::vector<ConvertBf16ToFp32Layer*> convertLayers;
     convertLayers.reserve(layer.GetNumInputSlots());
 
     // Insert a ConvertBf16ToFp32Layer before each input slot
     for (auto&& inputSlot = layer.BeginInputSlots(); inputSlot != layer.EndInputSlots(); ++inputSlot)
     {
         bool allowInsert = true;
         if (expectCorrectInputType)
         {
             // Only insert ConvertBf16ToFp32Layer before BF16 input slots
             OutputSlot* connectedOutputSlot = inputSlot->GetConnectedOutputSlot();
             allowInsert =
                 connectedOutputSlot && connectedOutputSlot->GetTensorInfo().GetDataType() == DataType::BFloat16;
         }
 
         if (allowInsert)
         {
             const std::string name =
                 std::string("convert_bf16_to_fp32-" + std::to_string(inputSlot->GetSlotIndex()) + "-") +
                 layer.GetName();
             ConvertBf16ToFp32Layer* convertLayer =
                 graph.InsertNewLayer<ConvertBf16ToFp32Layer>(*inputSlot, name.c_str());
 
             TensorInfo convertInfo = convertLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo();
             convertInfo.SetDataType(DataType::Float32);
 
             convertLayer->GetOutputSlot().SetTensorInfo(convertInfo);
 
             convertLayers.emplace_back(convertLayer);
         }
     }
 
     return convertLayers;
 }

◆ InsertConvertFp16ToFp32LayersBefore()

std::vector< ConvertFp16ToFp32Layer * > InsertConvertFp16ToFp32LayersBefore	(	Graph &	graph,
		Layer &	layer,
		bool	expectCorrectInputType
	)

Definition at line 129 of file NetworkUtils.cpp.

References Layer::BeginInputSlots(), Layer::EndInputSlots(), Float16, Float32, InputSlot::GetConnectedOutputSlot(), TensorInfo::GetDataType(), Layer::GetInputSlot(), Layer::GetName(), Layer::GetNumInputSlots(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), Graph::InsertNewLayer(), TensorInfo::SetDataType(), and OutputSlot::SetTensorInfo().

Referenced by AttemptBackendAssignment(), BOOST_AUTO_TEST_CASE(), and ConvertFp32NetworkToFp16Impl::Run().

 {
     std::vector<ConvertFp16ToFp32Layer*> convertLayers;
     convertLayers.reserve(layer.GetNumInputSlots());
 
     // Insert a ConvertFp16ToFp32Layer before each input slot
     for (auto&& inputSlot = layer.BeginInputSlots(); inputSlot != layer.EndInputSlots(); ++inputSlot)
     {
         bool allowInsert = true;
         if (expectCorrectInputType)
         {
             // Only insert ConvertFp16ToFp32Layer before FP16 input slots
             OutputSlot* connectedOutputSlot = inputSlot->GetConnectedOutputSlot();
             allowInsert =
                 connectedOutputSlot && connectedOutputSlot->GetTensorInfo().GetDataType() == DataType::Float16;
         }
 
         if (allowInsert)
         {
             const std::string name =
                 std::string("convert_fp16_to_fp32-" + std::to_string(inputSlot->GetSlotIndex()) + "-") +
                 layer.GetName();
             ConvertFp16ToFp32Layer* convertLayer =
                 graph.InsertNewLayer<ConvertFp16ToFp32Layer>(*inputSlot, name.c_str());
 
             TensorInfo convertInfo = convertLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo();
             convertInfo.SetDataType(DataType::Float32);
 
             convertLayer->GetOutputSlot().SetTensorInfo(convertInfo);
 
             convertLayers.emplace_back(convertLayer);
         }
     }
 
     return convertLayers;
 }

◆ InsertConvertFp32ToBf16LayersAfter()

std::vector< ConvertFp32ToBf16Layer * > InsertConvertFp32ToBf16LayersAfter	(	Graph &	graph,
		Layer &	layer
	)

Definition at line 168 of file NetworkUtils.cpp.

References BFloat16, Float32, InputSlot::GetConnectedOutputSlot(), TensorInfo::GetDataType(), Layer::GetInputSlot(), Layer::GetName(), Layer::GetNumOutputSlots(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), Graph::InsertNewLayer(), TensorInfo::SetDataType(), and OutputSlot::SetTensorInfo().

Referenced by AttemptBackendAssignment().

 {
     const unsigned int numOutputSlots = layer.GetNumOutputSlots();
 
     std::vector<ConvertFp32ToBf16Layer*> convertLayers;
     convertLayers.reserve(numOutputSlots);
 
     // Update Bf16 output slots to FP32 on current layer
     ChangeOutputBf16ToFp32(layer);
 
     // Insert a ConvertFp32ToBf16Layer after each FP32 output slot
     for (unsigned int slotIndex = 0u; slotIndex < numOutputSlots; ++slotIndex)
     {
         OutputSlot& outputSlot = layer.GetOutputSlot(slotIndex);
         if(outputSlot.GetTensorInfo().GetDataType() == DataType::Float32)
         {
             const std::string name =
                 std::string("convert_fp32_to_bf16-" + std::to_string(slotIndex) + "-") + layer.GetName();
             ConvertFp32ToBf16Layer* convertLayer =
                 graph.InsertNewLayer<ConvertFp32ToBf16Layer>(outputSlot, name.c_str());
 
             TensorInfo convertInfo = convertLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo();
             convertInfo.SetDataType(DataType::BFloat16);
 
             convertLayer->GetOutputSlot().SetTensorInfo(convertInfo);
 
             convertLayers.emplace_back(convertLayer);
         }
     }
 
     return convertLayers;
 }

◆ InsertConvertFp32ToBf16LayersBefore()

std::vector< ConvertFp32ToBf16Layer * > InsertConvertFp32ToBf16LayersBefore	(	Graph &	graph,
		Layer &	layer,
		bool	expectCorrectInputType
	)

Definition at line 90 of file NetworkUtils.cpp.

References Layer::BeginInputSlots(), BFloat16, Layer::EndInputSlots(), Float32, InputSlot::GetConnectedOutputSlot(), TensorInfo::GetDataType(), Layer::GetInputSlot(), Layer::GetName(), Layer::GetNumInputSlots(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), Graph::InsertNewLayer(), TensorInfo::SetDataType(), and OutputSlot::SetTensorInfo().

Referenced by ConvertFp32NetworkToBf16Impl::Run().

 {
     std::vector<ConvertFp32ToBf16Layer*> convertLayers;
     convertLayers.reserve(layer.GetNumInputSlots());
 
     // Insert a ConvertFp32ToBf16Layer before each input slot
     for (auto&& inputSlot = layer.BeginInputSlots(); inputSlot != layer.EndInputSlots(); ++inputSlot)
     {
         bool allowInsert = true;
         if (expectCorrectInputType)
         {
             // Only insert ConvertFp32ToBf16Layer before FP32 input slots
             OutputSlot* connectedOutputSlot = inputSlot->GetConnectedOutputSlot();
             allowInsert =
                 connectedOutputSlot && connectedOutputSlot->GetTensorInfo().GetDataType() == DataType::Float32;
         }
 
         if (allowInsert)
         {
             const std::string name =
                 std::string("convert_fp32_to_bf16-" + std::to_string(inputSlot->GetSlotIndex()) + "-") +
                 layer.GetName();
             ConvertFp32ToBf16Layer* convertLayer =
                 graph.InsertNewLayer<ConvertFp32ToBf16Layer>(*inputSlot, name.c_str());
 
             TensorInfo convertInfo = convertLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo();
             convertInfo.SetDataType(DataType::BFloat16);
 
             convertLayer->GetOutputSlot().SetTensorInfo(convertInfo);
 
             convertLayers.emplace_back(convertLayer);
         }
     }
 
     return convertLayers;
 }

◆ InsertConvertFp32ToFp16LayersAfter()

std::vector< ConvertFp32ToFp16Layer * > InsertConvertFp32ToFp16LayersAfter	(	Graph &	graph,
		Layer &	layer
	)

Definition at line 201 of file NetworkUtils.cpp.

References Float16, Float32, InputSlot::GetConnectedOutputSlot(), TensorInfo::GetDataType(), Layer::GetInputSlot(), Layer::GetName(), Layer::GetNumOutputSlots(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), Graph::InsertNewLayer(), TensorInfo::SetDataType(), and OutputSlot::SetTensorInfo().

Referenced by AttemptBackendAssignment(), BOOST_AUTO_TEST_CASE(), and ConvertFp32NetworkToFp16Impl::Run().

 {
     const unsigned int numOutputSlots = layer.GetNumOutputSlots();
 
     std::vector<ConvertFp32ToFp16Layer*> convertLayers;
     convertLayers.reserve(numOutputSlots);
 
     // Update FP16 output slots to FP32 on current layer
     ChangeOutputFp16ToFp32(layer);
 
     // Insert a ConvertFp32ToFp16Layer after each FP32 output slot
     for (unsigned int slotIndex = 0u; slotIndex < numOutputSlots; ++slotIndex)
     {
         OutputSlot& outputSlot = layer.GetOutputSlot(slotIndex);
         if(outputSlot.GetTensorInfo().GetDataType() == DataType::Float32)
         {
             const std::string name =
                 std::string("convert_fp32_to_fp16-" + std::to_string(slotIndex) + "-") + layer.GetName();
             ConvertFp32ToFp16Layer* convertLayer =
                 graph.InsertNewLayer<ConvertFp32ToFp16Layer>(outputSlot, name.c_str());
 
             TensorInfo convertInfo = convertLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo();
             convertInfo.SetDataType(DataType::Float16);
 
             convertLayer->GetOutputSlot().SetTensorInfo(convertInfo);
 
             convertLayers.emplace_back(convertLayer);
         }
     }
 
     return convertLayers;
 }

◆ InsertDebugLayerAfter()

std::vector< DebugLayer * > InsertDebugLayerAfter	(	Graph &	graph,
		Layer &	layer
	)

Definition at line 234 of file NetworkUtils.cpp.

References ARMNN_ASSERT, Layer::BeginOutputSlots(), CpuRef, Layer::EndOutputSlots(), InputSlot::GetConnectedOutputSlot(), Layer::GetInputSlot(), Layer::GetNameStr(), Layer::GetNumOutputSlots(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), Graph::InsertNewLayer(), Layer::SetBackendId(), and OutputSlot::SetTensorInfo().

Referenced by DynamicQuantizationVisitor::FinishVisit(), and AddDebugImpl::Run().

 {
     std::vector<DebugLayer*> debugLayers;
     debugLayers.reserve(layer.GetNumOutputSlots());
 
     // Connect a DebugLayer to each output slot of the layer
     for (auto outputSlot = layer.BeginOutputSlots(); outputSlot != layer.EndOutputSlots(); ++outputSlot)
     {
         const std::string debugName = std::string("DebugLayerAfter") + layer.GetNameStr();
 
         DebugLayer* debugLayer =
             graph.InsertNewLayer<DebugLayer>(*outputSlot, debugName.c_str());
 
         // Sets output tensor info for the debug layer.
         ARMNN_ASSERT(debugLayer->GetInputSlot(0).GetConnectedOutputSlot() == &(*outputSlot));
         TensorInfo debugInfo = debugLayer->GetInputSlot(0).GetConnectedOutputSlot()->GetTensorInfo();
 
         debugLayer->GetOutputSlot().SetTensorInfo(debugInfo);
 
         // NOTE: It is OK to do this because DebugLayer is only supported on CpuRef
         debugLayer->SetBackendId(Compute::CpuRef);
 
         debugLayers.emplace_back(debugLayer);
     }
 
     return debugLayers;
 }

◆ InstanceNorm()

void InstanceNorm	(	const InstanceNormalizationQueueDescriptor &	data,
		Decoder< float > &	inputDecoder,
		Encoder< float > &	outputEncoder
	)

Definition at line 18 of file InstanceNorm.cpp.

References Decoder< IType >::Get(), DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), DataLayoutIndexed::GetIndex(), TensorInfo::GetShape(), GetTensorInfo(), DataLayoutIndexed::GetWidthIndex(), InstanceNormalizationDescriptor::m_Beta, InstanceNormalizationDescriptor::m_DataLayout, InstanceNormalizationDescriptor::m_Eps, InstanceNormalizationDescriptor::m_Gamma, QueueDescriptor::m_Inputs, QueueDescriptorWithParameters< LayerDescriptor >::m_Parameters, and Encoder< IType >::Set().

Referenced by RefInstanceNormalizationWorkload::Execute().

 {
     const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[0]);
     const TensorShape inputShape = inputInfo.GetShape();
 
     armnnUtils::DataLayoutIndexed dataLayout(data.m_Parameters.m_DataLayout);
 
     unsigned int inputBatches  = inputShape[0];
     unsigned int inputHeight   = inputShape[dataLayout.GetHeightIndex()];
     unsigned int inputWidth    = inputShape[dataLayout.GetWidthIndex()];
     unsigned int inputChannels = inputShape[dataLayout.GetChannelsIndex()];
 
     float beta  = data.m_Parameters.m_Beta;
     float eps   = data.m_Parameters.m_Eps;
     float gamma = data.m_Parameters.m_Gamma;
 
     for (unsigned int n = 0; n < inputBatches; ++n)
     {
         for (unsigned int c = 0; c < inputChannels; ++c)
         {
             float mean = 0, var = 0;
 
             //Calculate Mean
             for (unsigned int h = 0; h < inputHeight; h++)
             {
                 for (unsigned int w = 0; w < inputWidth; w++)
                 {
                     unsigned int index = dataLayout.GetIndex(inputShape, n, c, h, w);
 
                     inputDecoder[index];
                     float value = inputDecoder.Get();
                     mean += value;
                 }
             }
             mean /= static_cast<float>(inputHeight * inputWidth);
 
             //Calculate Variance
             for (unsigned int h = 0; h < inputHeight; h++)
             {
                 for (unsigned int w = 0; w < inputWidth; w++)
                 {
                     unsigned int index = dataLayout.GetIndex(inputShape, n, c, h, w);
 
                     inputDecoder[index];
                     float value = inputDecoder.Get();
                     var += (value - mean) * (value - mean);
                 }
             }
             var /= static_cast<float>(inputHeight * inputWidth);
 
             // Apply Instance Normalisation
             for (unsigned int h = 0; h < inputHeight; ++h)
             {
                 for (unsigned int w = 0; w < inputWidth; ++w)
                 {
                     unsigned int index = dataLayout.GetIndex(inputShape, n, c, h, w);
                     inputDecoder[index];
                     outputEncoder[index];
                     outputEncoder.Set((inputDecoder.Get() - mean) * gamma /  std::sqrt ( var + eps) + beta);
                 }
 
             }
         }
     }
 }

◆ IntersectionOverUnion()

float IntersectionOverUnion	(	const float *	boxI,
		const float *	boxJ
	)

Definition at line 31 of file DetectionPostProcess.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), and NonMaxSuppression().

 {
     // Box-corner format: ymin, xmin, ymax, xmax.
     const int yMin = 0;
     const int xMin = 1;
     const int yMax = 2;
     const int xMax = 3;
     float areaI = (boxI[yMax] - boxI[yMin]) * (boxI[xMax] - boxI[xMin]);
     float areaJ = (boxJ[yMax] - boxJ[yMin]) * (boxJ[xMax] - boxJ[xMin]);
     float yMinIntersection = std::max(boxI[yMin], boxJ[yMin]);
     float xMinIntersection = std::max(boxI[xMin], boxJ[xMin]);
     float yMaxIntersection = std::min(boxI[yMax], boxJ[yMax]);
     float xMaxIntersection = std::min(boxI[xMax], boxJ[xMax]);
     float areaIntersection = std::max(yMaxIntersection - yMinIntersection, 0.0f) *
                                 std::max(xMaxIntersection - xMinIntersection, 0.0f);
     float areaUnion = areaI + areaJ - areaIntersection;
     return areaIntersection / areaUnion;
 }

◆ IsActivationSupported()

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.

Definition at line 69 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

Referenced by BOOST_AUTO_TEST_CASE().

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsActivationSupported, input, output, descriptor);
 }

◆ IsAdditionSupported()

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.

Definition at line 79 of file LayerSupport.cpp.

References CheckTensorDataTypesEqual(), and FORWARD_LAYER_SUPPORT_FUNC.

 {
     if(!CheckTensorDataTypesEqual(input0, input1))
     {
         return false;
     }
 
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsAdditionSupported, input0, input1, output);
 }

◆ IsArgMinMaxSupported()

bool armnn::IsArgMinMaxSupported	(	const BackendId &	backend,
		const TensorInfo &	input,
		const TensorInfo &	output,
		const ArgMinMaxDescriptor &	descriptor,
		char *	reasonIfUnsupported,
		size_t	reasonIfUnsupportedMaxLength
	)

Definition at line 94 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsArgMinMaxSupported, input, output, descriptor);
 }

◆ IsBatchNormalizationSupported()

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.

Definition at line 104 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend,
                                IsBatchNormalizationSupported,
                                input,
                                output,
                                mean,
                                var,
                                beta,
                                gamma,
                                descriptor);
 }

◆ IsBatchToSpaceNdSupported()

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.

Definition at line 126 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend,
                                IsBatchToSpaceNdSupported,
                                input,
                                output,
                                descriptor);
 }

◆ IsBFloat16()

bool armnn::IsBFloat16 ( const WorkloadInfo & info )

Definition at line 54 of file RefWorkloadFactory.cpp.

References info.

Referenced by RefWorkloadFactory::CreateDebug(), RefWorkloadFactory::CreatePermute(), and RefWorkloadFactory::CreateTranspose().

 {
     return IsDataType<DataType::BFloat16>(info);
 }

◆ IsConcatSupported() [1/2]

bool armnn::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.

Referenced by IsConcatSupported(), and RefLayerSupport::IsMergerSupported().

◆ IsConcatSupported() [2/2]

bool armnn::IsConcatSupported	(	const BackendId &	backend,
		std::vector< const TensorInfo *>	inputs,
		const TensorInfo &	output,
		const OriginsDescriptor &	descriptor,
		char *	reasonIfUnsupported,
		size_t	reasonIfUnsupportedMaxLength
	)

Definition at line 140 of file LayerSupport.cpp.

References ARMNN_ASSERT, FORWARD_LAYER_SUPPORT_FUNC, and IsConcatSupported().

 {
     ARMNN_ASSERT(inputs.size() > 0);
 
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsConcatSupported, inputs, output, descriptor);
 }

◆ IsConstantSupported()

bool IsConstantSupported	(	const BackendId &	backend,
		const TensorInfo &	output,
		char *	reasonIfUnsupported = `nullptr`,
		size_t	reasonIfUnsupportedMaxLength = `1024`
	)

Deprecated in favor of IBackend and ILayerSupport interfaces.

Definition at line 152 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsConstantSupported, output);
 }

◆ IsConvertFp16ToFp32Supported()

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.

Definition at line 160 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsConvertFp16ToFp32Supported, input, output);
 }

◆ IsConvertFp32ToFp16Supported()

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.

Definition at line 169 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsConvertFp32ToFp16Supported, input, output);
 }

◆ IsConvolution2dSupported()

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.

Definition at line 178 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsConvolution2dSupported, input, output, descriptor, weights, biases);
 }

◆ IsDataType()

bool armnn::IsDataType ( const WorkloadInfo & info )

Definition at line 33 of file RefWorkloadFactory.cpp.

References WorkloadInfo::m_InputTensorInfos, and WorkloadInfo::m_OutputTensorInfos.

 {
     auto checkType = [](const TensorInfo& tensorInfo) {return tensorInfo.GetDataType() == ArmnnType;};
     auto it = std::find_if(std::begin(info.m_InputTensorInfos), std::end(info.m_InputTensorInfos), checkType);
     if (it != std::end(info.m_InputTensorInfos))
     {
         return true;
     }
     it = std::find_if(std::begin(info.m_OutputTensorInfos), std::end(info.m_OutputTensorInfos), checkType);
     if (it != std::end(info.m_OutputTensorInfos))
     {
         return true;
     }
     return false;
 }

◆ IsDebugSupported()

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.

Definition at line 190 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsDebugSupported, input, output);
 }

◆ IsDepthwiseConvolutionSupported()

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.

Definition at line 199 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC, DepthwiseConvolution2dDescriptor::m_DilationX, and DepthwiseConvolution2dDescriptor::m_DilationY.

Referenced by RefLayerSupport::IsDilatedDepthwiseConvolutionSupported().

 {
     if (descriptor.m_DilationX == 1 && descriptor.m_DilationY == 1)
     {
         // Pre 19.05 ArmNN did not have the dilation parameters.
         // This version of IsDepthwiseConvolutionSupported is called for backwards-compatibility
         FORWARD_LAYER_SUPPORT_FUNC(backend,
                                    IsDepthwiseConvolutionSupported,
                                    input,
                                    output,
                                    descriptor,
                                    weights,
                                    biases);
     }
     else
     {
         FORWARD_LAYER_SUPPORT_FUNC(backend,
                                    IsDilatedDepthwiseConvolutionSupported,
                                    input,
                                    output,
                                    descriptor,
                                    weights,
                                    biases);
     }
 }

◆ IsDequantizeSupported()

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.

Definition at line 232 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC, and IsDetectionPostProcessSupported().

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsDequantizeSupported, input, output);
 }

◆ IsDetectionPostProcessSupported()

bool armnn::IsDetectionPostProcessSupported	(	const BackendId &	backend,
		const TensorInfo &	input0,
		const TensorInfo &	input1,
		const DetectionPostProcessDescriptor &	descriptor,
		char *	reasonIfUnsupported,
		size_t	reasonIfUnsupportedMaxLength
	)

Referenced by IsDequantizeSupported().

◆ IsDivisionSupported()

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.

Definition at line 248 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsDivisionSupported, input0, input1, output);
 }

◆ IsEqualSupported()

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.

Definition at line 258 of file LayerSupport.cpp.

References Equal, and FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend,
                                IsComparisonSupported,
                                input0,
                                input1,
                                output,
                                ComparisonDescriptor(ComparisonOperation::Equal));
 }

◆ IsFakeQuantizationSupported()

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.

Definition at line 273 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsFakeQuantizationSupported, input, descriptor);
 }

◆ IsFloat16()

bool armnn::IsFloat16 ( const WorkloadInfo & info )

Definition at line 59 of file RefWorkloadFactory.cpp.

References info.

Referenced by RefWorkloadFactory::CreateDebug().

 {
     return IsDataType<DataType::Float16>(info);
 }

◆ IsFloorSupported()

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.

Definition at line 282 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC, TensorInfo::GetDataType(), and TensorInfo::GetShape().

 {
     // By definition (that is, regardless of compute device), shapes and data type must match.
     if (input.GetShape() != output.GetShape() || input.GetDataType() != output.GetDataType())
     {
         return false;
     }
 
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsFloorSupported, input, output);
 }

◆ IsFullyConnectedSupported()

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.

Definition at line 296 of file LayerSupport.cpp.

References ARMNN_DEPRECATED_MSG, and FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsFullyConnectedSupported, input, output, weights, biases, descriptor);
 }

◆ IsGatherSupported() [1/2]

bool armnn::IsGatherSupported	(	const BackendId &	backend,
		const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output,
		char *	reasonIfUnsupported,
		size_t	reasonIfUnsupportedMaxLength
	)

Definition at line 309 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

Referenced by IsGatherSupported().

 {
     const GatherDescriptor descriptor{};
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsGatherSupported, input0, input1, output, descriptor);
 }

◆ IsGatherSupported() [2/2]

bool armnn::IsGatherSupported	(	const BackendId &	backend,
		const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output,
		const GatherDescriptor &	descriptor,
		char *	reasonIfUnsupported,
		size_t	reasonIfUnsupportedMaxLength
	)

Definition at line 320 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC, and IsGatherSupported().

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsGatherSupported, input0, input1, output, descriptor);
 }

◆ IsGreaterSupported()

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.

Definition at line 331 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC, and Greater.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend,
                                IsComparisonSupported,
                                input0,
                                input1,
                                output,
                                ComparisonDescriptor(ComparisonOperation::Greater));
 }

◆ IsInputSupported()

bool IsInputSupported	(	const BackendId &	backend,
		const TensorInfo &	input,
		char *	reasonIfUnsupported = `nullptr`,
		size_t	reasonIfUnsupportedMaxLength = `1024`
	)

Deprecated in favor of IBackend and ILayerSupport interfaces.

Definition at line 346 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

Referenced by BOOST_AUTO_TEST_CASE().

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsInputSupported, input);
 }

◆ IsL2NormalizationSupported()

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.

Definition at line 355 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsL2NormalizationSupported, input, output, descriptor);
 }

◆ IsLstmSupported()

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.

Definition at line 365 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsLstmSupported, input, outputStateIn, cellStateIn,
                                scratchBuffer, outputStateOut, cellStateOut,
                                output, descriptor, paramsInfo);
 }

◆ IsMaximumSupported()

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.

Definition at line 378 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsMaximumSupported, input0, input1, output);
 }

◆ IsMeanSupported()

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.

Definition at line 388 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsMeanSupported, input, output, descriptor);
 }

◆ IsMemCopySupported()

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.

Definition at line 398 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsMemCopySupported, input, output);
 }

◆ IsMemImportSupported()

bool armnn::IsMemImportSupported	(	const BackendId &	backend,
		const TensorInfo &	input,
		const TensorInfo &	output,
		char *	reasonIfUnsupported,
		size_t	reasonIfUnsupportedMaxLength
	)

Definition at line 407 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsMemImportSupported, input, output);
 }

◆ IsMergerSupported() [1/2]

bool armnn::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.

Referenced by IsMergerSupported().

◆ IsMergerSupported() [2/2]

bool armnn::IsMergerSupported	(	const BackendId &	backend,
		std::vector< const TensorInfo *>	inputs,
		const TensorInfo &	output,
		const OriginsDescriptor &	descriptor,
		char *	reasonIfUnsupported,
		size_t	reasonIfUnsupportedMaxLength
	)

Definition at line 427 of file LayerSupport.cpp.

References ARMNN_ASSERT, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, FORWARD_LAYER_SUPPORT_FUNC, and IsMergerSupported().

 {
     ARMNN_ASSERT(inputs.size() > 0);
 
     ARMNN_NO_DEPRECATE_WARN_BEGIN
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsMergerSupported, inputs, output, descriptor);
     ARMNN_NO_DEPRECATE_WARN_END
 }

◆ IsMergeSupported()

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.

Definition at line 416 of file LayerSupport.cpp.

References ARMNN_DEPRECATED_MSG, and FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsMergeSupported, input0, input1, output);
 }

◆ IsMinimumSupported()

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.

Definition at line 441 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsMinimumSupported, input0, input1, output);
 }

◆ IsMultiplicationSupported()

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.

Definition at line 451 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsMultiplicationSupported, input0, input1, output);
 }

◆ IsNormalizationSupported()

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.

Definition at line 461 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsNormalizationSupported, input, output, descriptor);
 }

◆ IsOperationQueueDescriptor() [1/4]

constexpr bool armnn::IsOperationQueueDescriptor ( const QueueDescriptorType & )

Definition at line 18 of file RefWorkloadFactory.hpp.

18 { return true; }

◆ IsOperationQueueDescriptor() [2/4]

constexpr bool armnn::IsOperationQueueDescriptor ( const MemCopyQueueDescriptor & )

Definition at line 21 of file RefWorkloadFactory.hpp.

21 { return false; }

◆ IsOperationQueueDescriptor() [3/4]

constexpr bool armnn::IsOperationQueueDescriptor ( const ConstantQueueDescriptor & )

Definition at line 24 of file RefWorkloadFactory.hpp.

24 { return false; }

◆ IsOperationQueueDescriptor() [4/4]

constexpr bool armnn::IsOperationQueueDescriptor ( const PermuteQueueDescriptor & )

Definition at line 27 of file RefWorkloadFactory.hpp.

27 { return false; }

◆ IsOutputSupported()

bool IsOutputSupported	(	const BackendId &	backend,
		const TensorInfo &	output,
		char *	reasonIfUnsupported = `nullptr`,
		size_t	reasonIfUnsupportedMaxLength = `1024`
	)

Deprecated in favor of IBackend and ILayerSupport interfaces.

Definition at line 471 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

Referenced by BOOST_AUTO_TEST_CASE().

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsOutputSupported, output);
 }

◆ IsPadSupported()

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.

Definition at line 479 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
 
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsPadSupported, input, output, descriptor);
 }

◆ IsPermuteSupported()

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.

Definition at line 531 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsPermuteSupported, input, output, descriptor);
 }

◆ IsPooling2dSupported()

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.

Definition at line 541 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsPooling2dSupported, input, output, descriptor);
 }

◆ IsPreCompiledSupported()

bool armnn::IsPreCompiledSupported	(	const BackendId &	backend,
		const TensorInfo &	input,
		char *	reasonIfUnsupported = `nullptr`,
		size_t	reasonIfUnsupportedMaxLength = `1024`
	)

Deprecated in favor of IBackend and ILayerSupport interfaces.

◆ IsPreluSupported()

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.

Definition at line 551 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsPreluSupported, input, alpha, output);
 }

◆ IsQAsymmS8()

bool armnn::IsQAsymmS8 ( const WorkloadInfo & info )

Definition at line 74 of file RefWorkloadFactory.cpp.

References info.

Referenced by RefWorkloadFactory::CreateDebug(), RefWorkloadFactory::CreatePermute(), and RefWorkloadFactory::CreateTranspose().

 {
     return IsDataType<DataType::QAsymmS8>(info);
 }

◆ IsQAsymmU8()

bool armnn::IsQAsymmU8 ( const WorkloadInfo & info )

Definition at line 79 of file RefWorkloadFactory.cpp.

References info.

Referenced by RefWorkloadFactory::CreateDebug().

 {
     return IsDataType<DataType::QAsymmU8>(info);
 }

◆ IsQLstmSupported()

bool armnn::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
	)

Definition at line 499 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsQLstmSupported, input, previousOutputIn, previousCellStateIn,
                                outputStateOut, cellStateOut, output, descriptor, paramsInfo);
 }

◆ IsQSymmS16()

bool armnn::IsQSymmS16 ( const WorkloadInfo & info )

Definition at line 64 of file RefWorkloadFactory.cpp.

References info.

Referenced by RefWorkloadFactory::CreateDebug(), RefWorkloadFactory::CreatePermute(), and RefWorkloadFactory::CreateTranspose().

 {
     return IsDataType<DataType::QSymmS16>(info);
 }

◆ IsQSymmS8()

bool armnn::IsQSymmS8 ( const WorkloadInfo & info )

Definition at line 69 of file RefWorkloadFactory.cpp.

References info.

Referenced by RefWorkloadFactory::CreateDebug().

 {
     return IsDataType<DataType::QSymmS8>(info);
 }

◆ IsQuantized8BitType()

constexpr bool armnn::IsQuantized8BitType ( DataType dataType )

Definition at line 241 of file TypesUtils.hpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, QAsymmS8, QAsymmU8, QSymmS8, and QuantizedSymm8PerAxis.

Referenced by GetBiasDataType(), RefLayerSupport::IsConvolution2dSupported(), RefLayerSupport::IsDepthwiseConvolutionSupported(), IsQuantizedType(), and RefLayerSupport::IsTransposeConvolution2dSupported().

 {
     ARMNN_NO_DEPRECATE_WARN_BEGIN
     return dataType == DataType::QAsymmU8        ||
            dataType == DataType::QAsymmS8        ||
            dataType == DataType::QSymmS8         ||
            dataType == DataType::QuantizedSymm8PerAxis;
     ARMNN_NO_DEPRECATE_WARN_END
 }

◆ IsQuantizedLstmSupported()

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.

Definition at line 516 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsQuantizedLstmSupported, input, previousCellStateIn, previousOutputIn,
                                cellStateOut, output, paramsInfo);
 }

◆ IsQuantizedType() [1/2]

constexpr bool armnn::IsQuantizedType ( )

Definition at line 236 of file TypesUtils.hpp.

Referenced by RefWorkloadFactory::CreateFloor(), TensorInfo::IsQuantized(), QuantizeQueueDescriptor::Validate(), and DequantizeQueueDescriptor::Validate().

 {
     return std::is_integral<T>::value;
 }

◆ IsQuantizedType() [2/2]

constexpr bool armnn::IsQuantizedType ( DataType dataType )

Definition at line 251 of file TypesUtils.hpp.

References IsQuantized8BitType(), and QSymmS16.

 {
     return dataType == DataType::QSymmS16 || IsQuantized8BitType(dataType);
 }

◆ IsQuantizeSupported()

bool armnn::IsQuantizeSupported	(	const BackendId &	backend,
		const TensorInfo &	input,
		const TensorInfo &	output,
		char *	reasonIfUnsupported,
		size_t	reasonIfUnsupportedMaxLength
	)

Definition at line 490 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsQuantizeSupported, input, output);
 }

◆ IsReadyForSplitAssignment()

bool armnn::IsReadyForSplitAssignment	(	LayerSelectionInfo::LayerInfoContainer &	layerInfos,
		LayerSelectionInfo &	layerInfo
	)

Definition at line 370 of file SubgraphViewSelector.cpp.

References ForEachLayerInput().

Referenced by SubgraphViewSelector::SelectSubgraphs().

 {
     bool ready = true;
     ForEachLayerInput(layerInfos, layerInfo,
                       [&ready](LayerSelectionInfo& parentInfo)
                           {
                               if (!parentInfo.m_IsProcessed)
                               {
                                   ready = false;
                               }
                           });
     return ready;
 }

◆ IsReshapeSupported() [1/2]

bool armnn::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.

Referenced by IsReshapeSupported().

◆ IsReshapeSupported() [2/2]

bool armnn::IsReshapeSupported	(	const BackendId &	backend,
		const TensorInfo &	input,
		const TensorInfo &	output,
		const ReshapeDescriptor &	descriptor,
		char *	reasonIfUnsupported,
		size_t	reasonIfUnsupportedMaxLength
	)

Definition at line 561 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC, and IsReshapeSupported().

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsReshapeSupported, input, output, descriptor);
 }

◆ IsResizeBilinearSupported()

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.

Definition at line 582 of file LayerSupport.cpp.

References Bilinear, FORWARD_LAYER_SUPPORT_FUNC, IsResizeSupported(), ResizeDescriptor::m_Method, ResizeDescriptor::m_TargetHeight, and ResizeDescriptor::m_TargetWidth.

 {
     ResizeDescriptor descriptor;
     descriptor.m_Method = ResizeMethod::Bilinear;
 
     const TensorShape& outputShape = output.GetShape();
     descriptor.m_TargetWidth  = outputShape[3];
     descriptor.m_TargetHeight = outputShape[2];
 
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsResizeSupported, input, output, descriptor);
 }

◆ IsResizeSupported()

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.

Definition at line 571 of file LayerSupport.cpp.

References ARMNN_DEPRECATED_MSG, and FORWARD_LAYER_SUPPORT_FUNC.

Referenced by IsResizeBilinearSupported().

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsResizeSupported, input, output, descriptor);
 }

◆ IsRsqrtSupported()

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.

Definition at line 598 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC, and Rsqrt.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend,
                                IsElementwiseUnarySupported,
                                input,
                                output,
                                ElementwiseUnaryDescriptor(UnaryOperation::Rsqrt));
 }

◆ IsSigned32()

bool armnn::IsSigned32 ( const WorkloadInfo & info )

Definition at line 49 of file RefWorkloadFactory.cpp.

References info.

Referenced by RefWorkloadFactory::CreateDebug().

 {
     return IsDataType<DataType::Signed32>(info);
 }

◆ IsSoftmaxSupported()

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.

Definition at line 611 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsSoftmaxSupported, input, output, descriptor);
 }

◆ IsSpaceToBatchNdSupported()

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.

Definition at line 621 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsSpaceToBatchNdSupported, input, output, descriptor);
 }

◆ IsSpaceToDepthSupported()

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.

Definition at line 631 of file LayerSupport.cpp.

References ARMNN_DEPRECATED_MSG, and FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsSpaceToDepthSupported, input, output, descriptor);
 }

◆ IsSplitterSupported() [1/2]

bool IsSplitterSupported	(	const BackendId &	backend,
		const TensorInfo &	input,
		const ViewsDescriptor &	descriptor,
		char *	reasonIfUnsupported = `nullptr`,
		size_t	reasonIfUnsupportedMaxLength = `1024`
	)

Definition at line 642 of file LayerSupport.cpp.

References ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, and FORWARD_LAYER_SUPPORT_FUNC.

Referenced by IsSplitterSupported().

 {
     ARMNN_NO_DEPRECATE_WARN_BEGIN
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsSplitterSupported, input, descriptor);
     ARMNN_NO_DEPRECATE_WARN_END
 }

◆ IsSplitterSupported() [2/2]

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.

Definition at line 653 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC, and IsSplitterSupported().

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsSplitterSupported, input, outputs, descriptor);
 }

◆ IsStackSupported()

bool armnn::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.

◆ IsStridedSliceSupported()

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.

Definition at line 663 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsStridedSliceSupported, input, output, descriptor);
 }

◆ IsSubtractionSupported()

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.

Definition at line 673 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsSubtractionSupported, input0, input1, output);
 }

◆ IsSupportedForDataTypeGeneric()

bool armnn::IsSupportedForDataTypeGeneric	(	Optional< std::string &>	reasonIfUnsupported,
		DataType	dataType,
		Float16Func	float16FuncPtr,
		Float32Func	float32FuncPtr,
		Uint8Func	uint8FuncPtr,
		Int32Func	int32FuncPtr,
		BooleanFunc	booleanFuncPtr,
		Params &&...	params
	)

Definition at line 27 of file LayerSupportCommon.hpp.

References Boolean, Float16, Float32, QAsymmU8, and Signed32.

Referenced by RefLayerSupport::IsConvertFp16ToFp32Supported(), RefLayerSupport::IsConvertFp32ToFp16Supported(), and NeonLayerSupport::IsFloorSupported().

 {
     switch(dataType)
     {
         case DataType::Float16:
             return float16FuncPtr(reasonIfUnsupported, std::forward<Params>(params)...);
         case DataType::Float32:
             return float32FuncPtr(reasonIfUnsupported, std::forward<Params>(params)...);
         case DataType::QAsymmU8:
             return uint8FuncPtr(reasonIfUnsupported, std::forward<Params>(params)...);
         case DataType::Signed32:
             return int32FuncPtr(reasonIfUnsupported, std::forward<Params>(params)...);
         case DataType::Boolean:
             return booleanFuncPtr(reasonIfUnsupported, std::forward<Params>(params)...);
         default:
             return false;
     }
 }

◆ IsSwitchSupported()

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.

Definition at line 683 of file LayerSupport.cpp.

References FORWARD_LAYER_SUPPORT_FUNC.

 {
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsSwitchSupported, input0, input1, output0, output1);
 }

◆ IsTransposeConvolution2dSupported()

bool armnn::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.

◆ LayerEnumOf() [1/63]

constexpr LayerType armnn::LayerEnumOf ( const T * = nullptr )

◆ LayerEnumOf() [2/63]

constexpr LayerType armnn::LayerEnumOf ( const ActivationLayer * )

Definition at line 99 of file LayersFwd.hpp.

◆ LayerEnumOf() [3/63]

constexpr LayerType armnn::LayerEnumOf ( const AdditionLayer * )

Definition at line 100 of file LayersFwd.hpp.

◆ LayerEnumOf() [4/63]

constexpr LayerType armnn::LayerEnumOf ( const ArgMinMaxLayer * )

Definition at line 101 of file LayersFwd.hpp.

◆ LayerEnumOf() [5/63]

constexpr LayerType armnn::LayerEnumOf ( const BatchNormalizationLayer * )

Definition at line 102 of file LayersFwd.hpp.

◆ LayerEnumOf() [6/63]

constexpr LayerType armnn::LayerEnumOf ( const BatchToSpaceNdLayer * )

Definition at line 103 of file LayersFwd.hpp.

◆ LayerEnumOf() [7/63]

constexpr LayerType armnn::LayerEnumOf ( const ComparisonLayer * )

Definition at line 104 of file LayersFwd.hpp.

◆ LayerEnumOf() [8/63]

constexpr LayerType armnn::LayerEnumOf ( const ConcatLayer * )

Definition at line 105 of file LayersFwd.hpp.

◆ LayerEnumOf() [9/63]

constexpr LayerType armnn::LayerEnumOf ( const ConstantLayer * )

Definition at line 106 of file LayersFwd.hpp.

◆ LayerEnumOf() [10/63]

constexpr LayerType armnn::LayerEnumOf ( const ConvertBf16ToFp32Layer * )

Definition at line 107 of file LayersFwd.hpp.

◆ LayerEnumOf() [11/63]

constexpr LayerType armnn::LayerEnumOf ( const ConvertFp16ToFp32Layer * )

Definition at line 108 of file LayersFwd.hpp.

◆ LayerEnumOf() [12/63]

constexpr LayerType armnn::LayerEnumOf ( const ConvertFp32ToBf16Layer * )

Definition at line 109 of file LayersFwd.hpp.

◆ LayerEnumOf() [13/63]

constexpr LayerType armnn::LayerEnumOf ( const ConvertFp32ToFp16Layer * )

Definition at line 110 of file LayersFwd.hpp.

◆ LayerEnumOf() [14/63]

constexpr LayerType armnn::LayerEnumOf ( const Convolution2dLayer * )

Definition at line 111 of file LayersFwd.hpp.

◆ LayerEnumOf() [15/63]

constexpr LayerType armnn::LayerEnumOf ( const DebugLayer * )

Definition at line 112 of file LayersFwd.hpp.

◆ LayerEnumOf() [16/63]

constexpr LayerType armnn::LayerEnumOf ( const DepthToSpaceLayer * )

Definition at line 113 of file LayersFwd.hpp.

◆ LayerEnumOf() [17/63]

constexpr LayerType armnn::LayerEnumOf ( const DepthwiseConvolution2dLayer * )

Definition at line 114 of file LayersFwd.hpp.

◆ LayerEnumOf() [18/63]

constexpr LayerType armnn::LayerEnumOf ( const DequantizeLayer * )

Definition at line 115 of file LayersFwd.hpp.

◆ LayerEnumOf() [19/63]

constexpr LayerType armnn::LayerEnumOf ( const DetectionPostProcessLayer * )

Definition at line 116 of file LayersFwd.hpp.

◆ LayerEnumOf() [20/63]

constexpr LayerType armnn::LayerEnumOf ( const DivisionLayer * )

Definition at line 117 of file LayersFwd.hpp.

◆ LayerEnumOf() [21/63]

constexpr LayerType armnn::LayerEnumOf ( const ElementwiseUnaryLayer * )

Definition at line 118 of file LayersFwd.hpp.

◆ LayerEnumOf() [22/63]

constexpr LayerType armnn::LayerEnumOf ( const FakeQuantizationLayer * )

Definition at line 119 of file LayersFwd.hpp.

◆ LayerEnumOf() [23/63]

constexpr LayerType armnn::LayerEnumOf ( const FillLayer * )

Definition at line 120 of file LayersFwd.hpp.

◆ LayerEnumOf() [24/63]

constexpr LayerType armnn::LayerEnumOf ( const FloorLayer * )

Definition at line 121 of file LayersFwd.hpp.

◆ LayerEnumOf() [25/63]

constexpr LayerType armnn::LayerEnumOf ( const FullyConnectedLayer * )

Definition at line 122 of file LayersFwd.hpp.

◆ LayerEnumOf() [26/63]

constexpr LayerType armnn::LayerEnumOf ( const GatherLayer * )

Definition at line 123 of file LayersFwd.hpp.

◆ LayerEnumOf() [27/63]

constexpr LayerType armnn::LayerEnumOf ( const InputLayer * )

Definition at line 124 of file LayersFwd.hpp.

◆ LayerEnumOf() [28/63]

constexpr LayerType armnn::LayerEnumOf ( const InstanceNormalizationLayer * )

Definition at line 125 of file LayersFwd.hpp.

◆ LayerEnumOf() [29/63]

constexpr LayerType armnn::LayerEnumOf ( const L2NormalizationLayer * )

Definition at line 126 of file LayersFwd.hpp.

◆ LayerEnumOf() [30/63]

constexpr LayerType armnn::LayerEnumOf ( const LogSoftmaxLayer * )

Definition at line 127 of file LayersFwd.hpp.

◆ LayerEnumOf() [31/63]

constexpr LayerType armnn::LayerEnumOf ( const LstmLayer * )

Definition at line 128 of file LayersFwd.hpp.

◆ LayerEnumOf() [32/63]

constexpr LayerType armnn::LayerEnumOf ( const MaximumLayer * )

Definition at line 129 of file LayersFwd.hpp.

◆ LayerEnumOf() [33/63]

constexpr LayerType armnn::LayerEnumOf ( const MeanLayer * )

Definition at line 130 of file LayersFwd.hpp.

◆ LayerEnumOf() [34/63]

constexpr LayerType armnn::LayerEnumOf ( const MemCopyLayer * )

Definition at line 131 of file LayersFwd.hpp.

◆ LayerEnumOf() [35/63]

constexpr LayerType armnn::LayerEnumOf ( const MemImportLayer * )

Definition at line 132 of file LayersFwd.hpp.

◆ LayerEnumOf() [36/63]

constexpr LayerType armnn::LayerEnumOf ( const MergeLayer * )

Definition at line 133 of file LayersFwd.hpp.

◆ LayerEnumOf() [37/63]

constexpr LayerType armnn::LayerEnumOf ( const MinimumLayer * )

Definition at line 134 of file LayersFwd.hpp.

◆ LayerEnumOf() [38/63]

constexpr LayerType armnn::LayerEnumOf ( const MultiplicationLayer * )

Definition at line 135 of file LayersFwd.hpp.

◆ LayerEnumOf() [39/63]

constexpr LayerType armnn::LayerEnumOf ( const NormalizationLayer * )

Definition at line 136 of file LayersFwd.hpp.

◆ LayerEnumOf() [40/63]

constexpr LayerType armnn::LayerEnumOf ( const OutputLayer * )

Definition at line 137 of file LayersFwd.hpp.

◆ LayerEnumOf() [41/63]

constexpr LayerType armnn::LayerEnumOf ( const PadLayer * )

Definition at line 138 of file LayersFwd.hpp.

◆ LayerEnumOf() [42/63]

constexpr LayerType armnn::LayerEnumOf ( const PermuteLayer * )

Definition at line 139 of file LayersFwd.hpp.

◆ LayerEnumOf() [43/63]

constexpr LayerType armnn::LayerEnumOf ( const Pooling2dLayer * )

Definition at line 140 of file LayersFwd.hpp.

◆ LayerEnumOf() [44/63]

constexpr LayerType armnn::LayerEnumOf ( const PreCompiledLayer * )

Definition at line 141 of file LayersFwd.hpp.

◆ LayerEnumOf() [45/63]

constexpr LayerType armnn::LayerEnumOf ( const PreluLayer * )

Definition at line 142 of file LayersFwd.hpp.

◆ LayerEnumOf() [46/63]

constexpr LayerType armnn::LayerEnumOf ( const QuantizeLayer * )

Definition at line 143 of file LayersFwd.hpp.

◆ LayerEnumOf() [47/63]

constexpr LayerType armnn::LayerEnumOf ( const QLstmLayer * )

Definition at line 144 of file LayersFwd.hpp.

◆ LayerEnumOf() [48/63]

constexpr LayerType armnn::LayerEnumOf ( const QuantizedLstmLayer * )

Definition at line 145 of file LayersFwd.hpp.

◆ LayerEnumOf() [49/63]

constexpr LayerType armnn::LayerEnumOf ( const RankLayer * )

Definition at line 146 of file LayersFwd.hpp.

◆ LayerEnumOf() [50/63]

constexpr LayerType armnn::LayerEnumOf ( const ReshapeLayer * )

Definition at line 147 of file LayersFwd.hpp.

◆ LayerEnumOf() [51/63]

constexpr LayerType armnn::LayerEnumOf ( const ResizeLayer * )

Definition at line 148 of file LayersFwd.hpp.

◆ LayerEnumOf() [52/63]

constexpr LayerType armnn::LayerEnumOf ( const SliceLayer * )

Definition at line 149 of file LayersFwd.hpp.

◆ LayerEnumOf() [53/63]

constexpr LayerType armnn::LayerEnumOf ( const SoftmaxLayer * )

Definition at line 150 of file LayersFwd.hpp.

◆ LayerEnumOf() [54/63]

constexpr LayerType armnn::LayerEnumOf ( const SpaceToBatchNdLayer * )

Definition at line 151 of file LayersFwd.hpp.

◆ LayerEnumOf() [55/63]

constexpr LayerType armnn::LayerEnumOf ( const SpaceToDepthLayer * )

Definition at line 152 of file LayersFwd.hpp.

◆ LayerEnumOf() [56/63]

constexpr LayerType armnn::LayerEnumOf ( const SplitterLayer * )

Definition at line 153 of file LayersFwd.hpp.

◆ LayerEnumOf() [57/63]

constexpr LayerType armnn::LayerEnumOf ( const StackLayer * )

Definition at line 154 of file LayersFwd.hpp.

◆ LayerEnumOf() [58/63]

constexpr LayerType armnn::LayerEnumOf ( const StandInLayer * )

Definition at line 155 of file LayersFwd.hpp.

◆ LayerEnumOf() [59/63]

constexpr LayerType armnn::LayerEnumOf ( const StridedSliceLayer * )

Definition at line 156 of file LayersFwd.hpp.

◆ LayerEnumOf() [60/63]

constexpr LayerType armnn::LayerEnumOf ( const SubtractionLayer * )

Definition at line 157 of file LayersFwd.hpp.

◆ LayerEnumOf() [61/63]

constexpr LayerType armnn::LayerEnumOf ( const SwitchLayer * )

Definition at line 158 of file LayersFwd.hpp.

◆ LayerEnumOf() [62/63]

constexpr LayerType armnn::LayerEnumOf ( const TransposeLayer * )

Definition at line 159 of file LayersFwd.hpp.

◆ LayerEnumOf() [63/63]

constexpr LayerType armnn::LayerEnumOf ( const TransposeConvolution2dLayer * )

Definition at line 160 of file LayersFwd.hpp.

◆ LevelToString()

std::string armnn::LevelToString ( LogSeverity level )

inline

Definition at line 14 of file Logging.hpp.

References Debug, Error, Fatal, Info, Trace, and Warning.

Referenced by ScopedRecord::ScopedRecord().

 {
     switch(level)
     {
         case LogSeverity::Trace:
             return "Trace";
         case LogSeverity::Debug:
             return "Debug";
         case LogSeverity::Info:
             return "Info";
         case LogSeverity::Warning:
             return "Warning";
         case LogSeverity::Error:
             return "Error";
         case LogSeverity::Fatal:
             return "Fatal";
         default:
             return "Log";
     }
 }

◆ LogSoftmax()

void LogSoftmax	(	Decoder< float > &	input,
		Encoder< float > &	output,
		const TensorInfo &	inputInfo,
		const LogSoftmaxDescriptor &	descriptor
	)

Definition at line 30 of file LogSoftmax.cpp.

References ARMNN_ASSERT_MSG, Decoder< IType >::Get(), TensorShape::GetNumDimensions(), TensorInfo::GetNumDimensions(), armnnUtils::GetNumElementsBetween(), TensorInfo::GetShape(), IgnoreUnused(), SoftmaxDescriptor::m_Axis, SoftmaxDescriptor::m_Beta, numeric_cast(), and Encoder< IType >::Set().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     const unsigned int numDimensions = inputInfo.GetNumDimensions();
 
     bool axisIsValid = ValidateAxis(descriptor.m_Axis, numDimensions);
     ARMNN_ASSERT_MSG(axisIsValid,
         "Axis index is not in range [-numDimensions, numDimensions).");
     IgnoreUnused(axisIsValid);
 
     unsigned int uAxis = descriptor.m_Axis < 0  ?
         numDimensions - boost::numeric_cast<unsigned int>(std::abs(descriptor.m_Axis)) :
         boost::numeric_cast<unsigned int>(descriptor.m_Axis);
 
     const TensorShape& inputShape = inputInfo.GetShape();
     const unsigned int outerSize  = armnnUtils::GetNumElementsBetween(inputShape, 0, uAxis);
     const unsigned int axisSize   = inputShape[uAxis];
     const unsigned int innerSize  = armnnUtils::GetNumElementsBetween(inputShape,
                                                                       uAxis + 1,
                                                                       inputShape.GetNumDimensions());
 
     for (unsigned int outer = 0; outer < outerSize; ++outer)
     {
         for (unsigned int inner = 0; inner < innerSize; ++inner)
         {
             // Find max
             input[outer * axisSize * innerSize + inner];
             float maxValue = input.Get();
             for (unsigned int i = 1u; i < axisSize; ++i)
             {
                 input[(outer * axisSize + i) * innerSize + inner];
                 maxValue = std::max(maxValue, input.Get());
             }
 
             // Compute sum
             float sum = 0.0f;
             for (unsigned int i = 0u; i < axisSize; ++i)
             {
                 input[(outer * axisSize + i) * innerSize + inner];
                 sum += std::exp((input.Get() - maxValue) * descriptor.m_Beta);
             }
 
             // Compute log sum
             const float logSum = std::log(sum);
 
             // Compute result
             for (unsigned int i = 0u; i < axisSize; ++i)
             {
                 const unsigned int index = (outer * axisSize + i) * innerSize + inner;
 
                 input [index];
                 output[index];
 
                 output.Set((input.Get() - maxValue) * descriptor.m_Beta - logSum);
             }
         }
     }
 }

◆ LowerString()

std::string armnn::LowerString ( std::string value )

Definition at line 61 of file ClBackendContext.cpp.

 {
     std::transform(value.begin(), value.end(), value.begin(),
                    [](unsigned char c){ return std::tolower(c); });
 
     return value;
 }

◆ MakeDecoder() [1/3]

std::unique_ptr<Decoder<T> > armnn::MakeDecoder	(	const TensorInfo &	info,
		const void *	data = `nullptr`
	)

inline

Definition at line 70 of file Decoders.hpp.

References ARMNN_ASSERT_MSG, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, BFloat16, Boolean, Float16, Float32, TensorInfo::GetDataType(), armnnUtils::GetPerAxisParams(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::HasPerAxisQuantization(), QAsymmS8, QAsymmU8, QSymmS16, QSymmS8, QuantizedSymm8PerAxis, and Signed32.

 {
     switch(info.GetDataType())
     {
         ARMNN_NO_DEPRECATE_WARN_BEGIN
         case armnn::DataType::QuantizedSymm8PerAxis:
         {
             std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info);
             return std::make_unique<QSymm8PerAxisDecoder>(
                 static_cast<const int8_t*>(data),
                 params.second,
                 params.first);
         }
         ARMNN_NO_DEPRECATE_WARN_END
         case DataType::QAsymmS8:
         {
             return std::make_unique<QASymmS8Decoder>(
                 static_cast<const int8_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case DataType::QAsymmU8:
         {
             return std::make_unique<QASymm8Decoder>(
                 static_cast<const uint8_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case DataType::QSymmS16:
         {
             return std::make_unique<QSymm16Decoder>(
                 static_cast<const int16_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case DataType::BFloat16:
         {
             return std::make_unique<BFloat16Decoder>(static_cast<const BFloat16*>(data));
         }
         case DataType::Float16:
         {
             return std::make_unique<Float16Decoder>(static_cast<const Half*>(data));
         }
         case DataType::Float32:
         {
             return std::make_unique<Float32Decoder>(static_cast<const float*>(data));
         }
         case DataType::Signed32:
         {
             return MakeSigned32Decoder(info, data);
         }
         case DataType::QSymmS8:
         {
             if (info.HasPerAxisQuantization())
             {
                 std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info);
                 return std::make_unique<QSymm8PerAxisDecoder>(
                     static_cast<const int8_t*>(data),
                     params.second,
                     params.first);
             }
             else
             {
                 return std::make_unique<QSymmS8Decoder>(
                     static_cast<const int8_t*>(data),
                     info.GetQuantizationScale(),
                     info.GetQuantizationOffset());
             }
         }
         case armnn::DataType::Boolean:
         {
             return std::make_unique<BooleanDecoder>(static_cast<const uint8_t*>(data));
         }
         default:
         {
             ARMNN_ASSERT_MSG(false, "Unsupported Data Type!");
             break;
         }
     }
     return nullptr;
 }

◆ MakeDecoder() [2/3]

std::unique_ptr<Decoder<float> > armnn::MakeDecoder	(	const TensorInfo &	info,
		const void *	data
	)

inline

Definition at line 70 of file Decoders.hpp.

References ARMNN_ASSERT_MSG, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, BFloat16, Boolean, Float16, Float32, TensorInfo::GetDataType(), armnnUtils::GetPerAxisParams(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::HasPerAxisQuantization(), QAsymmS8, QAsymmU8, QSymmS16, QSymmS8, QuantizedSymm8PerAxis, and Signed32.

 {
     switch(info.GetDataType())
     {
         ARMNN_NO_DEPRECATE_WARN_BEGIN
         case armnn::DataType::QuantizedSymm8PerAxis:
         {
             std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info);
             return std::make_unique<QSymm8PerAxisDecoder>(
                 static_cast<const int8_t*>(data),
                 params.second,
                 params.first);
         }
         ARMNN_NO_DEPRECATE_WARN_END
         case DataType::QAsymmS8:
         {
             return std::make_unique<QASymmS8Decoder>(
                 static_cast<const int8_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case DataType::QAsymmU8:
         {
             return std::make_unique<QASymm8Decoder>(
                 static_cast<const uint8_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case DataType::QSymmS16:
         {
             return std::make_unique<QSymm16Decoder>(
                 static_cast<const int16_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case DataType::BFloat16:
         {
             return std::make_unique<BFloat16Decoder>(static_cast<const BFloat16*>(data));
         }
         case DataType::Float16:
         {
             return std::make_unique<Float16Decoder>(static_cast<const Half*>(data));
         }
         case DataType::Float32:
         {
             return std::make_unique<Float32Decoder>(static_cast<const float*>(data));
         }
         case DataType::Signed32:
         {
             return MakeSigned32Decoder(info, data);
         }
         case DataType::QSymmS8:
         {
             if (info.HasPerAxisQuantization())
             {
                 std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info);
                 return std::make_unique<QSymm8PerAxisDecoder>(
                     static_cast<const int8_t*>(data),
                     params.second,
                     params.first);
             }
             else
             {
                 return std::make_unique<QSymmS8Decoder>(
                     static_cast<const int8_t*>(data),
                     info.GetQuantizationScale(),
                     info.GetQuantizationOffset());
             }
         }
         case armnn::DataType::Boolean:
         {
             return std::make_unique<BooleanDecoder>(static_cast<const uint8_t*>(data));
         }
         default:
         {
             ARMNN_ASSERT_MSG(false, "Unsupported Data Type!");
             break;
         }
     }
     return nullptr;
 }

◆ MakeDecoder() [3/3]

std::unique_ptr<Decoder<int32_t> > armnn::MakeDecoder	(	const TensorInfo &	info,
		const void *	data
	)

inline

Definition at line 153 of file Decoders.hpp.

References ARMNN_ASSERT_MSG, TensorInfo::GetDataType(), and Signed32.

 {
     switch(info.GetDataType())
     {
         case DataType::Signed32:
         {
             return std::make_unique<Int32ToInt32tDecoder>(static_cast<const int32_t*>(data));
         }
         default:
         {
             ARMNN_ASSERT_MSG(false, "Unsupported Data Type!");
             break;
         }
     }
     return nullptr;
 }

◆ MakeEncoder() [1/4]

std::unique_ptr<Encoder<T> > armnn::MakeEncoder	(	const TensorInfo &	info,
		void *	data = `nullptr`
	)

inline

Definition at line 21 of file Encoders.hpp.

References ARMNN_ASSERT_MSG, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, BFloat16, Boolean, Float16, Float32, TensorInfo::GetDataType(), armnnUtils::GetPerAxisParams(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::HasPerAxisQuantization(), QAsymmS8, QAsymmU8, QSymmS16, QSymmS8, QuantizedSymm8PerAxis, and Signed32.

 {
     switch(info.GetDataType())
     {
         ARMNN_NO_DEPRECATE_WARN_BEGIN
         case armnn::DataType::QuantizedSymm8PerAxis:
         {
             std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info);
             return std::make_unique<QSymm8PerAxisEncoder>(
                 static_cast<int8_t*>(data),
                 params.second,
                 params.first);
         }
         ARMNN_NO_DEPRECATE_WARN_END
         case armnn::DataType::QAsymmS8:
         {
             return std::make_unique<QASymmS8Encoder>(
                 static_cast<int8_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case armnn::DataType::QAsymmU8:
         {
             return std::make_unique<QASymm8Encoder>(
                 static_cast<uint8_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case DataType::QSymmS8:
         {
             if (info.HasPerAxisQuantization())
             {
                 std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info);
                 return std::make_unique<QSymm8PerAxisEncoder>(
                         static_cast<int8_t*>(data),
                         params.second,
                         params.first);
             }
             else
             {
                 return std::make_unique<QSymmS8Encoder>(
                         static_cast<int8_t*>(data),
                         info.GetQuantizationScale(),
                         info.GetQuantizationOffset());
             }
         }
         case armnn::DataType::QSymmS16:
         {
             return std::make_unique<QSymm16Encoder>(
                 static_cast<int16_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case armnn::DataType::Signed32:
         {
             return std::make_unique<Int32Encoder>(static_cast<int32_t*>(data));
         }
         case armnn::DataType::BFloat16:
         {
             return std::make_unique<BFloat16Encoder>(static_cast<armnn::BFloat16*>(data));
         }
         case armnn::DataType::Float16:
         {
             return std::make_unique<Float16Encoder>(static_cast<Half*>(data));
         }
         case armnn::DataType::Float32:
         {
             return std::make_unique<Float32Encoder>(static_cast<float*>(data));
         }
         default:
         {
             ARMNN_ASSERT_MSG(false, "Unsupported target Data Type!");
             break;
         }
     }
     return nullptr;
 }

◆ MakeEncoder() [2/4]

std::unique_ptr<Encoder<float> > armnn::MakeEncoder	(	const TensorInfo &	info,
		void *	data
	)

inline

Definition at line 21 of file Encoders.hpp.

References ARMNN_ASSERT_MSG, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, BFloat16, Float16, Float32, TensorInfo::GetDataType(), armnnUtils::GetPerAxisParams(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::HasPerAxisQuantization(), QAsymmS8, QAsymmU8, QSymmS16, QSymmS8, QuantizedSymm8PerAxis, and Signed32.

 {
     switch(info.GetDataType())
     {
         ARMNN_NO_DEPRECATE_WARN_BEGIN
         case armnn::DataType::QuantizedSymm8PerAxis:
         {
             std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info);
             return std::make_unique<QSymm8PerAxisEncoder>(
                 static_cast<int8_t*>(data),
                 params.second,
                 params.first);
         }
         ARMNN_NO_DEPRECATE_WARN_END
         case armnn::DataType::QAsymmS8:
         {
             return std::make_unique<QASymmS8Encoder>(
                 static_cast<int8_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case armnn::DataType::QAsymmU8:
         {
             return std::make_unique<QASymm8Encoder>(
                 static_cast<uint8_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case DataType::QSymmS8:
         {
             if (info.HasPerAxisQuantization())
             {
                 std::pair<unsigned int, std::vector<float>> params = armnnUtils::GetPerAxisParams(info);
                 return std::make_unique<QSymm8PerAxisEncoder>(
                         static_cast<int8_t*>(data),
                         params.second,
                         params.first);
             }
             else
             {
                 return std::make_unique<QSymmS8Encoder>(
                         static_cast<int8_t*>(data),
                         info.GetQuantizationScale(),
                         info.GetQuantizationOffset());
             }
         }
         case armnn::DataType::QSymmS16:
         {
             return std::make_unique<QSymm16Encoder>(
                 static_cast<int16_t*>(data),
                 info.GetQuantizationScale(),
                 info.GetQuantizationOffset());
         }
         case armnn::DataType::Signed32:
         {
             return std::make_unique<Int32Encoder>(static_cast<int32_t*>(data));
         }
         case armnn::DataType::BFloat16:
         {
             return std::make_unique<BFloat16Encoder>(static_cast<armnn::BFloat16*>(data));
         }
         case armnn::DataType::Float16:
         {
             return std::make_unique<Float16Encoder>(static_cast<Half*>(data));
         }
         case armnn::DataType::Float32:
         {
             return std::make_unique<Float32Encoder>(static_cast<float*>(data));
         }
         default:
         {
             ARMNN_ASSERT_MSG(false, "Unsupported target Data Type!");
             break;
         }
     }
     return nullptr;
 }

◆ MakeEncoder() [3/4]

std::unique_ptr<Encoder<bool> > armnn::MakeEncoder	(	const TensorInfo &	info,
		void *	data
	)

inline

Definition at line 100 of file Encoders.hpp.

References ARMNN_ASSERT_MSG, Boolean, and TensorInfo::GetDataType().

 {
     switch(info.GetDataType())
     {
         case armnn::DataType::Boolean:
         {
             return std::make_unique<BooleanEncoder>(static_cast<uint8_t*>(data));
         }
         default:
         {
             ARMNN_ASSERT_MSG(false, "Cannot encode from boolean. Not supported target Data Type!");
             break;
         }
     }
     return nullptr;
 }

◆ MakeEncoder() [4/4]

std::unique_ptr<Encoder<int32_t> > armnn::MakeEncoder	(	const TensorInfo &	info,
		void *	data
	)

inline

Definition at line 118 of file Encoders.hpp.

References ARMNN_ASSERT_MSG, TensorInfo::GetDataType(), and Signed32.

 {
     switch(info.GetDataType())
     {
         case DataType::Signed32:
         {
             return std::make_unique<Int32ToInt32tEncoder>(static_cast<int32_t*>(data));
         }
         default:
         {
             ARMNN_ASSERT_MSG(false, "Unsupported Data Type!");
             break;
         }
     }
     return nullptr;
 }

◆ MakeInfo()

arm_compute::DetectionPostProcessLayerInfo armnn::MakeInfo ( const DetectionPostProcessDescriptor & desc )

Definition at line 17 of file NeonDetectionPostProcessWorkload.cpp.

References DetectionPostProcessDescriptor::m_DetectionsPerClass, DetectionPostProcessDescriptor::m_MaxClassesPerDetection, DetectionPostProcessDescriptor::m_MaxDetections, DetectionPostProcessDescriptor::m_NmsIouThreshold, DetectionPostProcessDescriptor::m_NmsScoreThreshold, DetectionPostProcessDescriptor::m_NumClasses, and DetectionPostProcessDescriptor::m_UseRegularNms.

Referenced by NeonDetectionPostProcessValidate().

 {
     return arm_compute::DetectionPostProcessLayerInfo(desc.m_MaxDetections,
                                                       desc.m_MaxClassesPerDetection,
                                                       desc.m_NmsScoreThreshold,
                                                       desc.m_NmsIouThreshold,
                                                       desc.m_NumClasses,
                                                       { desc.m_ScaleX,
                                                         desc.m_ScaleY,
                                                         desc.m_ScaleW,
                                                         desc.m_ScaleH },
                                                       desc.m_UseRegularNms,
                                                       desc.m_DetectionsPerClass);
 }

◆ MakeOptimizations()

Optimizer::Optimizations armnn::MakeOptimizations ( Args &&... args )

Definition at line 43 of file Optimizer.hpp.

References Append().

Referenced by BOOST_AUTO_TEST_CASE(), and Optimize().

 {
     Optimizer::Optimizations optimizations;
 
     Append(optimizations, std::forward<Args>(args)...);
 
     return optimizations;
 }

◆ MakeOptional()

Optional<T> armnn::MakeOptional ( Args &&... args )

Utility template that constructs an object of type T in-place and wraps it inside an Optional<T> object.

Definition at line 305 of file Optional.hpp.

References CONSTRUCT_IN_PLACE.

 {
     return Optional<T>(CONSTRUCT_IN_PLACE, std::forward<Args>(args)...);
 }

◆ Mean()

void Mean	(	const armnn::TensorInfo &	inputInfo,
		const armnn::TensorInfo &	outputInfo,
		const std::vector< unsigned int > &	axis,
		Decoder< float > &	input,
		Encoder< float > &	output
	)

Definition at line 71 of file Mean.cpp.

References ARMNN_ASSERT, Decoder< IType >::Get(), TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), NextIndex(), numeric_cast(), ReducedOutputOffset(), and Encoder< IType >::Set().

Referenced by BOOST_AUTO_TEST_CASE().

 {
 
     unsigned int inputNumDims = inputInfo.GetNumDimensions();
     unsigned int outputNumDims = outputInfo.GetNumDimensions();
 
     armnn::TensorShape outputDims = outputInfo.GetShape();
     armnn::TensorShape inputDims = inputInfo.GetShape();
 
     // Initialise output data.
     unsigned int numOutputs = 1;
     for (unsigned int idx = 0; idx < outputNumDims; ++idx)
     {
         numOutputs *= outputDims[idx];
     }
 
     std::vector<float> tempSum(numOutputs);
     for (unsigned int idx = 0; idx < numOutputs; ++idx)
     {
         output[idx];
         output.Set(0.0f);
         tempSum[idx] = 0.0f;
     }
 
     // Initialise temp index.
     std::vector<unsigned int> tempIndex(inputNumDims);
     for (unsigned int idx = 0; idx < inputNumDims; ++idx)
     {
         tempIndex[idx] = 0;
     }
 
     std::vector<unsigned int> resolvedAxis = axis;
     if (resolvedAxis.empty())
     {
       for (unsigned int idx = 0; idx < inputNumDims; ++idx)
       {
           resolvedAxis.push_back(idx);
       }
     }
     auto numResolvedAxis = boost::numeric_cast<unsigned int>(resolvedAxis.size());
 
     // Iterates through input_data and sum up the reduced axis.
     for (bool hasNext = true; hasNext; hasNext = NextIndex(inputNumDims, inputDims, tempIndex))
     {
         unsigned int inputOffset = ReducedOutputOffset(inputNumDims, inputDims, tempIndex, 0, {});
         unsigned int outputOffset = ReducedOutputOffset(inputNumDims, inputDims, tempIndex,
                                                         numResolvedAxis, resolvedAxis);
         input[inputOffset];
         tempSum[outputOffset] += input.Get();
     }
 
     // Takes average by num of elements added to get mean.
     size_t numElementsInAxis = 1;
     for (unsigned int idx = 0; idx < numResolvedAxis; ++idx)
     {
         unsigned int current = inputDims[resolvedAxis[idx]];
         ARMNN_ASSERT(boost::numeric_cast<float>(current) <
               (std::numeric_limits<float>::max() / boost::numeric_cast<float>(numElementsInAxis)));
         numElementsInAxis *= current;
     }
     if (numElementsInAxis > 0) {
         for (unsigned int idx = 0; idx < numOutputs; ++idx)
         {
             output[idx];
             output.Set(tempSum[idx] / boost::numeric_cast<float>(numElementsInAxis));
         }
     }
 }

◆ MockBackendId()

constexpr const char* armnn::MockBackendId ( )

Definition at line 11 of file MockBackendId.hpp.

Referenced by BOOST_AUTO_TEST_CASE(), MockBackend::GetIdStatic(), and MockBackend::OptimizeSubgraphView().

11 { return "MockAcc"; }

◆ MockImportBackendId()

constexpr const char* armnn::MockImportBackendId ( )

Definition at line 12 of file MockImportBackend.hpp.

Referenced by BOOST_AUTO_TEST_CASE(), and MockImportBackend::GetIdStatic().

12 { return "MockRef"; }

◆ NeonAbsWorkloadValidate()

arm_compute::Status NeonAbsWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 17 of file NeonAbsWorkload.cpp.

Referenced by NeonLayerSupport::IsElementwiseUnarySupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEAbsLayer::validate(&aclInput, &aclOutput);
 }

◆ NeonActivationWorkloadValidate()

arm_compute::Status NeonActivationWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const ActivationDescriptor &	descriptor
	)

Definition at line 17 of file NeonActivationWorkload.cpp.

Referenced by NeonLayerSupport::IsActivationSupported().

 {
     const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     const arm_compute::ActivationLayerInfo activationLayerInfo =
         ConvertActivationDescriptorToAclActivationLayerInfo(descriptor);
 
     return arm_compute::NEActivationLayer::validate(&aclInput,
                                                     &aclOutput,
                                                     activationLayerInfo);
 }

◆ NeonAdditionWorkloadValidate()

arm_compute::Status NeonAdditionWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 18 of file NeonAdditionWorkload.cpp.

Referenced by NeonLayerSupport::IsAdditionSupported().

 {
     const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEArithmeticAddition::validate(&aclInput0,
                                                        &aclInput1,
                                                        &aclOutput,
                                                        arm_compute::ConvertPolicy::SATURATE);
 }

◆ NeonArgMinMaxWorkloadValidate()

arm_compute::Status NeonArgMinMaxWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const ArgMinMaxDescriptor &	descriptor
	)

Definition at line 30 of file NeonArgMinMaxWorkload.cpp.

Referenced by NeonLayerSupport::IsArgMinMaxSupported().

 {
     const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     auto numDims = input.GetNumDimensions();
     auto unsignedAxis = armnnUtils::GetUnsignedAxis(numDims, descriptor.m_Axis);
     int aclAxis = boost::numeric_cast<int>(CalcAclAxis(numDims, unsignedAxis));
 
     if (descriptor.m_Function == ArgMinMaxFunction::Max)
     {
         return arm_compute::NEArgMinMaxLayer::validate(&aclInput, aclAxis, &aclOutput,
                                                        arm_compute::ReductionOperation::ARG_IDX_MAX);
     }
     else
     {
         return arm_compute::NEArgMinMaxLayer::validate(&aclInput, aclAxis, &aclOutput,
                                                        arm_compute::ReductionOperation::ARG_IDX_MIN);
     }
 }

◆ NeonBackendId()

constexpr const char* armnn::NeonBackendId ( )

Definition at line 10 of file NeonBackendId.hpp.

Referenced by NeonBackend::GetIdStatic().

10 { return "CpuAcc"; }

◆ NeonBatchNormalizationValidate()

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
	)

Definition at line 21 of file NeonBatchNormalizationWorkload.cpp.

Referenced by NeonLayerSupport::IsBatchNormalizationSupported().

 {
     const arm_compute::TensorInfo aclInputInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclMeanInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(mean, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclVarInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(var, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclBetaInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(beta, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclGammaInfo =
           armcomputetensorutils::BuildArmComputeTensorInfo(gamma, descriptor.m_DataLayout);
 
     return arm_compute::NEBatchNormalizationLayer::validate(&aclInputInfo,
                                                             &aclOutputInfo,
                                                             &aclMeanInfo,
                                                             &aclVarInfo,
                                                             &aclBetaInfo,
                                                             &aclGammaInfo,
                                                             descriptor.m_Eps);
 }

◆ NeonBatchToSpaceNdWorkloadValidate()

arm_compute::Status NeonBatchToSpaceNdWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const BatchToSpaceNdDescriptor &	desc
	)

Definition at line 18 of file NeonBatchToSpaceNdWorkload.cpp.

Referenced by NeonLayerSupport::IsBatchToSpaceNdSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, desc.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, desc.m_DataLayout);
 
     // ArmNN blockShape is [H, W] Cl asks for W, H
     int32_t blockHeight = boost::numeric_cast<int32_t>(desc.m_BlockShape[0]);
     int32_t blockWidth = boost::numeric_cast<int32_t>(desc.m_BlockShape[1]);
 
     const arm_compute::Status aclStatus = arm_compute::NEBatchToSpaceLayer::validate(&aclInputInfo,
                                                                                      blockWidth,
                                                                                      blockHeight,
                                                                                      &aclOutputInfo);
     return aclStatus;
 }

◆ NeonComparisonWorkloadValidate()

arm_compute::Status NeonComparisonWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output,
		const ComparisonDescriptor &	descriptor
	)

Definition at line 16 of file NeonComparisonWorkload.cpp.

Referenced by NeonLayerSupport::IsComparisonSupported().

 {
     const arm_compute::TensorInfo aclInput0 = BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1 = BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output);
 
     const arm_compute::ComparisonOperation comparisonOperation = ConvertComparisonOperationToAcl(descriptor);
 
     const arm_compute::Status aclStatus = arm_compute::NEElementwiseComparison::validate(&aclInput0,
                                                                                          &aclInput1,
                                                                                          &aclOutput,
                                                                                          comparisonOperation);
     return aclStatus;
 }

◆ NeonConcatWorkloadValidate()

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

Definition at line 27 of file NeonConcatWorkload.cpp.

Referenced by NeonLayerSupport::IsConcatSupported().

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

◆ NeonConstantWorkloadValidate()

arm_compute::Status NeonConstantWorkloadValidate ( const TensorInfo & output )

Definition at line 22 of file NeonConstantWorkload.cpp.

Referenced by NeonLayerSupport::IsConstantSupported().

 {
     const arm_compute::TensorInfo neonOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     std::array<arm_compute::DataType,9> supportedTypes = {
             arm_compute::DataType::BFLOAT16,
             arm_compute::DataType::F16,
             arm_compute::DataType::F32,
             arm_compute::DataType::QASYMM8,
             arm_compute::DataType::QASYMM8_SIGNED,
             arm_compute::DataType::QSYMM16,
             arm_compute::DataType::QSYMM8,
             arm_compute::DataType::QSYMM8_PER_CHANNEL,
             arm_compute::DataType::S32
     };
     auto it = std::find(begin(supportedTypes), end(supportedTypes), neonOutputInfo.data_type());
 
     if (it != end(supportedTypes))
     {
         return arm_compute::Status{};
     }
     else
     {
         return arm_compute::Status{arm_compute::ErrorCode::RUNTIME_ERROR, "Unsupported DataType"};
     }
 }

◆ NeonConvolution2dWorkloadValidate()

arm_compute::Status NeonConvolution2dWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const Convolution2dDescriptor &	descriptor,
		const TensorInfo &	weights,
		const Optional< TensorInfo > &	biases
	)

Definition at line 23 of file NeonConvolution2dWorkload.cpp.

Referenced by NeonLayerSupport::IsConvolution2dSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclWeightsInfo = BuildArmComputeTensorInfo(weights, descriptor.m_DataLayout);
 
     const arm_compute::Size2D aclDilationInfo = BuildArmComputeSize2D(descriptor.m_DilationX,
                                                                       descriptor.m_DilationY);
 
     arm_compute::TensorInfo aclBiasesInfo;
     arm_compute::TensorInfo *optionalAclBiasesInfo = nullptr;
 
     if (descriptor.m_BiasEnabled)
     {
         ARMNN_ASSERT(biases.has_value());
 
         aclBiasesInfo = BuildArmComputeTensorInfo(biases.value(), descriptor.m_DataLayout);
         optionalAclBiasesInfo = &aclBiasesInfo;
     }
 
     arm_compute::PadStrideInfo layerInfo = BuildArmComputePadStrideInfo(descriptor);
 
     return arm_compute::NEConvolutionLayer::validate(&aclInputInfo,
                                                      &aclWeightsInfo,
                                                      optionalAclBiasesInfo,
                                                      &aclOutputInfo,
                                                      layerInfo,
                                                      arm_compute::WeightsInfo(),
                                                      aclDilationInfo);
 }

◆ NeonDepthToSpaceWorkloadValidate()

arm_compute::Status NeonDepthToSpaceWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const DepthToSpaceDescriptor &	descriptor
	)

Definition at line 20 of file NeonDepthToSpaceWorkload.cpp.

References SpaceToDepthDescriptor::m_DataLayout.

Referenced by NeonLayerSupport::IsDepthToSpaceSupported().

 {
     DataLayout dataLayout = descriptor.m_DataLayout;
     const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input, dataLayout);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output, dataLayout);
 
     int32_t blockSize = boost::numeric_cast<int32_t>(descriptor.m_BlockSize);
 
     return arm_compute::NEDepthToSpaceLayer::validate(&aclInput, &aclOutput, blockSize);
 }

◆ NeonDepthwiseConvolutionWorkloadValidate()

arm_compute::Status NeonDepthwiseConvolutionWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const DepthwiseConvolution2dDescriptor &	descriptor,
		const TensorInfo &	weights,
		const Optional< TensorInfo > &	biases
	)

Definition at line 28 of file NeonDepthwiseConvolutionWorkload.cpp.

Referenced by NeonLayerSupport::IsDepthwiseConvolutionSupported(), and NeonLayerSupport::IsDilatedDepthwiseConvolutionSupported().

 {
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input,  descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     // ArmNN's weight format is [ M, I, H, W ]
     const unsigned int aclDepthMultiplier = weights.GetShape()[0];
 
     // Convert the weight format from ArmNN's [ M, I, H, W ] (does NOT depend on the data layout) to either
     // [ 1, H, W, I * M ] (if NHWC) or [ 1, I * M, H, W ] (if NCHW), as required by the compute library
     TensorInfo weightsPermuted = ConvertWeightTensorInfoFromArmnnToAcl(weights, descriptor.m_DataLayout);
 
     // Convert the weights into the compute library format
     const arm_compute::TensorInfo aclWeightsInfo = BuildArmComputeTensorInfo(weightsPermuted, descriptor.m_DataLayout);
 
     arm_compute::TensorInfo aclBiasesInfo;
     arm_compute::TensorInfo *optionalAclBiasesInfo = nullptr;
 
     if (descriptor.m_BiasEnabled)
     {
         ARMNN_ASSERT(biases.has_value());
 
         aclBiasesInfo = BuildArmComputeTensorInfo(biases.value(), descriptor.m_DataLayout);
         optionalAclBiasesInfo = &aclBiasesInfo;
     }
 
     arm_compute::PadStrideInfo aclPadStrideInfo = BuildArmComputePadStrideInfo(descriptor);
     const arm_compute::Size2D aclDilationInfo = BuildArmComputeSize2D(
             descriptor.m_DilationX,descriptor.m_DilationY);
 
     return arm_compute::NEDepthwiseConvolutionLayer::validate(&aclInputInfo,
                                                               &aclWeightsInfo,
                                                               optionalAclBiasesInfo,
                                                               &aclOutputInfo,
                                                               aclPadStrideInfo,
                                                               aclDepthMultiplier,
                                                               arm_compute::ActivationLayerInfo(),
                                                               aclDilationInfo);
 }

◆ NeonDequantizeWorkloadValidate()

arm_compute::Status NeonDequantizeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 22 of file NeonDequantizeWorkload.cpp.

Referenced by NeonLayerSupport::IsDequantizeSupported().

 {
     const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEDequantizationLayer::validate(&aclInput, &aclOutput);
 }

◆ NeonDetectionPostProcessValidate()

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
	)

Definition at line 32 of file NeonDetectionPostProcessWorkload.cpp.

References info, and MakeInfo().

 {
     arm_compute::DetectionPostProcessLayerInfo info = MakeInfo(desc);
 
     const arm_compute::TensorInfo aclBoxEncodings =
         armcomputetensorutils::BuildArmComputeTensorInfo(boxEncodings);
 
     const arm_compute::TensorInfo aclScores =
         armcomputetensorutils::BuildArmComputeTensorInfo(scores);
 
     const arm_compute::TensorInfo aclAnchors =
         armcomputetensorutils::BuildArmComputeTensorInfo(anchors);
 
     arm_compute::TensorInfo aclDetectionBoxes =
         armcomputetensorutils::BuildArmComputeTensorInfo(detectionBoxes);
 
     arm_compute::TensorInfo aclDetectionClasses =
         armcomputetensorutils::BuildArmComputeTensorInfo(detectionClasses);
 
     arm_compute::TensorInfo aclDetectionScores =
         armcomputetensorutils::BuildArmComputeTensorInfo(detectionScores);
 
     arm_compute::TensorInfo aclNumDetections =
         armcomputetensorutils::BuildArmComputeTensorInfo(numDetections);
 
     return arm_compute::NEDetectionPostProcessLayer::validate(
             &aclBoxEncodings,
             &aclScores,
             &aclAnchors,
             &aclDetectionBoxes,
             &aclDetectionClasses,
             &aclDetectionScores,
             &aclNumDetections,
             info);
 }

◆ NeonDivisionWorkloadValidate()

arm_compute::Status NeonDivisionWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 15 of file NeonDivisionWorkload.cpp.

Referenced by NeonLayerSupport::IsDivisionSupported().

 {
     const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEElementwiseDivision::validate(&aclInput0,
                                                    &aclInput1,
                                                    &aclOutput);
 }

◆ NeonExpWorkloadValidate()

arm_compute::Status NeonExpWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 17 of file NeonExpWorkload.cpp.

Referenced by NeonLayerSupport::IsElementwiseUnarySupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEExpLayer::validate(&aclInput, &aclOutput);
 }

◆ NeonFullyConnectedWorkloadValidate()

arm_compute::Status NeonFullyConnectedWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const TensorInfo &	weights,
		const TensorInfo &	biases,
		const FullyConnectedDescriptor &	descriptor
	)

Definition at line 20 of file NeonFullyConnectedWorkload.cpp.

Referenced by NeonLayerSupport::IsFullyConnectedSupported().

 {
     const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output);
     const arm_compute::TensorInfo aclWeights = BuildArmComputeTensorInfo(weights);
 
     arm_compute::TensorInfo aclBiases;
     arm_compute::TensorInfo *optionalAclBiases = nullptr;
     if (descriptor.m_BiasEnabled)
     {
         aclBiases  = BuildArmComputeTensorInfo(biases);
         optionalAclBiases = &aclBiases;
     }
 
     const arm_compute::FullyConnectedLayerInfo fullyConnectedLayerInfo =
         ConvertFullyConnectedDescriptorToAclFullyConnectedLayerInfo(descriptor);
 
 
     return arm_compute::NEFullyConnectedLayer::validate(&aclInput,
                                                         &aclWeights,
                                                         optionalAclBiases,
                                                         &aclOutput,
                                                         fullyConnectedLayerInfo);
 }

◆ NeonGatherWorkloadValidate()

arm_compute::Status NeonGatherWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	indices,
		const TensorInfo &	output,
		const GatherDescriptor &	descriptor
	)

Definition at line 13 of file NeonGatherWorkload.cpp.

Referenced by NeonLayerSupport::IsGatherSupported().

 {
     const arm_compute::TensorInfo aclInput   = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclIndices = BuildArmComputeTensorInfo(indices);
     const arm_compute::TensorInfo aclOutput  = BuildArmComputeTensorInfo(output);
 
     int aclAxis = ComputeAclAxis(descriptor.m_Axis, input);
 
     return arm_compute::NEGather::validate(&aclInput, &aclIndices, &aclOutput, aclAxis);
 }

◆ NeonInstanceNormalizationWorkloadValidate()

arm_compute::Status NeonInstanceNormalizationWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const InstanceNormalizationDescriptor &	descriptor
	)

Definition at line 19 of file NeonInstanceNormalizationWorkload.cpp.

Referenced by NeonLayerSupport::IsInstanceNormalizationSupported().

 {
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     return arm_compute::NEInstanceNormalizationLayer::validate(&aclInputInfo,
                                                                &aclOutputInfo,
                                                                descriptor.m_Gamma,
                                                                descriptor.m_Beta,
                                                                descriptor.m_Eps);
 }

◆ NeonL2NormalizationWorkloadValidate()

arm_compute::Status NeonL2NormalizationWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const L2NormalizationDescriptor &	descriptor
	)

Definition at line 19 of file NeonL2NormalizationFloatWorkload.cpp.

Referenced by NeonLayerSupport::IsL2NormalizationSupported().

 {
     const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     int axis = (descriptor.m_DataLayout == DataLayout::NCHW) ? 2 : 0;
 
     return arm_compute::NEL2NormalizeLayer::validate(&aclInput, &aclOutput, axis, descriptor.m_Eps);
 }

◆ NeonLogSoftmaxWorkloadValidate()

arm_compute::Status NeonLogSoftmaxWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const LogSoftmaxDescriptor &	descriptor
	)

Definition at line 19 of file NeonLogSoftmaxWorkload.cpp.

Referenced by NeonLayerSupport::IsLogSoftmaxSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     int aclAxis_int = ComputeAclAxis(descriptor.m_Axis, input);
     unsigned int aclAxis = ComputePositiveAxis(aclAxis_int, input);
     return arm_compute::NELogSoftmaxLayer::validate(&aclInputInfo,
                                                     &aclOutputInfo,
                                                     descriptor.m_Beta,
                                                     static_cast<int>(aclAxis));
 }

◆ NeonLstmFloatWorkloadValidate()

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
	)

Definition at line 271 of file NeonLstmFloatWorkload.cpp.

Referenced by NeonLayerSupport::IsLstmSupported().

 {
     arm_compute::LSTMParams<arm_compute::ITensorInfo> lstm_params_info;
 
     // The inputs and outputs
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputStateInInfo = BuildArmComputeTensorInfo(outputStateIn);
     const arm_compute::TensorInfo aclCellStateInInfo = BuildArmComputeTensorInfo(cellStateIn);
     const arm_compute::TensorInfo aclScratchBufferInfo = BuildArmComputeTensorInfo(scratchBuffer);
     const arm_compute::TensorInfo aclOutputStateOutInfo = BuildArmComputeTensorInfo(outputStateOut);
     const arm_compute::TensorInfo aclCellStateOutInfo = BuildArmComputeTensorInfo(cellStateOut);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     // Basic parameters
     const arm_compute::TensorInfo aclInputToForgetWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToForgetWeights());
     const arm_compute::TensorInfo aclInputToCellWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToCellWeights());
     const arm_compute::TensorInfo aclInputToOutputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToOutputWeights());
     const arm_compute::TensorInfo aclRecurrentToForgetWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToForgetWeights());
     const arm_compute::TensorInfo aclRecurrentToCellWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToCellWeights());
     const arm_compute::TensorInfo aclRecurrentToOutputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToOutputWeights());
     const arm_compute::TensorInfo aclForgetGateBiasInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetForgetGateBias());
     const arm_compute::TensorInfo aclCellBiasInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetCellBias());
     const arm_compute::TensorInfo aclOutputGateBiasInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetOutputGateBias());
 
     arm_compute::TensorInfo aclInputToInputWeightsInfo;
     arm_compute::TensorInfo aclRecurrentToInputWeightsInfo;
     arm_compute::TensorInfo aclCellToInputWeightsInfo;
     arm_compute::TensorInfo aclInputGateBiasInfo;
     arm_compute::TensorInfo aclProjectionWeightsInfo;
     arm_compute::TensorInfo aclProjectionBiasInfo;
     arm_compute::TensorInfo aclCellToForgetWeightsInfo;
     arm_compute::TensorInfo aclCellToOutputWeightsInfo;
 
     arm_compute::TensorInfo aclInputLayerNormWeightsInfo;
     arm_compute::TensorInfo aclForgetLayerNormWeightsInfo;
     arm_compute::TensorInfo aclCellLayerNormWeightsInfo;
     arm_compute::TensorInfo aclOutputLayerNormWeightsInfo;
 
 
     if (!descriptor.m_CifgEnabled)
     {
         if (descriptor.m_PeepholeEnabled)
         {
             aclCellToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToInputWeights());
         }
         aclInputToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputToInputWeights());
         aclRecurrentToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToInputWeights());
         aclInputGateBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputGateBias());
 
         lstm_params_info.set_cifg_params(&aclInputToInputWeightsInfo, &aclRecurrentToInputWeightsInfo,
                                          descriptor.m_PeepholeEnabled ? &aclCellToInputWeightsInfo : nullptr,
                                          &aclInputGateBiasInfo);
     }
 
     if (descriptor.m_ProjectionEnabled)
     {
         if (paramsInfo.m_ProjectionBias != nullptr)
         {
             aclProjectionBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetProjectionBias());
         }
         aclProjectionWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetProjectionWeights());
 
         lstm_params_info.set_projection_params(&aclProjectionWeightsInfo,
                                                paramsInfo.m_ProjectionBias != nullptr ?
                                                &aclProjectionBiasInfo : nullptr);
     }
 
     if (descriptor.m_PeepholeEnabled)
     {
         aclCellToForgetWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToForgetWeights());
         aclCellToOutputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToOutputWeights());
 
         lstm_params_info.set_peephole_params(&aclCellToForgetWeightsInfo, &aclCellToOutputWeightsInfo);
     }
 
     if (descriptor.m_LayerNormEnabled)
     {
         if (!descriptor.m_CifgEnabled)
         {
             aclInputLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputLayerNormWeights());
         }
         aclForgetLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetForgetLayerNormWeights());
         aclCellLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellLayerNormWeights());
         aclOutputLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetOutputLayerNormWeights());
 
         lstm_params_info.set_layer_normalization_params(descriptor.m_CifgEnabled ?
                                                         nullptr : &aclInputLayerNormWeightsInfo,
                                                         &aclForgetLayerNormWeightsInfo,
                                                         &aclCellLayerNormWeightsInfo,
                                                         &aclOutputLayerNormWeightsInfo);
     }
 
     float cell_threshold = descriptor.m_ClippingThresCell;
     float projection_threshold = descriptor.m_ClippingThresProj;
 
     // for preparing the object for the class ActivationLayerInfo, we need to consider 5 situations
     arm_compute::ActivationLayerInfo activationLayerInfo;
     switch (descriptor.m_ActivationFunc)
     {
         case 0:
             // no activation, do nothing
             break;
         case 1:
             activationLayerInfo = arm_compute::ActivationLayerInfo(
                     arm_compute::ActivationLayerInfo::ActivationFunction::RELU);
             break;
         case 3:
             activationLayerInfo = arm_compute::ActivationLayerInfo(
                     arm_compute::ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.0);
             break;
         case 4:
             activationLayerInfo = arm_compute::ActivationLayerInfo(
                     arm_compute::ActivationLayerInfo::ActivationFunction::TANH, 1.0, 1.0);
             break;
         case 6:
             activationLayerInfo = arm_compute::ActivationLayerInfo(
                     arm_compute::ActivationLayerInfo::ActivationFunction::LOGISTIC);
             break;
         default:
             throw armnn::Exception("Wrong Type of Activation Function!");
     }
 
     return arm_compute::NELSTMLayer::validate(&aclInputInfo,
                                               &aclInputToForgetWeightsInfo,
                                               &aclInputToCellWeightsInfo,
                                               &aclInputToOutputWeightsInfo,
                                               &aclRecurrentToForgetWeightsInfo,
                                               &aclRecurrentToCellWeightsInfo,
                                               &aclRecurrentToOutputWeightsInfo,
                                               &aclForgetGateBiasInfo,
                                               &aclCellBiasInfo,
                                               &aclOutputGateBiasInfo,
                                               &aclOutputStateInInfo,
                                               &aclCellStateInInfo,
                                               &aclScratchBufferInfo,
                                               &aclOutputStateOutInfo,
                                               &aclCellStateOutInfo,
                                               &aclOutputInfo,
                                               lstm_params_info,
                                               activationLayerInfo,
                                               cell_threshold,
                                               projection_threshold);
 }

◆ NeonMaximumWorkloadValidate()

arm_compute::Status NeonMaximumWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 14 of file NeonMaximumWorkload.cpp.

Referenced by NeonLayerSupport::IsMaximumSupported().

 {
     const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEElementwiseMax::validate(&aclInput0,
                                                    &aclInput1,
                                                    &aclOutput);
 }

◆ NeonMeanWorkloadValidate()

arm_compute::Status NeonMeanWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const MeanDescriptor &	desc
	)

Definition at line 18 of file NeonMeanWorkload.cpp.

Referenced by NeonLayerSupport::IsMeanSupported().

 {
     const arm_compute::TensorInfo aclInputInfo  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     arm_compute::Coordinates coords = BuildArmComputeReductionCoordinates(aclInputInfo.num_dimensions(),
                                                                           input.GetNumDimensions(),
                                                                           desc.m_Axis);
 
     return arm_compute::NEReduceMean::validate(&aclInputInfo, coords, desc.m_KeepDims, &aclOutputInfo);
 }

◆ NeonMinimumWorkloadValidate()

arm_compute::Status NeonMinimumWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Validate function for validating the inputs and output.

Parameters

[in]	input0	The input0 value to be validated.
[in]	input1	The input1 value to be validated.
[in]	output	The output value to be validated.

Definition at line 15 of file NeonMinimumWorkload.cpp.

Referenced by NeonLayerSupport::IsMinimumSupported().

 {
     const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEElementwiseMin::validate(&aclInput0,
                                                    &aclInput1,
                                                    &aclOutput);
 }

◆ NeonMultiplicationWorkloadValidate()

arm_compute::Status NeonMultiplicationWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 17 of file NeonMultiplicationWorkload.cpp.

Referenced by NeonLayerSupport::IsMultiplicationSupported().

 {
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput2 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     // At the time of writing, configure() will fail if a rounding policy other than TO_ZERO is supplied to it,
     // when providing a scale of 1.0 for F32 tensors, even though the provided rounding policy appears to be
     // ignored for F32 tensors.
     return arm_compute::NEPixelWiseMultiplication::validate(&aclInput1,
                                                             &aclInput2,
                                                             &aclOutput,
                                                             1.0f,
                                                             arm_compute::ConvertPolicy::SATURATE,
                                                             arm_compute::RoundingPolicy::TO_ZERO);
 }

◆ NeonNegWorkloadValidate()

arm_compute::Status NeonNegWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 17 of file NeonNegWorkload.cpp.

Referenced by NeonLayerSupport::IsElementwiseUnarySupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NENegLayer::validate(&aclInput, &aclOutput);
 }

◆ NeonNormalizationWorkloadValidate()

arm_compute::Status NeonNormalizationWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const NormalizationDescriptor &	descriptor
	)

Definition at line 48 of file NeonNormalizationFloatWorkload.cpp.

Referenced by NeonLayerSupport::IsNormalizationSupported().

 {
     const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     arm_compute::NormalizationLayerInfo normalizationInfo = BuildArmComputeNormalizationLayerInfo(descriptor);
 
     return arm_compute::NENormalizationLayer::validate(&aclInput, &aclOutput, normalizationInfo);
 }

◆ NeonPadWorkloadValidate()

arm_compute::Status NeonPadWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const PadDescriptor &	descriptor
	)

Definition at line 48 of file NeonPadWorkload.cpp.

Referenced by NeonLayerSupport::IsPadSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     std::vector<std::pair<unsigned int, unsigned int>> reversed_PadList(descriptor.m_PadList.size());
 
     std::reverse_copy(std::begin(descriptor.m_PadList),
                       std::end(descriptor.m_PadList),
                       std::begin(reversed_PadList));
 
     arm_compute::PaddingList padList = static_cast<arm_compute::PaddingList>(reversed_PadList);
 
     return arm_compute::NEPadLayer::validate(&aclInputInfo, &aclOutputInfo, padList);
 }

◆ NeonPermuteWorkloadValidate()

arm_compute::Status NeonPermuteWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const PermuteDescriptor &	descriptor
	)

Definition at line 15 of file NeonPermuteWorkload.cpp.

Referenced by NeonLayerSupport::IsPermuteSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
     const armnn::PermutationVector& mappings = descriptor.m_DimMappings;
 
     return arm_compute::NEPermute::validate(&aclInputInfo, &aclOutputInfo,
                                       armcomputetensorutils::BuildArmComputePermutationVector(mappings));
 }

◆ NeonPooling2dWorkloadValidate()

arm_compute::Status NeonPooling2dWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const Pooling2dDescriptor &	descriptor
	)

Definition at line 22 of file NeonPooling2dWorkload.cpp.

Referenced by NeonLayerSupport::IsPooling2dSupported().

 {
     const arm_compute::TensorInfo aclInputInfo =
             BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo =
             BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     arm_compute::PoolingLayerInfo layerInfo = BuildArmComputePoolingLayerInfo(descriptor);
 
     return arm_compute::NEPoolingLayer::validate(&aclInputInfo, &aclOutputInfo, layerInfo);
 }

◆ NeonPreluWorkloadValidate()

arm_compute::Status NeonPreluWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	alpha,
		const TensorInfo &	output
	)

Definition at line 17 of file NeonPreluWorkload.cpp.

Referenced by NeonLayerSupport::IsPreluSupported().

 {
     const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclAlpha = armcomputetensorutils::BuildArmComputeTensorInfo(alpha);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEPReluLayer::validate(&aclInput,
                                                &aclAlpha,
                                                &aclOutput);
 }

◆ NeonQLstmWorkloadValidate()

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
	)

Definition at line 236 of file NeonQLstmWorkload.cpp.

Referenced by NeonLayerSupport::IsQLstmSupported().

 {
     arm_compute::LSTMParams<arm_compute::ITensorInfo> aclParamsInfo;
 
     // Input/Output tensor info
     const arm_compute::TensorInfo aclInputInfo         = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputStateInInfo = BuildArmComputeTensorInfo(outputStateIn);
     const arm_compute::TensorInfo aclCellStateInInfo   = BuildArmComputeTensorInfo(cellStateIn);
 
     const arm_compute::TensorInfo aclOutputStateOutInfo = BuildArmComputeTensorInfo(outputStateOut);
     const arm_compute::TensorInfo aclCellStateOutInfo   = BuildArmComputeTensorInfo(cellStateOut);
     const arm_compute::TensorInfo aclOutputInfo         = BuildArmComputeTensorInfo(output);
 
     // Mandatory tensor info
     const arm_compute::TensorInfo aclInputToForgetWeightsInfo
             = BuildArmComputeTensorInfo(paramsInfo.GetInputToForgetWeights());
     const arm_compute::TensorInfo aclInputToCellWeightsInfo
             = BuildArmComputeTensorInfo(paramsInfo.GetInputToCellWeights());
     const arm_compute::TensorInfo aclInputToOutputWeightsInfo
             = BuildArmComputeTensorInfo(paramsInfo.GetInputToOutputWeights());
     const arm_compute::TensorInfo aclRecurrentToForgetWeightsInfo
             = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToForgetWeights());
     const arm_compute::TensorInfo aclRecurrentToCellWeightsInfo
             = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToCellWeights());
     const arm_compute::TensorInfo aclRecurrentToOutputWeightsInfo
             = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToOutputWeights());
     const arm_compute::TensorInfo aclForgetGateBiasInfo
             = BuildArmComputeTensorInfo(paramsInfo.GetForgetGateBias());
     const arm_compute::TensorInfo aclCellBiasInfo
             = BuildArmComputeTensorInfo(paramsInfo.GetCellBias());
     const arm_compute::TensorInfo aclOutputGateBiasInfo
             = BuildArmComputeTensorInfo(paramsInfo.GetOutputGateBias());
 
     // Optional tensor info
     arm_compute::TensorInfo aclInputToInputWeightsInfo;
     arm_compute::TensorInfo aclRecurrentToInputWeightsInfo;
 
     arm_compute::TensorInfo aclCellToInputWeightsInfo;
     arm_compute::TensorInfo aclCellToForgetWeightsInfo;
     arm_compute::TensorInfo aclCellToOutputWeightsInfo;
 
     arm_compute::TensorInfo aclInputGateBiasInfo;
 
     arm_compute::TensorInfo aclProjectionWeightsInfo;
     arm_compute::TensorInfo aclProjectionBiasInfo;
 
     arm_compute::TensorInfo aclInputLayerNormWeightsInfo;
     arm_compute::TensorInfo aclForgetLayerNormWeightsInfo;
     arm_compute::TensorInfo aclCellLayerNormWeightsInfo;
     arm_compute::TensorInfo aclOutputLayerNormWeightsInfo;
 
     // Create tensor info for optional params if they are enabled
     if (descriptor.m_PeepholeEnabled)
     {
         if (!descriptor.m_CifgEnabled)
         {
             aclCellToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToInputWeights());
         }
 
         aclCellToForgetWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToForgetWeights());
         aclCellToOutputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToOutputWeights());
 
         // Set peephole params info
         aclParamsInfo.set_peephole_params(&aclCellToForgetWeightsInfo,
                                           &aclCellToOutputWeightsInfo);
     }
 
     if (descriptor.m_ProjectionEnabled)
     {
         aclProjectionWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetProjectionWeights());
 
         if (paramsInfo.m_ProjectionBias != nullptr)
         {
             aclProjectionBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetProjectionBias());
         }
 
         // Set projection params info
         aclParamsInfo.set_projection_params(
             &aclProjectionWeightsInfo,
             paramsInfo.m_ProjectionBias != nullptr ? &aclProjectionBiasInfo : nullptr);
     }
 
     if (descriptor.m_LayerNormEnabled)
     {
         if (!descriptor.m_CifgEnabled)
         {
             aclInputLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputLayerNormWeights());
         }
 
         aclForgetLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetForgetLayerNormWeights());
         aclCellLayerNormWeightsInfo   = BuildArmComputeTensorInfo(paramsInfo.GetCellLayerNormWeights());
         aclOutputLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetOutputLayerNormWeights());
 
         // Set layer norm params info
         aclParamsInfo.set_layer_normalization_params(
             paramsInfo.m_InputLayerNormWeights != nullptr ? &aclInputLayerNormWeightsInfo : nullptr,
             &aclForgetLayerNormWeightsInfo,
             &aclCellLayerNormWeightsInfo,
             &aclOutputLayerNormWeightsInfo);
     }
 
     if (!descriptor.m_CifgEnabled)
     {
         aclInputToInputWeightsInfo     = BuildArmComputeTensorInfo(paramsInfo.GetInputToInputWeights());
         aclRecurrentToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToInputWeights());
         aclInputGateBiasInfo           = BuildArmComputeTensorInfo(paramsInfo.GetInputGateBias());
 
         // Set CIFG params info
         aclParamsInfo.set_cifg_params(
             &aclInputToInputWeightsInfo,
             &aclRecurrentToInputWeightsInfo,
             paramsInfo.m_CellToInputWeights != nullptr ? &aclCellToInputWeightsInfo : nullptr,
             &aclInputGateBiasInfo);
     }
 
     // Set scalar descriptor params
     aclParamsInfo.set_cell_clip_params(descriptor.m_CellClip);
     aclParamsInfo.set_projection_clip_params(descriptor.m_ProjectionClip);
     aclParamsInfo.set_hidden_state_params(descriptor.m_HiddenStateZeroPoint, descriptor.m_HiddenStateScale);
     aclParamsInfo.set_matmul_scale_params(descriptor.m_InputIntermediateScale,
                                           descriptor.m_ForgetIntermediateScale,
                                           descriptor.m_CellIntermediateScale,
                                           descriptor.m_OutputIntermediateScale);
 
     // QLSTM NEON validate
     return arm_compute::NEQLSTMLayer::validate(&aclInputInfo,
                                                &aclInputToForgetWeightsInfo,
                                                &aclInputToCellWeightsInfo,
                                                &aclInputToOutputWeightsInfo,
                                                &aclRecurrentToForgetWeightsInfo,
                                                &aclRecurrentToCellWeightsInfo,
                                                &aclRecurrentToOutputWeightsInfo,
                                                &aclForgetGateBiasInfo,
                                                &aclCellBiasInfo,
                                                &aclOutputGateBiasInfo,
                                                &aclCellStateInInfo,
                                                &aclOutputStateInInfo,
                                                &aclCellStateOutInfo,
                                                &aclOutputStateOutInfo,
                                                &aclOutputInfo,
                                                aclParamsInfo);
 }

◆ NeonQuantizedLstmWorkloadValidate()

arm_compute::Status NeonQuantizedLstmWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	cellStateIn,
		const TensorInfo &	outputStateIn,
		const TensorInfo &	cellStateOut,
		const TensorInfo &	outputStateOut,
		const QuantizedLstmInputParamsInfo &	paramsInfo
	)

Definition at line 130 of file NeonQuantizedLstmWorkload.cpp.

Referenced by NeonLayerSupport::IsQuantizedLstmSupported().

 {
     // The inputs and outputs
     const arm_compute::TensorInfo aclInputInfo          = BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclCellStateInInfo    = BuildArmComputeTensorInfo(cellStateIn);
     const arm_compute::TensorInfo aclOutputStateInInfo  = BuildArmComputeTensorInfo(outputStateIn);
     const arm_compute::TensorInfo aclCellStateOutInfo   = BuildArmComputeTensorInfo(cellStateOut);
     const arm_compute::TensorInfo aclOutputStateOutInfo = BuildArmComputeTensorInfo(outputStateOut);
 
     // Basic parameters
     const arm_compute::TensorInfo aclInputToInputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToInputWeights());
     const arm_compute::TensorInfo aclInputToForgetWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToForgetWeights());
     const arm_compute::TensorInfo aclInputToCellWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToCellWeights());
     const arm_compute::TensorInfo aclInputToOutputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputToOutputWeights());
 
     const arm_compute::TensorInfo aclRecurrentToInputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToInputWeights());
     const arm_compute::TensorInfo aclRecurrentToForgetWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToForgetWeights());
     const arm_compute::TensorInfo aclRecurrentToCellWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToCellWeights());
     const arm_compute::TensorInfo aclRecurrentToOutputWeightsInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToOutputWeights());
 
     const arm_compute::TensorInfo aclInputGateBiasInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetInputGateBias());
     const arm_compute::TensorInfo aclForgetGateBiasInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetForgetGateBias());
     const arm_compute::TensorInfo aclCellBiasInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetCellBias());
     const arm_compute::TensorInfo aclOutputGateBiasInfo
                                   = BuildArmComputeTensorInfo(paramsInfo.GetOutputGateBias());
 
     return arm_compute::NELSTMLayerQuantized::validate(&aclInputInfo,
                                                        &aclInputToInputWeightsInfo,
                                                        &aclInputToForgetWeightsInfo,
                                                        &aclInputToCellWeightsInfo,
                                                        &aclInputToOutputWeightsInfo,
                                                        &aclRecurrentToInputWeightsInfo,
                                                        &aclRecurrentToForgetWeightsInfo,
                                                        &aclRecurrentToCellWeightsInfo,
                                                        &aclRecurrentToOutputWeightsInfo,
                                                        &aclInputGateBiasInfo,
                                                        &aclForgetGateBiasInfo,
                                                        &aclCellBiasInfo,
                                                        &aclOutputGateBiasInfo,
                                                        &aclCellStateInInfo,
                                                        &aclOutputStateInInfo,
                                                        &aclCellStateOutInfo,
                                                        &aclOutputStateOutInfo);
 }

◆ NeonQuantizeWorkloadValidate()

arm_compute::Status NeonQuantizeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 18 of file NeonQuantizeWorkload.cpp.

Referenced by NeonLayerSupport::IsQuantizeSupported().

 {
     const arm_compute::TensorInfo neonInputInfo  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo neonOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEQuantizationLayer::validate(&neonInputInfo, &neonOutputInfo);
 }

◆ NeonReshapeWorkloadValidate()

arm_compute::Status NeonReshapeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 17 of file NeonReshapeWorkload.cpp.

Referenced by NeonLayerSupport::IsReshapeSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEReshapeLayer::validate(&aclInputInfo, &aclOutputInfo);
 }

◆ NeonResizeWorkloadValidate()

arm_compute::Status NeonResizeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const ResizeDescriptor &	descriptor
	)

Definition at line 22 of file NeonResizeWorkload.cpp.

Referenced by NeonLayerSupport::IsResizeSupported().

 {
     arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input);
     arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
 
     arm_compute::DataLayout aclDataLayout = ConvertDataLayout(descriptor.m_DataLayout);
     aclInputInfo.set_data_layout(aclDataLayout);
     aclOutputInfo.set_data_layout(aclDataLayout);
 
     arm_compute::InterpolationPolicy aclInterpolationPolicy =
             ConvertResizeMethodToAclInterpolationPolicy(descriptor.m_Method);
 
     arm_compute::SamplingPolicy samplingPolicy = descriptor.m_HalfPixelCenters ? arm_compute::SamplingPolicy::CENTER :
                                                                                  arm_compute::SamplingPolicy::TOP_LEFT;
 
     return arm_compute::NEScale::validate(&aclInputInfo,
                                           &aclOutputInfo,
                                           arm_compute::ScaleKernelInfo(aclInterpolationPolicy,
                                                                        arm_compute::BorderMode::REPLICATE,
                                                                        arm_compute::PixelValue(0.f),
                                                                        samplingPolicy,
                                                                        true,
                                                                        descriptor.m_AlignCorners));
 
 }

◆ NeonRsqrtWorkloadValidate()

arm_compute::Status NeonRsqrtWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output
	)

Definition at line 18 of file NeonRsqrtWorkload.cpp.

Referenced by NeonLayerSupport::IsElementwiseUnarySupported().

 {
     const arm_compute::TensorInfo aclInput  = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NERsqrtLayer::validate(&aclInput, &aclOutput);
 }

◆ NeonSliceWorkloadValidate()

arm_compute::Status NeonSliceWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const SliceDescriptor &	descriptor
	)

Definition at line 21 of file NeonSliceWorkload.cpp.

Referenced by NeonLayerSupport::IsSliceSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     arm_compute::Coordinates starts;
     arm_compute::Coordinates ends;
 
     std::tie(starts, ends) = SetNeonSliceData(descriptor.m_Begin, descriptor.m_Size);
 
     return arm_compute::NESlice::validate(&aclInputInfo, &aclOutputInfo, starts, ends);
 }

◆ NeonSoftmaxWorkloadValidate()

arm_compute::Status NeonSoftmaxWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const SoftmaxDescriptor &	descriptor
	)

Definition at line 19 of file NeonSoftmaxWorkload.cpp.

Referenced by NeonLayerSupport::IsSoftmaxSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     int aclAxis_int = ComputeAclAxis(descriptor.m_Axis, input);
     unsigned int aclAxis = ComputePositiveAxis(aclAxis_int, input);
     return arm_compute::NESoftmaxLayer::validate(&aclInputInfo,
                                                  &aclOutputInfo,
                                                  descriptor.m_Beta,
                                                  static_cast<int>(aclAxis));
 }

◆ NeonSpaceToBatchNdWorkloadValidate()

arm_compute::Status NeonSpaceToBatchNdWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const SpaceToBatchNdDescriptor &	descriptor
	)

Definition at line 18 of file NeonSpaceToBatchNdWorkload.cpp.

Referenced by NeonLayerSupport::IsSpaceToBatchNdSupported().

 {
     const arm_compute::TensorInfo aclInputInfo  = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
 
     // ArmNN blockShape is [H, W] Cl asks for W, H
     int32_t blockHeight = boost::numeric_cast<int32_t>(descriptor.m_BlockShape[0]);
     int32_t blockWidth  = boost::numeric_cast<int32_t>(descriptor.m_BlockShape[1]);
 
     arm_compute::Size2D paddingLeftTop = BuildArmComputeSize2D(
             descriptor.m_PadList[1].first, descriptor.m_PadList[0].first);
     arm_compute::Size2D paddingRightBottom  = BuildArmComputeSize2D(
             descriptor.m_PadList[1].second, descriptor.m_PadList[0].second);
 
     return arm_compute::NESpaceToBatchLayer::validate(&aclInputInfo,
                                                       blockWidth,
                                                       blockHeight,
                                                       paddingLeftTop,
                                                       paddingRightBottom,
                                                       &aclOutputInfo);
 }

◆ NeonSpaceToDepthWorkloadValidate()

arm_compute::Status NeonSpaceToDepthWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const SpaceToDepthDescriptor &	descriptor
	)

Definition at line 17 of file NeonSpaceToDepthWorkload.cpp.

References SpaceToDepthDescriptor::m_DataLayout.

Referenced by NeonLayerSupport::IsSpaceToDepthSupported().

 {
     DataLayout dataLayout = descriptor.m_DataLayout;
     const arm_compute::TensorInfo aclInput = BuildArmComputeTensorInfo(input, dataLayout);
     const arm_compute::TensorInfo aclOutput = BuildArmComputeTensorInfo(output, dataLayout);
 
     int32_t blockSize  = boost::numeric_cast<int32_t>(descriptor.m_BlockSize);
 
     return arm_compute::NESpaceToDepthLayer::validate(&aclInput, &aclOutput, blockSize);
 }

◆ NeonSplitterWorkloadValidate()

arm_compute::Status NeonSplitterWorkloadValidate	(	const TensorInfo &	input,
		const std::vector< std::reference_wrapper< TensorInfo >> &	outputs,
		unsigned int	splitAxis
	)

Definition at line 32 of file NeonSplitterWorkload.cpp.

Referenced by NeonLayerSupport::IsSplitterSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input);
 
     size_t numOutputs = outputs.size();
 
     std::vector<arm_compute::TensorInfo> aclOutputs;
     aclOutputs.reserve(numOutputs);
 
     std::vector<arm_compute::ITensorInfo*> aclOutputPtr;
     aclOutputPtr.reserve(numOutputs);
 
     for (size_t i = 0u; i < outputs.size(); ++i)
     {
         aclOutputs.emplace_back(BuildArmComputeTensorInfo(outputs[i]));
         aclOutputPtr.emplace_back(&aclOutputs.back());
     }
 
     unsigned int aclAxis = CalcAclAxis(input.GetNumDimensions(), splitAxis);
     return arm_compute::NESplit::validate(&aclInputInfo, aclOutputPtr, aclAxis);
 }

◆ NeonStackWorkloadValidate()

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

Definition at line 28 of file NeonStackWorkload.cpp.

Referenced by NeonLayerSupport::IsStackSupported().

 {
     std::vector<arm_compute::TensorInfo> aclInputs;
     for (const TensorInfo* input : inputs)
     {
         arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(*input, armnn::DataLayout::NCHW);
         aclInputs.emplace_back(aclInputInfo);
     }
 
     std::vector<arm_compute::ITensorInfo*> aclInputPtrs;
     for (arm_compute::ITensorInfo& input : aclInputs)
     {
         aclInputPtrs.emplace_back(&input);
     }
 
     const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
     int aclAxis = CalcAxis(descriptor.m_Axis, descriptor.m_InputShape.GetNumDimensions());
     return arm_compute::NEStackLayer::validate(aclInputPtrs, aclAxis, &aclOutputInfo);
 }

◆ NeonStridedSliceWorkloadValidate()

arm_compute::Status NeonStridedSliceWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const StridedSliceDescriptor &	descriptor
	)

Definition at line 18 of file NeonStridedSliceWorkload.cpp.

Referenced by NeonLayerSupport::IsStridedSliceSupported().

 {
     const arm_compute::TensorInfo aclInput = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     arm_compute::Coordinates starts;
     arm_compute::Coordinates ends;
     arm_compute::Coordinates strides;
 
     std::tie(starts, ends, strides) = SetNeonStridedSliceData(descriptor.m_Begin,
                                                               descriptor.m_End,
                                                               descriptor.m_Stride);
 
     auto numDimensions       = boost::numeric_cast<int>(input.GetNumDimensions());
     int32_t begin_mask       = ConvertMaskToACLFormat(descriptor.m_BeginMask, numDimensions);
     int32_t end_mask         = ConvertMaskToACLFormat(descriptor.m_EndMask, numDimensions);
     int32_t shrink_axis_mask = ConvertMaskToACLFormat(descriptor.m_ShrinkAxisMask, numDimensions);
 
     return arm_compute::NEStridedSlice::validate(&aclInput,
                                                  &aclOutput,
                                                  starts,
                                                  ends,
                                                  strides,
                                                  begin_mask,
                                                  end_mask,
                                                  shrink_axis_mask);
 }

◆ NeonSubtractionWorkloadValidate()

arm_compute::Status NeonSubtractionWorkloadValidate	(	const TensorInfo &	input0,
		const TensorInfo &	input1,
		const TensorInfo &	output
	)

Definition at line 18 of file NeonSubtractionWorkload.cpp.

Referenced by NeonLayerSupport::IsSubtractionSupported().

 {
     const arm_compute::TensorInfo aclInput0 = armcomputetensorutils::BuildArmComputeTensorInfo(input0);
     const arm_compute::TensorInfo aclInput1 = armcomputetensorutils::BuildArmComputeTensorInfo(input1);
     const arm_compute::TensorInfo aclOutput = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
     return arm_compute::NEArithmeticSubtraction::validate(&aclInput0,
                                                           &aclInput1,
                                                           &aclOutput,
                                                           arm_compute::ConvertPolicy::SATURATE);
 }

◆ NeonTensorHandleFactoryId()

constexpr const char* armnn::NeonTensorHandleFactoryId ( )

Definition at line 14 of file NeonTensorHandleFactory.hpp.

Referenced by NeonTensorHandleFactory::GetIdStatic().

14 { return "Arm/Neon/TensorHandleFactory"; }

◆ NeonTransposeConvolution2dWorkloadValidate()

arm_compute::Status NeonTransposeConvolution2dWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const TransposeConvolution2dDescriptor &	descriptor,
		const TensorInfo &	weights,
		const Optional< TensorInfo > &	biases
	)

Definition at line 27 of file NeonTransposeConvolution2dWorkload.cpp.

Referenced by NeonLayerSupport::IsTransposeConvolution2dSupported().

 {
     const arm_compute::TensorInfo aclInputInfo   = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclOutputInfo  = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout);
     const arm_compute::TensorInfo aclWeightsInfo = BuildArmComputeTensorInfo(weights, descriptor.m_DataLayout);
 
     arm_compute::TensorInfo aclBiasesInfo;
     arm_compute::TensorInfo *optionalAclBiasesInfo = nullptr;
 
     if (descriptor.m_BiasEnabled)
     {
         ARMNN_ASSERT(biases.has_value());
 
         aclBiasesInfo = BuildArmComputeTensorInfo(biases.value(), descriptor.m_DataLayout);
         optionalAclBiasesInfo = &aclBiasesInfo;
     }
 
     arm_compute::PadStrideInfo layerInfo = BuildArmComputePadStrideInfo(descriptor);
 
     return arm_compute::NEDeconvolutionLayer::validate(&aclInputInfo,
                                                        &aclWeightsInfo,
                                                        optionalAclBiasesInfo,
                                                        &aclOutputInfo,
                                                        layerInfo);
 }

◆ NeonTransposeWorkloadValidate()

arm_compute::Status NeonTransposeWorkloadValidate	(	const TensorInfo &	input,
		const TensorInfo &	output,
		const TransposeDescriptor &	descriptor
	)

Definition at line 15 of file NeonTransposeWorkload.cpp.

Referenced by NeonLayerSupport::IsTransposeSupported().

 {
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
     const armnn::PermutationVector& mappings = descriptor.m_DimMappings;
 
     return arm_compute::NEPermute::validate(&aclInputInfo, &aclOutputInfo,
                                             armcomputetensorutils::BuildArmComputeTransposeVector(mappings));
 }

◆ NextIndex()

bool armnn::NextIndex	(	const unsigned int	numDims,
		const armnn::TensorShape &	dims,
		std::vector< unsigned int > &	current
	)

Definition at line 18 of file Mean.cpp.

Referenced by Mean().

 {
     unsigned int carry = 1;
 
     for (unsigned int idx = numDims; idx-- > 0; )
     {
         unsigned int current_val = current[idx] + carry;
         if (dims[idx] == current_val)
         {
             current[idx] = 0;
         }
         else
         {
             current[idx] = current_val;
             carry = 0;
             break;
         }
     }
     return (carry == 0);
 }

◆ NonMaxSuppression()

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
	)

Definition at line 50 of file DetectionPostProcess.cpp.

References GenerateRangeK(), IntersectionOverUnion(), numeric_cast(), and TopKSort().

Referenced by BOOST_AUTO_TEST_CASE(), and DetectionPostProcess().

 {
     // Select boxes that have scores above a given threshold.
     std::vector<float> scoresAboveThreshold;
     std::vector<unsigned int> indicesAboveThreshold;
     for (unsigned int i = 0; i < numBoxes; ++i)
     {
         if (scores[i] >= nmsScoreThreshold)
         {
             scoresAboveThreshold.push_back(scores[i]);
             indicesAboveThreshold.push_back(i);
         }
     }
 
     // Sort the indices based on scores.
     unsigned int numAboveThreshold = boost::numeric_cast<unsigned int>(scoresAboveThreshold.size());
     std::vector<unsigned int> sortedIndices = GenerateRangeK(numAboveThreshold);
     TopKSort(numAboveThreshold, sortedIndices.data(), scoresAboveThreshold.data(), numAboveThreshold);
 
     // Number of output cannot be more than max detections specified in the option.
     unsigned int numOutput = std::min(maxDetection, numAboveThreshold);
     std::vector<unsigned int> outputIndices;
     std::vector<bool> visited(numAboveThreshold, false);
 
     // Prune out the boxes with high intersection over union by keeping the box with higher score.
     for (unsigned int i = 0; i < numAboveThreshold; ++i)
     {
         if (outputIndices.size() >= numOutput)
         {
             break;
         }
         if (!visited[sortedIndices[i]])
         {
             outputIndices.push_back(indicesAboveThreshold[sortedIndices[i]]);
         }
         for (unsigned int j = i + 1; j < numAboveThreshold; ++j)
         {
             unsigned int iIndex = indicesAboveThreshold[sortedIndices[i]] * 4;
             unsigned int jIndex = indicesAboveThreshold[sortedIndices[j]] * 4;
             if (IntersectionOverUnion(&boxCorners[iIndex], &boxCorners[jIndex]) > nmsIouThreshold)
             {
                 visited[sortedIndices[j]] = true;
             }
         }
     }
     return outputIndices;
 }

◆ numeric_cast() [1/4]

std::enable_if_t< std::is_unsigned<Source>::value && std::is_unsigned<Dest>::value , Dest> armnn::numeric_cast ( Source source )

Definition at line 33 of file NumericCast.hpp.

References ARMNN_NUMERIC_CAST_CHECK.

Referenced by CaffeParserBase::AddConvLayerWithDepthwiseConv(), CaffeParserBase::AddConvLayerWithSplits(), AllocateOutputData(), ArgMinMax(), BOOST_AUTO_TEST_CASE(), ClArgMinMaxWorkload::ClArgMinMaxWorkload(), ClSpaceToBatchNdWorkload::ClSpaceToBatchNdWorkload(), ClStridedSliceWorkload::ClStridedSliceWorkload(), CompareActivationTestImpl(), armnnTfLiteParser::ComputeWrappedIndex(), OutputSlot::Connect(), CreateNetworkImpl< IParser >::Create(), SendCounterPacket::CreateCategoryRecord(), SendCounterPacket::CreateEventRecord(), TfLiteParser::CreateNetworkFromBinary(), RecordByRecordCaffeParser::CreateNetworkFromBinaryFile(), Debug(), DepthwiseConvolution2dAsymmetricTestImpl(), DepthwiseConvolution2dTestImpl(), Dequantize(), DetectionPostProcess(), RefL2NormalizationWorkload::Execute(), armnnUtils::ExpandDims(), FakeQuantization(), Gather(), CounterDirectory::GetCategoryCount(), MockCounterDirectory::GetCategoryCount(), CounterDirectory::GetCounterCount(), MockCounterDirectory::GetCounterCount(), CounterDirectory::GetCounterSetCount(), MockCounterDirectory::GetCounterSetCount(), CounterDirectory::GetDeviceCount(), MockCounterDirectory::GetDeviceCount(), Deserializer::GetNetworkOutputBindingInfo(), OutputSlot::GetNumConnections(), SubgraphView::GetNumInputSlots(), SubgraphView::GetNumOutputSlots(), StridedSliceDescriptor::GetStartForAxis(), StridedSliceDescriptor::GetStopForAxis(), GetStreamMetaDataPacketSize(), Cifar10Database::GetTestCaseData(), MnistDatabase::GetTestCaseData(), CaffePreprocessor::GetTestCaseData(), YoloDatabase::GetTestCaseData(), armnnUtils::GetUnsignedAxis(), RequestCountersPacketHandler::HandlePacket(), InferenceTestImage::InferenceTestImage(), PreluLayer::InferOutputShapes(), RefLayerSupport::IsMeanSupported(), CaffeParserBase::LoadNetParam(), LogSoftmax(), Mean(), NeonArgMinMaxWorkload::NeonArgMinMaxWorkload(), NeonSpaceToBatchNdWorkload::NeonSpaceToBatchNdWorkload(), NeonStridedSliceWorkload::NeonStridedSliceWorkload(), NonMaxSuppression(), ClassifierTestCaseProvider< TDatabase, InferenceModel >::OnInferenceTestFinished(), armnnTfParser::OutputShapeOfExpandDims(), Deserializer::OutputShapeOfReshape(), TfLiteParser::OutputShapeOfReshape(), armnnTfParser::OutputShapeOfSqueeze(), CaffeParserBase::ParseInputLayer(), CaffeParserBase::ParseLRNLayer(), Pooling2d(), ClassifierTestCase< TTestCaseDatabase, TModel >::ProcessResult(), QuantizerVisitor::QuantizerVisitor(), InferenceModel< IParser, TDataType >::Run(), Serializer::SaveSerializedToStream(), SendCounterPacket::SendPeriodicCounterCapturePacket(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), SendCounterPacket::SendStreamMetaDataPacket(), SimpleConvolution2dNhwcTestImpl(), SimpleConvolution2dTestImpl(), InferenceTestImage::StbResize(), StridedSlice(), Graph::SubstituteSubgraph(), MeanQueueDescriptor::Validate(), MeanLayer::ValidateTensorShapesFromInputs(), VerifyTimelineLabelBinaryPacketData(), armnn::profiling::WriteTimelineLabelBinaryPacket(), and armnn::profiling::WriteTimelineMessageDirectoryPackage().

 {
 #if ENABLE_NUMERIC_CAST_CHECKS
     if (source > std::numeric_limits<Dest>::max())
     {
         ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting unsigned type to "
                                         "narrower unsigned type. Overflow detected.");
     }
 #endif // ENABLE_NUMERIC_CAST_CHECKS
 
     return static_cast<Dest>(source);
 }

◆ numeric_cast() [2/4]

std::enable_if_t< std::is_signed<Source>::value && std::is_signed<Dest>::value , Dest> armnn::numeric_cast ( Source source )

Definition at line 51 of file NumericCast.hpp.

References ARMNN_NUMERIC_CAST_CHECK.

 {
     static_assert(!std::is_floating_point<Source>::value && !std::is_floating_point<Dest>::value,
         "numeric_cast doesn't cast float.");
 
 #if ENABLE_NUMERIC_CAST_CHECKS
     if (source > std::numeric_limits<Dest>::max())
     {
         ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed type to narrower signed type. "
                                         "Overflow detected.");
     }
 
     if (source < std::numeric_limits<Dest>::lowest())
     {
         ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed type to narrower signed type. "
                                         "Underflow detected.");
     }
 #endif // ENABLE_NUMERIC_CAST_CHECKS
 
     return static_cast<Dest>(source);
 }

◆ numeric_cast() [3/4]

std::enable_if_t< std::is_signed<Dest>::value && std::is_unsigned<Source>::value , Dest> armnn::numeric_cast ( Source sValue )

Definition at line 79 of file NumericCast.hpp.

References ARMNN_NUMERIC_CAST_CHECK.

 {
     static_assert(!std::is_floating_point<Dest>::value, "numeric_cast doesn't cast to float.");
 
 #if ENABLE_NUMERIC_CAST_CHECKS
     if (sValue > static_cast< typename std::make_unsigned<Dest>::type >(std::numeric_limits<Dest>::max()))
     {
         ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting unsigned type to signed type. "
                                         "Overflow detected.");
     }
 #endif // ENABLE_NUMERIC_CAST_CHECKS
 
     return static_cast<Dest>(sValue);
 }

◆ numeric_cast() [4/4]

std::enable_if_t< std::is_unsigned<Dest>::value && std::is_signed<Source>::value , Dest> armnn::numeric_cast ( Source sValue )

Definition at line 100 of file NumericCast.hpp.

References ARMNN_NUMERIC_CAST_CHECK.

 {
     static_assert(!std::is_floating_point<Source>::value && !std::is_floating_point<Dest>::value,
         "numeric_cast doesn't cast floats.");
 
 #if ENABLE_NUMERIC_CAST_CHECKS
     if (sValue < 0)
     {
         ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting negative value to unsigned type. "
                                         "Underflow detected.");
     }
 
     if (static_cast< typename std::make_unsigned<Source>::type >(sValue) > std::numeric_limits<Dest>::max())
     {
         ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed type to unsigned type. "
                                         "Overflow detected.");
     }
 
 #endif // ENABLE_NUMERIC_CAST_CHECKS
     return static_cast<Dest>(sValue);
 }

◆ Offset()

unsigned int armnn::Offset	(	const TensorShape &	shape,
		unsigned int	batch,
		unsigned int	height,
		unsigned int	width,
		unsigned int	channels,
		const DataLayoutIndexed &	dataLayout
	)

inline

Definition at line 19 of file BatchToSpaceNd.cpp.

References DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetDataLayout(), DataLayoutIndexed::GetHeightIndex(), DataLayoutIndexed::GetWidthIndex(), and NHWC.

Referenced by BatchToSpaceNd().

 {
     if (dataLayout.GetDataLayout() == DataLayout::NHWC)
     {
         return ((batch * shape[dataLayout.GetHeightIndex()] + height) * shape[dataLayout.GetWidthIndex()] + width) *
                shape[dataLayout.GetChannelsIndex()] + channels;
     }
     else
     {
         return ((batch * shape[dataLayout.GetChannelsIndex()] + channels) *
                shape[dataLayout.GetHeightIndex()] + height) *
                shape[dataLayout.GetWidthIndex()] + width;
     }
 }

◆ operator<<() [1/9]

std::ostream& armnn::operator<<	(	std::ostream &	os,
		const std::vector< Compute > &	compute
	)

inline

Deprecated function that will be removed together with the Compute enum.

Definition at line 47 of file BackendId.hpp.

References GetComputeDeviceAsCString().

 {
     for (const Compute& comp : compute)
     {
         os << GetComputeDeviceAsCString(comp) << " ";
     }
     return os;
 }

◆ operator<<() [2/9]

std::ostream& armnn::operator<<	(	std::ostream &	os,
		const std::set< Compute > &	compute
	)

inline

Deprecated function that will be removed together with the Compute enum.

Definition at line 58 of file BackendId.hpp.

References GetComputeDeviceAsCString().

 {
     for (const Compute& comp : compute)
     {
         os << GetComputeDeviceAsCString(comp) << " ";
     }
     return os;
 }

◆ operator<<() [3/9]

std::ostream& armnn::operator<<	(	std::ostream &	os,
		const BackendVersion &	backendVersion
	)

inline

Definition at line 61 of file IBackendInternal.hpp.

References BackendVersion::m_Major, and BackendVersion::m_Minor.

 {
     os << "[" << backendVersion.m_Major << "." << backendVersion.m_Minor << "]";
 
     return os;
 }

◆ operator<<() [4/9]

std::ostream& armnn::operator<<	(	std::ostream &	os,
		const Compute &	compute
	)

inline

Deprecated function that will be removed together with the Compute enum.

Definition at line 69 of file BackendId.hpp.

References GetComputeDeviceAsCString().

 {
     os << GetComputeDeviceAsCString(compute);
     return os;
 }

◆ operator<<() [5/9]

std::ostream& armnn::operator<<	(	std::ostream &	os,
		const BFloat16 &	b
	)

inline

Definition at line 119 of file BFloat16.hpp.

References BFloat16::ToFloat32(), and BFloat16::Val().

 {
     os << b.ToFloat32() << "(0x" << std::hex << b.Val() << ")";
     return os;
 }

◆ operator<<() [6/9]

std::ostream& armnn::operator<<	(	std::ostream &	os,
		const BackendId &	id
	)

inline

Definition at line 174 of file BackendId.hpp.

 {
     os << id.Get();
     return os;
 }

◆ operator<<() [7/9]

std::ostream& armnn::operator<<	(	std::ostream &	os,
		const TContainer< BackendId, TContainerTemplateArgs... > &	ids
	)

Definition at line 181 of file BackendId.hpp.

 {
     os << '[';
     for (const auto& id : ids) { os << id << " "; }
     os << ']';
     return os;
 }

◆ operator<<() [8/9]

std::ostream& armnn::operator<<	(	std::ostream &	os,
		Status	stat
	)

inline

Definition at line 256 of file TypesUtils.hpp.

References GetStatusAsCString().

 {
     os << GetStatusAsCString(stat);
     return os;
 }

◆ operator<<() [9/9]

std::ostream& armnn::operator<<	(	std::ostream &	os,
		const armnn::TensorShape &	shape
	)

inline

Definition at line 263 of file TypesUtils.hpp.

References Dequantize, TensorShape::GetNumDimensions(), and Quantize.

 {
     os << "[";
     for (uint32_t i=0; i<shape.GetNumDimensions(); ++i)
     {
         if (i!=0)
         {
             os << ",";
         }
         os << shape[i];
     }
     os << "]";
     return os;
 }

◆ operator>>() [1/2]

std::istream& armnn::operator>>	(	std::istream &	in,
		armnn::Compute &	compute
	)

inline

Definition at line 20 of file InferenceTest.hpp.

References ParseComputeDevice(), and Undefined.

 {
     std::string token;
     in >> token;
     compute = armnn::ParseComputeDevice(token.c_str());
     if (compute == armnn::Compute::Undefined)
     {
         in.setstate(std::ios_base::failbit);
         throw boost::program_options::validation_error(boost::program_options::validation_error::invalid_option_value);
     }
     return in;
 }

◆ operator>>() [2/2]

std::istream& armnn::operator>>	(	std::istream &	in,
		armnn::BackendId &	backend
	)

inline

Definition at line 33 of file InferenceTest.hpp.

References ParseComputeDevice(), and Undefined.

 {
     std::string token;
     in >> token;
     armnn::Compute compute = armnn::ParseComputeDevice(token.c_str());
     if (compute == armnn::Compute::Undefined)
     {
         in.setstate(std::ios_base::failbit);
         throw boost::program_options::validation_error(boost::program_options::validation_error::invalid_option_value);
     }
     backend = compute;
     return in;
 }

◆ Optimize()

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.

Parameters

network	INetwork description of the network to be optimized.
backendPreferences	The choice of the backend ordered by user preferences.
deviceSpec	DeviceSpec object as queried from the runtime. See IRuntime::GetDeviceSpec()
messages	If there are failures or warnings a string describing same will be added to the vector
options	OptimizerOptions object with optimizer configuration options

Returns: An IOptimizedNetworkPtr interface to the optimized network, throws an exception derived from armnn::Exception if process fails.

Definition at line 1014 of file Network.cpp.

References ApplyBackendOptimizations(), ARMNN_ASSERT, ARMNN_NO_DEPRECATE_WARN_BEGIN, ARMNN_NO_DEPRECATE_WARN_END, AssignBackends(), BackendRegistryInstance(), CreateSupportedBackends(), IOptimizedNetwork::Destroy(), BackendSettings::GetAvailablePreferredBackends(), BackendRegistry::GetFactory(), Network::GetGraph(), OptimizedNetwork::GetGraph(), OptimizerOptions::m_Debug, OptimizationResult::m_Error, OptimizerOptions::m_ImportEnabled, OptimizerOptions::m_ReduceFp32ToBf16, OptimizerOptions::m_ReduceFp32ToFp16, BackendSettings::m_SelectedBackends, BackendSettings::m_SupportedBackends, MakeOptimizations(), Optimizer::Pass(), ReportError(), and SelectTensorHandleStrategy().

Referenced by BOOST_AUTO_TEST_CASE(), BOOST_FIXTURE_TEST_CASE(), GetSoftmaxProfilerJson(), InferenceModel< IParser, TDataType >::InferenceModel(), main(), QLstmEndToEnd(), QuantizedLstmEndToEnd(), NetworkQuantizer::Refine(), ParserPrototxtFixture< armnnOnnxParser::IOnnxParser >::Setup(), ParserFlatbuffersSerializeFixture::Setup(), ParserFlatbuffersFixture::Setup(), ParserPrototxtFixture< armnnOnnxParser::IOnnxParser >::SetupOptimizedNetwork(), and VerifyPostOptimisationStructureTestImpl().

 {
     if (backendPreferences.empty())
     {
         throw armnn::InvalidArgumentException("Invoked Optimize with no backends specified");
     }
 
     if (options.m_ReduceFp32ToFp16 && options.m_ReduceFp32ToBf16)
     {
         throw InvalidArgumentException("BFloat16 and Float16 optimization cannot be enabled at the same time.");
     }
 
     const Network& network = *PolymorphicDowncast<const Network*>(&inNetwork);
     std::unique_ptr<Graph> graph = std::make_unique<Graph>(network.GetGraph());
 
     auto optNet = IOptimizedNetworkPtr(new OptimizedNetwork(std::move(graph)), &IOptimizedNetwork::Destroy);
 
     OptimizedNetwork* optNetObjPtr = PolymorphicDowncast<OptimizedNetwork*>(optNet.get());
 
     // Get the optimized graph
     Graph& optGraph = optNetObjPtr->GetGraph();
 
     // Perform optimisation passes
     using namespace optimizations;
     Optimizer::Pass(optGraph, MakeOptimizations(SquashEqualPermuteSiblings(),
                                                 SquashEqualTransposeSiblings(),
                                                 SquashEqualReshapeSiblings(),
                                                 OptimizeInversePermutes(),
                                                 OptimizeInverseTransposes(),
                                                 MovePermuteUp(),
                                                 MoveTransposeUp(),
                                                 PermuteAsReshape(),
                                                 TransposeAsReshape(),
                                                 OptimizeConsecutiveReshapes(),
                                                 FoldPadIntoConvolution2d(),
                                                 PermuteAndBatchToSpaceAsDepthToSpace(),
                                                 TransposeAndBatchToSpaceAsDepthToSpace()));
 
     // Infer the tensor infos for all output slots. Throws an exception on failure
     optGraph.InferTensorInfos();
 
     // If Fp32 to Fp16 optimization is set convert Fp32 network to Fp16
     if (options.m_ReduceFp32ToFp16)
     {
         Optimizer::Pass(optGraph, MakeOptimizations(Fp32NetworkToFp16Converter()));
         Optimizer::Pass(optGraph, MakeOptimizations(ConvertConstantsFloatToHalf()));
     }
 
     // If Fp32 to Bf16 optimization is set convert Fp32 network to Bf16
     // Convert input of Convolution2d and FullyConnected from Fp32 to Bf16
     // Only Constant weight of Convolution2d and FullyConnected are converted from Fp32 to Bf16
     if (options.m_ReduceFp32ToBf16)
     {
         Optimizer::Pass(optGraph, MakeOptimizations(Fp32NetworkToBf16Converter()));
     }
 
     // Initialize backend settings
     BackendSettings backendSettings(backendPreferences, deviceSpec);
     if (backendSettings.GetAvailablePreferredBackends().empty())
     {
         std::stringstream failureMsg;
         failureMsg << "None of the preferred backends " << backendPreferences
                    << " are supported. Current platform provides " << backendSettings.m_SupportedBackends;
         ReportError(failureMsg.str(), messages);
         return IOptimizedNetworkPtr(nullptr, &IOptimizedNetwork::Destroy);
     }
 
     // Create a map to temporarily hold initialized backend objects
     TensorHandleFactoryRegistry tensorHandleFactoryRegistry;
     BackendsMap backends = CreateSupportedBackends(tensorHandleFactoryRegistry, backendSettings);
 
     // Assign an available backend to each layer
     Graph::Iterator firstLayer = optGraph.begin();
     Graph::Iterator lastLayer  = optGraph.end();
     OptimizationResult assignBackendsResult = AssignBackends(optNetObjPtr,
                                                              backendSettings,
                                                              firstLayer,
                                                              lastLayer,
                                                              messages);
     if (assignBackendsResult.m_Error)
     {
         // Failed to assign a backend to each layer
         return IOptimizedNetworkPtr(nullptr, &IOptimizedNetwork::Destroy);
     }
 
     Optimizer::Pass(optGraph, MakeOptimizations(OptimizeInverseConversionsFp16(),
                                                 OptimizeInverseConversionsFp32()));
 
     // Apply the backend-specific optimizations
     OptimizationResult backendOptimizationResult = ApplyBackendOptimizations(optNetObjPtr,
                                                                              backendSettings,
                                                                              backends,
                                                                              messages);
     if (backendOptimizationResult.m_Error)
     {
         // Failed to apply the backend-specific optimizations
         return IOptimizedNetworkPtr(nullptr, &IOptimizedNetwork::Destroy);
     }
 
     // If the debug flag is set, then insert a DebugLayer after each layer
     // Doing this after applying the backend optimizations as they might have changed some layers
     if (options.m_Debug)
     {
         Optimizer::Pass(optGraph, MakeOptimizations(InsertDebugLayer()));
     }
 
     // Calculate the compatibility strategies for tensor handles
     OptimizationResult strategyResult = SelectTensorHandleStrategy(optGraph,
                                                                    backends,
                                                                    tensorHandleFactoryRegistry,
                                                                    options.m_ImportEnabled,
                                                                    messages);
     if (strategyResult.m_Error)
     {
         // Failed to apply the backend-specific optimizations
         return IOptimizedNetworkPtr(nullptr, &IOptimizedNetwork::Destroy);
     }
 
     // Based on the tensor handle strategy determined above, insert copy layers where required.
     optGraph.AddCompatibilityLayers(backends, tensorHandleFactoryRegistry);
 
     // Convert constants
     Optimizer::Pass(optGraph, MakeOptimizations(ConvertConstantsFloatToHalf()));
     Optimizer::Pass(optGraph, MakeOptimizations(ConvertConstantsHalfToFloat()));
 
     // Run backend specific optimizations (deprecated)
     for (auto&& chosenBackend : backendSettings.m_SelectedBackends)
     {
         auto factoryFun = BackendRegistryInstance().GetFactory(chosenBackend);
         auto backendPtr = factoryFun();
         ARMNN_ASSERT(backendPtr.get() != nullptr);
 
         ARMNN_NO_DEPRECATE_WARN_BEGIN
         auto backendSpecificOptimizations = backendPtr->GetOptimizations();
         ARMNN_NO_DEPRECATE_WARN_END
 
         if (!backendSpecificOptimizations.empty())
         {
             Optimizer::Pass(optNetObjPtr->GetGraph(), backendSpecificOptimizations);
         }
     }
 
     return optNet;
 }

◆ Pad()

void Pad	(	const TensorInfo &	inputInfo,
		const TensorInfo &	outputInfo,
		const PadQueueDescriptor &	data
	)

Definition at line 39 of file Pad.cpp.

References Decoder< IType >::Get(), TensorShape::GetNumDimensions(), TensorInfo::GetNumElements(), TensorInfo::GetShape(), QueueDescriptor::m_Inputs, QueueDescriptor::m_Outputs, PadDescriptor::m_PadList, PadDescriptor::m_PadValue, QueueDescriptorWithParameters< LayerDescriptor >::m_Parameters, and Encoder< IType >::Set().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     auto padList  = data.m_Parameters.m_PadList;
     auto padValue = data.m_Parameters.m_PadValue;
 
     unsigned int numOutputElements = outputInfo.GetNumElements();
 
     TensorShape outputShape = outputInfo.GetShape();
     TensorShape inputShape  = inputInfo.GetShape();
 
     unsigned int numInputDimensions = inputShape.GetNumDimensions();
 
 #ifndef NDEBUG
 
     unsigned int numOutputDimensions = outputShape.GetNumDimensions();
     assert(numInputDimensions == numOutputDimensions);
 
 #endif
 
     unsigned int inputBatches  = 0;
     unsigned int inputChannels = 0;
     unsigned int inputHeight   = 0;
     unsigned int inputWidth    = 0;
 
     unsigned int outputChannels = 0;
     unsigned int outputHeight   = 0;
     unsigned int outputWidth    = 0;
 
     auto inputData = MakeDecoder<float>(inputInfo, data.m_Inputs[0]->Map());
     auto outData   = MakeEncoder<float>(outputInfo, data.m_Outputs[0]->Map());
 
     // Fill the output tensor with Pad value first
     if (outputInfo.IsQuantized())
     {
         // For Quantized types Pad Value should not be quantized with scale and offset of the tensor info
         auto temporaryInfo = TensorInfo(outputInfo.GetShape(), outputInfo.GetDataType(), 1.0f, 0);
         auto outputData = MakeEncoder<float>(temporaryInfo, data.m_Outputs[0]->Map());
         FillOutputWithPadValue(*outputData, padValue, numOutputElements);
     }
     else
     {
         FillOutputWithPadValue(*outData, padValue, numOutputElements);
     }
 
     Decoder<float>& input  = *inputData;
     Encoder<float>& output = *outData;
 
     switch(numInputDimensions) {
 
         case 1:
             inputWidth = inputShape[0];
             for (unsigned int w = 0; w < inputWidth ; w++)
             {
                 input[w];
                 auto inputValue = input.Get();
                 auto outputIndex = w + std::get<0>(padList[0]);
                 output[outputIndex];
                 output.Set(inputValue);
             }
 
             break;
         case 2  :
             inputHeight = inputShape[0];
             inputWidth  = inputShape[1];
             outputWidth = outputShape[1];
 
             for (unsigned int h = 0; h < inputHeight; h++)
             {
                 for (unsigned int w = 0; w < inputWidth ; w++)
                 {
                     input[h * inputWidth + w];
                     auto inputValue  = input.Get();
                     auto outputIndex = (h + std::get<0>(padList[0])) * outputWidth + (w + std::get<0>(padList[1]));
                     output[outputIndex];
                     output.Set(inputValue);
                 }
             }
 
             break;
         case 3  :
             inputChannels = inputShape[0];
             inputHeight   = inputShape[1];
             inputWidth    = inputShape[2];
             outputHeight  = outputShape[1];
             outputWidth   = outputShape[2];
 
             for (unsigned int c = 0; c < inputChannels; c++)
             {
                 for (unsigned int h = 0; h < inputHeight; h++)
                 {
                     for (unsigned int w = 0; w < inputWidth ; w++)
                     {
                         input[c * inputHeight * inputWidth + h * inputWidth + w];
                         auto inputValue  = input.Get();
                         auto outputIndex = (c + std::get<0>(padList[0])) * outputHeight * outputWidth
                                            + (h + std::get<0>(padList[1])) * outputWidth
                                            + (w + std::get<0>(padList[2]));
                         output[outputIndex];
                         output.Set(inputValue);
                     }
                 }
             }
 
             break;
         case 4  :
             inputBatches   = inputShape[0];
             inputChannels  = inputShape[1];
             inputHeight    = inputShape[2];
             inputWidth     = inputShape[3];
             outputChannels = outputShape[1];
             outputHeight   = outputShape[2];
             outputWidth    = outputShape[3];
 
             for (unsigned int b = 0; b < inputBatches; b++)
             {
                 for (unsigned int c = 0; c < inputChannels; c++)
                 {
                     for (unsigned int h = 0; h < inputHeight; h++)
                     {
                         for (unsigned int w = 0; w < inputWidth ; w++)
                         {
                             input[b * inputChannels * inputHeight * inputWidth
                                       + c * inputHeight * inputWidth
                                       + h * inputWidth
                                       + w];
                             auto inputValue  = input.Get();
                             auto outputIndex = (b + std::get<0>(padList[0]))
                                                * outputChannels * outputHeight * outputWidth
                                                + (c + std::get<0>(padList[1])) * outputHeight * outputWidth
                                                + (h + std::get<0>(padList[2])) * outputWidth
                                                + (w + std::get<0>(padList[3]));
                             output[outputIndex];
                             output.Set(inputValue);
                         }
                     }
                 }
             }
 
             break;
         default :
             break;
     }
 }

◆ ParseBoolean()

bool armnn::ParseBoolean	(	const BackendOptions::Var &	value,
		bool	defaultValue
	)

Definition at line 96 of file ClBackendContext.cpp.

References BackendOptions::Var::AsBool(), and BackendOptions::Var::IsBool().

 {
     if (value.IsBool())
     {
         return value.AsBool();
     }
 
     return defaultValue;
 }

◆ ParseComputeDevice()

constexpr armnn::Compute armnn::ParseComputeDevice ( const char * str )

Deprecated function that will be removed together with the Compute enum.

Definition at line 148 of file TypesUtils.hpp.

References CpuAcc, CpuRef, GpuAcc, StrEqual(), and Undefined.

Referenced by operator>>().

 {
     if (armnn::StrEqual(str, "CpuAcc"))
     {
         return armnn::Compute::CpuAcc;
     }
     else if (armnn::StrEqual(str, "CpuRef"))
     {
         return armnn::Compute::CpuRef;
     }
     else if (armnn::StrEqual(str, "GpuAcc"))
     {
         return armnn::Compute::GpuAcc;
     }
     else
     {
         return armnn::Compute::Undefined;
     }
 }

◆ ParseFile()

std::string armnn::ParseFile	(	const BackendOptions::Var &	value,
		std::string	defaultValue
	)

Definition at line 106 of file ClBackendContext.cpp.

References BackendOptions::Var::AsString(), and BackendOptions::Var::IsString().

Referenced by ClBackendContext::ClBackendContext().

 {
     if (value.IsString())
     {
         return value.AsString();
     }
     return defaultValue;
 }

◆ ParseOptions()

void armnn::ParseOptions	(	const std::vector< BackendOptions > &	options,
		BackendId	backend,
		F	f
	)

Definition at line 116 of file ClBackendContext.cpp.

References BackendOptions::BackendOption::GetName(), and BackendOptions::BackendOption::GetValue().

Referenced by ClBackendContext::ClBackendContext().

 {
     for (auto optionsGroup : options)
     {
         if (optionsGroup.GetBackendId() == backend)
         {
             for (size_t i=0; i < optionsGroup.GetOptionCount(); i++)
             {
                 const BackendOptions::BackendOption option = optionsGroup.GetOption(i);
                 f(option.GetName(), option.GetValue());
             }
         }
     }
 }

◆ ParseTuningLevel()

TuningLevel armnn::ParseTuningLevel	(	const BackendOptions::Var &	value,
		TuningLevel	defaultValue
	)

Definition at line 78 of file ClBackendContext.cpp.

References ARMNN_LOG, BackendOptions::Var::AsInt(), Exhaustive, BackendOptions::Var::IsInt(), None, and warning.

Referenced by ClBackendContext::ClBackendContext().

 {
     if (value.IsInt())
     {
         int v = value.AsInt();
         if (v > static_cast<int>(TuningLevel::Exhaustive) ||
             v < static_cast<int>(TuningLevel::None))
         {
             ARMNN_LOG(warning) << "Invalid GpuAcc tuning level ("<< v << ") selected. "
                                   "Using default(" << static_cast<int>(defaultValue) << ")";
         } else
         {
             return static_cast<TuningLevel>(v);
         }
     }
     return defaultValue;
 }

◆ PermuteTensor()

armnn::ConstTensor PermuteTensor	(	const ConstCpuTensorHandle *	tensor,
		const PermutationVector &	permutationVector,
		void *	permuteBuffer
	)

Definition at line 15 of file WorkloadUtils.cpp.

References ARMNN_ASSERT_MSG, ConstCpuTensorHandle::GetConstTensor(), TensorInfo::GetDataType(), GetDataTypeSize(), TensorInfo::GetNumBytes(), TensorInfo::GetShape(), PermutationVector::GetSize(), ConstCpuTensorHandle::GetTensorInfo(), Permute, and armnnUtils::Permuted().

Referenced by ConvertWeightTensorFromArmnnToAcl(), and GatherTensorHandlePairs().

 {
     ARMNN_ASSERT_MSG(tensor, "Invalid input tensor");
     ARMNN_ASSERT_MSG(permuteBuffer, "Invalid permute buffer");
 
     TensorInfo tensorInfo = tensor->GetTensorInfo();
 
     if (permutationVector.GetSize() > 0)
     {
         tensorInfo = armnnUtils::Permuted(tensorInfo, permutationVector);
         armnnUtils::Permute(tensorInfo.GetShape(), permutationVector,
                             tensor->GetConstTensor<void>(), permuteBuffer,
                             GetDataTypeSize(tensorInfo.GetDataType()));
     }
     else
     {
         ::memcpy(permuteBuffer, tensor->GetConstTensor<void>(), tensorInfo.GetNumBytes());
     }
 
     return ConstTensor(tensorInfo, permuteBuffer);
 }

◆ PolymorphicDowncast()

DestType armnn::PolymorphicDowncast ( SourceType value )

Polymorphic downcast for build in pointers only.

Usage: Child* pChild = PolymorphicDowncast<Child*>(pBase);

Template Parameters

DestType	Pointer type to the target object (Child pointer type)
SourceType	Pointer type to the source object (Base pointer type)

Parameters

value Pointer to the source object

Returns: Pointer of type DestType (Pointer of type child)

Definition at line 74 of file PolymorphicDowncast.hpp.

References ARMNN_POLYMORPHIC_CAST_CHECK.

 {
     static_assert(std::is_pointer<SourceType>::value &&
                   std::is_pointer<DestType>::value,
                   "PolymorphicDowncast only works with pointer types.");
 
     ARMNN_POLYMORPHIC_CAST_CHECK(dynamic_cast<DestType>(value) == static_cast<DestType>(value));
     return static_cast<DestType>(value);
 }

◆ PolymorphicPointerDowncast()

auto armnn::PolymorphicPointerDowncast ( const SourceType & value )

Polymorphic downcast for shared pointers and build in pointers.

Usage: auto pChild = PolymorphicPointerDowncast<Child>(pBase)

Template Parameters

DestType	Type of the target object (Child type)
SourceType	Pointer type to the source object (Base (shared) pointer type)

Parameters

value Pointer to the source object

Returns: Pointer of type DestType ((Shared) pointer of type child)

Definition at line 94 of file PolymorphicDowncast.hpp.

References ARMNN_POLYMORPHIC_CAST_CHECK.

 {
     ARMNN_POLYMORPHIC_CAST_CHECK(utility::DynamicPointerCast<DestType>(value)
                                  == utility::StaticPointerCast<DestType>(value));
     return utility::StaticPointerCast<DestType>(value);
 }

◆ Pooling2d()

void Pooling2d	(	Decoder< float > &	rInputDecoder,
		Encoder< float > &	rOutputEncoder,
		const TensorInfo &	inputInfo,
		const TensorInfo &	outputInfo,
		const Pooling2dDescriptor &	params
	)

Computes the Pooling2d operation.

Definition at line 143 of file Pooling2d.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), Pooling2d(), and Pooling2dLayer::Pooling2dLayer().

 {
     const DataLayoutIndexed dataLayout(params.m_DataLayout);
     auto channelsIndex = dataLayout.GetChannelsIndex();
     auto heightIndex = dataLayout.GetHeightIndex();
     auto widthIndex = dataLayout.GetWidthIndex();
 
     const int batchSize    = boost::numeric_cast<int>(outputInfo.GetShape()[0]);
     const int channels     = boost::numeric_cast<int>(outputInfo.GetShape()[channelsIndex]);
     const int heightOutput = boost::numeric_cast<int>(outputInfo.GetShape()[heightIndex]);
     const int widthOutput  = boost::numeric_cast<int>(outputInfo.GetShape()[widthIndex]);
     const int heightInput  = boost::numeric_cast<int>(inputInfo.GetShape()[heightIndex]);
     const int widthInput   = boost::numeric_cast<int>(inputInfo.GetShape()[widthIndex]);
     const int padLeft      = boost::numeric_cast<int>(params.m_PadLeft);
     const int padRight     = boost::numeric_cast<int>(params.m_PadRight);
     const int padTop       = boost::numeric_cast<int>(params.m_PadTop);
     const int padBottom    = boost::numeric_cast<int>(params.m_PadBottom);
     const int strideX      = boost::numeric_cast<int>(params.m_StrideX);
     const int strideY      = boost::numeric_cast<int>(params.m_StrideY);
     const int poolHeight   = boost::numeric_cast<int>(params.m_PoolHeight);
     const int poolWidth    = boost::numeric_cast<int>(params.m_PoolWidth);
 
     float defaultInitializer = DefaultInitializer(params.m_PoolType);
 
     Accumulator accumulate = GetAccumulator(params.m_PoolType);
     Executor execute       = GetExecutor(params.m_PoolType);
 
     TensorShape outputShape = outputInfo.GetShape();
     TensorShape inputShape =  inputInfo.GetShape();
 
     // Check supported padding methods outside the loop to simplify
     // the inner loop.
     if (params.m_PaddingMethod != PaddingMethod::Exclude &&
         params.m_PaddingMethod != PaddingMethod::IgnoreValue)
     {
         throw armnn::InvalidArgumentException("Unsupported padding type");
     }
 
     for (int n = 0; n < batchSize; n++)
     {
         for (int c = 0; c < channels; c++)
         {
             for (int yOutput = 0; yOutput < heightOutput; yOutput++)
             {
                 //  Calculate values independent of the x axis
                 int hstart = (yOutput * strideY) - padTop;
                 int hend = hstart + poolHeight;
                 // Clamp the pooling region inside the valid input area (which includes the padding).
                 // This is necessary because the final pooling in a row may overlap beyond the padding.
                 hend = std::min(hend, heightInput + padBottom);
 
                 int height = hend - hstart;
                 bool hclamped = ClampRange(hstart, hend, heightInput);
 
                 for (int xOutput = 0; xOutput < widthOutput; xOutput++)
                 {
                     int wstart = (xOutput * strideX) - padLeft;
                     int wend = wstart + poolWidth;
 
                     // Clamp the pooling region inside the valid input area (which includes the padding).
                     // This is necessary because the final pooling in a row may overlap beyond the padding.
                     wend = std::min(wend, widthInput + padRight);
 
                     float result = defaultInitializer;
                     float poolAreaSize = boost::numeric_cast<float>(height * (wend - wstart));
 
                     // Special case: when the pooling kernel is over a padding region and the padding
                     //               size is larger or equal to the kernel and the kernel only covers
                     //               padding and no real values, then we initialize the result as zero
                     //               by convention. This is because we need to choose a value here and
                     //               all values we have are padding, which we ignore.
                     if (OnPaddingOnly(hstart, hend, heightInput) ||
                         OnPaddingOnly(wstart, wend, widthInput))
                     {
                         result = 0.0f;
 
                         unsigned int outputIndex = dataLayout.GetIndex(outputShape,
                                                                        boost::numeric_cast<unsigned int>(n),
                                                                        boost::numeric_cast<unsigned int>(c),
                                                                        boost::numeric_cast<unsigned int>(yOutput),
                                                                        boost::numeric_cast<unsigned int>(xOutput));
                         rOutputEncoder[outputIndex];
                         rOutputEncoder.Set(result);
                         continue;
                     }
 
                     bool clamped = hclamped |= ClampRange(wstart, wend, widthInput);
 
                     if (clamped && params.m_PaddingMethod == PaddingMethod::Exclude)
                     {
                         // When we exclude the padding, it means we calculate with a smaller
                         // kernel size, so I changed the divisor here.
                         poolAreaSize = boost::numeric_cast<float>((hend - hstart) * (wend - wstart));
                     }
 
                     for (auto yInput = hstart; yInput < hend; yInput++)
                     {
                         for (auto xInput = wstart; xInput < wend; xInput++)
                         {
                             unsigned int inputIndex = dataLayout.GetIndex(inputShape,
                                                                           boost::numeric_cast<unsigned int>(n),
                                                                           boost::numeric_cast<unsigned int>(c),
                                                                           boost::numeric_cast<unsigned int>(yInput),
                                                                           boost::numeric_cast<unsigned int>(xInput));
 
                             rInputDecoder[inputIndex];
                             float inval = rInputDecoder.Get();
 
                             accumulate(result, inval);
                         }
                     }
 
                     execute(result, poolAreaSize);
 
                     unsigned int outputIndex = dataLayout.GetIndex(outputShape,
                                                                    boost::numeric_cast<unsigned int>(n),
                                                                    boost::numeric_cast<unsigned int>(c),
                                                                    boost::numeric_cast<unsigned int>(yOutput),
                                                                    boost::numeric_cast<unsigned int>(xOutput));
 
                     rOutputEncoder[outputIndex];
                     rOutputEncoder.Set(result);
                 }
             }
         }
     }
 }

◆ PreluImpl()

void PreluImpl	(	const PreluQueueDescriptor &	data,
		Decoder< float > &	inputData,
		Decoder< float > &	alphaData,
		Encoder< float > &	outputData
	)

Definition at line 13 of file PreluImpl.cpp.

References TensorInfo::GetShape(), GetTensorInfo(), QueueDescriptor::m_Inputs, QueueDescriptor::m_Outputs, and BroadcastLoop::Unroll().

Referenced by RefPreluWorkload::Execute().

 {
     const TensorInfo& inputInfo  = GetTensorInfo(data.m_Inputs[0]);
     const TensorInfo& alphaInfo  = GetTensorInfo(data.m_Inputs[1]);
     const TensorInfo& outputInfo = GetTensorInfo(data.m_Outputs[0]);
 
     const TensorShape& inputShape  = inputInfo.GetShape();
     const TensorShape& alphaShape  = alphaInfo.GetShape();
     const TensorShape& outputShape = outputInfo.GetShape();
 
     // PReLU activation: f(x) = alpha * x for x < 0, f(x) = x for x >= 0
     auto prelu = [](float x, float alpha)
     {
         return x < 0 ? alpha * x : x;
     };
 
     BroadcastLoop(inputShape, alphaShape, outputShape).Unroll(prelu, 0, inputData, alphaData, outputData);
 }

◆ PreserveTypeTestImpl()

void armnn::PreserveTypeTestImpl ( const DataType & dataType )

Definition at line 2998 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float16, Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), info, QAsymmU8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     INetworkPtr network = INetwork::Create();
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* input1 = network->AddInputLayer(1);
     IConnectableLayer* addition = network->AddAdditionLayer();
     IConnectableLayer* output = network->AddOutputLayer(2);
 
     input0->GetOutputSlot(0).Connect(addition->GetInputSlot(0));
     input1->GetOutputSlot(0).Connect(addition->GetInputSlot(1));
     addition->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     const TensorShape shape{1U, 2U, 3U};
     const TensorInfo info(shape, dataType);
     input0->GetOutputSlot(0).SetTensorInfo(info);
     input1->GetOutputSlot(0).SetTensorInfo(info);
     addition->GetOutputSlot(0).SetTensorInfo(info);
 
     QuantizerOptions options = dataType == DataType::Float32 ?
             QuantizerOptions(DataType::QAsymmU8, true) : QuantizerOptions(dataType, true);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get(), options)->ExportNetwork();
     TestPreserveType validatorQAsymmU8(options, dataType, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
     validatorQAsymmU8.CheckQuantizeDequantizeLayerVisited(
     dataType == DataType::Float32 || dataType == DataType::Float16);
 }

◆ Quantize() [1/2]

void armnn::Quantize	(	uint8_t *	quant,
		const float *	dequant,
		const TensorInfo &	info
	)

inline

Definition at line 108 of file RefWorkloadUtils.hpp.

References TensorInfo::GetNumElements(), TensorInfo::GetQuantizationOffset(), and TensorInfo::GetQuantizationScale().

 {
     for (size_t i = 0; i < info.GetNumElements(); i++)
     {
         quant[i] = armnn::Quantize<uint8_t>(dequant[i], info.GetQuantizationScale(), info.GetQuantizationOffset());
     }
 }

◆ Quantize() [2/2]

template int32_t Quantize< int32_t >	(	float	value,
		float	scale,
		int32_t	offset
	)

Quantize a floating point data type into an 8-bit data type.

Explicit specialization of Quantize for int32_t.

Explicit specialization of Quantize for int16_t.

Explicit specialization of Quantize for uint8_t.

Explicit specialization of Quantize for int8_t.

Parameters

value	- The value to quantize.
scale	- The scale (must be non-zero).
offset	- The offset.

Returns: - The quantized value calculated as round(value/scale)+offset.

Definition at line 31 of file TypesUtils.cpp.

References ARMNN_ASSERT.

Referenced by BOOST_AUTO_TEST_CASE().

 {
     static_assert(IsQuantizedType<QuantizedType>(), "Not an integer type.");
     constexpr QuantizedType max = std::numeric_limits<QuantizedType>::max();
     constexpr QuantizedType min = std::numeric_limits<QuantizedType>::lowest();
     ARMNN_ASSERT(scale != 0.f);
     ARMNN_ASSERT(!std::isnan(value));
 
     float clampedValue = std::min(std::max(static_cast<float>(round(value/scale) + offset), static_cast<float>(min)),
                                   static_cast<float>(max));
     auto quantizedBits = static_cast<QuantizedType>(clampedValue);
 
     return quantizedBits;
 }

◆ QuantizeConstant()

void armnn::QuantizeConstant	(	const srcType *	src,
		uint8_t *	dst,
		size_t	numElements,
		float &	scale,
		int &	offset
	)

Definition at line 22 of file NetworkQuantizerUtils.hpp.

References ARMNN_ASSERT, QAsymmU8QuantizationScheme::ComputeScheme(), and CreateQuantizedConst().

Referenced by CreateQuantizedConst().

 {
     ARMNN_ASSERT(src);
     ARMNN_ASSERT(dst);
 
     float min = std::numeric_limits<srcType>::max();
     float max = std::numeric_limits<srcType>::lowest();
     for (size_t i = 0; i < numElements; ++i)
     {
         min = std::min(min, src[i]);
         max = std::max(max, src[i]);
     }
 
     QAsymmU8QuantizationScheme quantizationScheme;
     OffsetScalePair qParams = quantizationScheme.ComputeScheme(min, max);
     scale = qParams.first;
     offset = qParams.second;
 
     for (size_t i = 0; i < numElements; ++i)
     {
         dst[i] = armnn::Quantize<uint8_t>(src[i], scale, offset);
     }
 }

◆ ReducedOutputOffset()

unsigned int armnn::ReducedOutputOffset	(	const unsigned int	numDims,
		const armnn::TensorShape &	dims,
		std::vector< unsigned int > &	index,
		const unsigned int	numAxis,
		const std::vector< unsigned int > &	axis
	)

Definition at line 39 of file Mean.cpp.

Referenced by Mean().

 {
     unsigned int offset = 0;
     for (unsigned int idx = 0; idx < numDims; ++idx)
     {
         bool isAxis = false;
         if (!axis.empty())
         {
             for (unsigned int axisIdx = 0; axisIdx < numAxis; ++axisIdx)
             {
                 if (idx == axis[axisIdx])
                 {
                     isAxis = true;
                     break;
                 }
             }
         }
         if (!isAxis)
         {
             offset = offset * dims[idx] + index[idx];
         }
     }
     return offset;
 }

◆ RefBackendId()

constexpr const char* armnn::RefBackendId ( )

Definition at line 10 of file RefBackendId.hpp.

Referenced by RefBackend::GetIdStatic().

10 { return "CpuRef"; }

◆ RefTensorHandleFactoryId()

constexpr const char* armnn::RefTensorHandleFactoryId ( )

Definition at line 15 of file RefTensorHandleFactory.hpp.

Referenced by RefTensorHandleFactory::GetIdStatic().

15 { return "Arm/Ref/TensorHandleFactory"; }

◆ ReorderWeightChannelsForAcl()

ConstTensor armnn::ReorderWeightChannelsForAcl	(	const ConstTensor &	weightHandle,
		DataLayout	dataLayout,
		void *	permuteBuffer
	)

Definition at line 64 of file WorkloadUtils.cpp.

References BaseTensor< MemoryType >::GetInfo(), TensorInfo::GetNumBytes(), BaseTensor< MemoryType >::GetShape(), NCHW, and NHWC.

 {
     DataType* weight = static_cast<DataType*>(permuteBuffer);
     const TensorShape& weightShape = weightHandle.GetShape();
     unsigned int multiplier;
     unsigned int height;
     unsigned int width;
     unsigned int inputChannels;
     switch (dataLayout)
     {
         case DataLayout::NHWC:    //It actually is [ H, W, I, M ]
             height        = weightShape[0];
             width         = weightShape[1];
             inputChannels = weightShape[2];
             multiplier    = weightShape[3];
             break;
         case DataLayout::NCHW:    //It actually is [ M, I, H, W ]
         default:
             height        = weightShape[2];
             width         = weightShape[3];
             inputChannels = weightShape[1];
             multiplier    = weightShape[0];
             break;
     }
 
     std::vector<DataType> weightAclOrder(height*width*inputChannels*multiplier);
     unsigned int destinationWeightsChannel;
     unsigned int totalChannels = inputChannels * multiplier;
     unsigned int channelSize   = height * width;
     unsigned int inputChannel  = 0;
 
     for (unsigned int originWeightsChannel = 0; originWeightsChannel < totalChannels; originWeightsChannel++)
     {
         inputChannel = originWeightsChannel % inputChannels;
         destinationWeightsChannel = (originWeightsChannel - inputChannel) / inputChannels + multiplier * inputChannel;
 
         for (unsigned int i = 0; i < channelSize; i++)
         {
             weightAclOrder[i + destinationWeightsChannel * channelSize] =
                     weight[i + originWeightsChannel * channelSize];
         }
     }
 
     ::memcpy(permuteBuffer, weightAclOrder.data(), weightHandle.GetInfo().GetNumBytes());
     return ConstTensor(weightHandle.GetInfo(), permuteBuffer);
 }

◆ ReportError()

void armnn::ReportError	(	const std::string &	errorMessage,
		Optional< std::vector< std::string > &>	errorMessages
	)

Definition at line 76 of file Network.cpp.

References ARMNN_LOG, and warning.

Referenced by AssignBackends(), CheckScaleSetOnQuantizedType(), Optimize(), and ReturnWithError().

 {
     std::stringstream fullErrorMessage;
     fullErrorMessage << "ERROR: " << errorMessage;
     ARMNN_LOG(warning) << fullErrorMessage.str();
     if (errorMessages)
     {
         errorMessages.value().push_back(fullErrorMessage.str());
     }
 }

◆ ReportWarning()

void armnn::ReportWarning	(	const std::string &	warningMessage,
		Optional< std::vector< std::string > &>	warningMessages
	)

Definition at line 88 of file Network.cpp.

References ARMNN_LOG, and warning.

Referenced by ApplyBackendOptimizations(), and AttemptBackendAssignment().

 {
     std::stringstream fullWarningMessage;
     fullWarningMessage << "WARNING: " << warningMessage;
     ARMNN_LOG(warning) << fullWarningMessage.str();
     if (warningMessages)
     {
         warningMessages.value().push_back(fullWarningMessage.str());
     }
 }

◆ RequiresCopy()

bool armnn::RequiresCopy	(	ITensorHandleFactory::FactoryId	src,
		ITensorHandleFactory::FactoryId	dst,
		TensorHandleFactoryRegistry &	registry
	)

Definition at line 639 of file Network.cpp.

References ITensorHandleFactory::GetExportFlags(), TensorHandleFactoryRegistry::GetFactory(), and ITensorHandleFactory::GetImportFlags().

Referenced by CalculateSlotOption().

 {
     if (src != dst)
     {
         ITensorHandleFactory* srcFactory = registry.GetFactory(src);
         ITensorHandleFactory* dstFactory = registry.GetFactory(dst);
 
         if (srcFactory && dstFactory &&
             (srcFactory->GetExportFlags() & dstFactory->GetImportFlags()) != 0)
         {
             return false;
         }
         return true;
     }
     return false;
 }

◆ ReshapeWeightsForAcl()

void ReshapeWeightsForAcl	(	TensorInfo &	weightInfo,
		DataLayout	dataLayout
	)

Definition at line 38 of file WorkloadUtils.cpp.

References TensorInfo::GetShape(), NCHW, NHWC, and TensorInfo::SetShape().

Referenced by ConvertWeightTensorFromArmnnToAcl(), ConvertWeightTensorInfoFromArmnnToAcl(), and GatherTensorHandlePairs().

 {
     // Reshape the weights in-place
     const TensorShape& weightShape = weightInfo.GetShape();
     switch (dataLayout)
     {
         case DataLayout::NHWC:
             // The data layout is NHWC, reshape from [ H, W, I, M ] to [ 1, H, W, I * M ]
             weightInfo.SetShape({ 1,
                                   weightShape[0],
                                   weightShape[1],
                                   weightShape[2] * weightShape[3] });
             weightInfo.SetShape({ 1,
                                   weightShape[0] * weightShape[1],
                                   weightShape[2],
                                   weightShape[3] });
             break;
         case DataLayout::NCHW:
         default:
             // The data layout is NCHW, reshape from [ M, I, H, W ] to [ 1, I * M, H, W, ]
             weightInfo.SetShape({ 1, weightShape[0] * weightShape[1], weightShape[2], weightShape[3] });
             break;
     }
 }

◆ Resize()

void Resize	(	Decoder< float > &	in,
		const TensorInfo &	inputInfo,
		Encoder< float > &	out,
		const TensorInfo &	outputInfo,
		DataLayoutIndexed	dataLayout,
		armnn::ResizeMethod	resizeMethod,
		bool	alignCorners,
		bool	halfPixelCenters
	)

Definition at line 65 of file Resize.cpp.

References ARMNN_ASSERT, Bilinear, Decoder< IType >::Get(), DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), DataLayoutIndexed::GetIndex(), TensorInfo::GetShape(), DataLayoutIndexed::GetWidthIndex(), NearestNeighbor, Resize(), and Encoder< IType >::Set().

Referenced by BOOST_AUTO_TEST_CASE(), InferenceTestImage::GetSizeInBytes(), Resize(), and ResizeLayer::ResizeLayer().

 {
     // alignCorners and halfPixelCenters cannot both be true
     ARMNN_ASSERT(!(alignCorners && halfPixelCenters));
 
     // We follow the definition of TensorFlow and AndroidNN: the top-left corner of a texel in the output
     // image is projected into the input image to figure out the interpolants and weights. Note that this
     // will yield different results than if projecting the centre of output texels.
 
     const unsigned int batchSize = inputInfo.GetShape()[0];
     const unsigned int channelCount = inputInfo.GetShape()[dataLayout.GetChannelsIndex()];
 
     const unsigned int inputHeight = inputInfo.GetShape()[dataLayout.GetHeightIndex()];
     const unsigned int inputWidth = inputInfo.GetShape()[dataLayout.GetWidthIndex()];
     const unsigned int outputHeight = outputInfo.GetShape()[dataLayout.GetHeightIndex()];
     const unsigned int outputWidth = outputInfo.GetShape()[dataLayout.GetWidthIndex()];
 
     // How much to scale pixel coordinates in the output image, to get the corresponding pixel coordinates
     // in the input image.
     const float scaleY = CalculateResizeScale(inputHeight, outputHeight, alignCorners);
     const float scaleX = CalculateResizeScale(inputWidth, outputWidth, alignCorners);
 
     TensorShape inputShape =  inputInfo.GetShape();
     TensorShape outputShape =  outputInfo.GetShape();
 
     for (unsigned int n = 0; n < batchSize; ++n)
     {
         for (unsigned int c = 0; c < channelCount; ++c)
         {
             for (unsigned int y = 0; y < outputHeight; ++y)
             {
                 // Corresponding real-valued height coordinate in input image.
                 float iy = PixelScaler(y, scaleY, halfPixelCenters, resizeMethod);
 
                 // Discrete height coordinate of top-left texel (in the 2x2 texel area used for interpolation).
                 const float fiy = (resizeMethod == armnn::ResizeMethod::NearestNeighbor && alignCorners) ?
                                   roundf(iy) : floorf(iy);
                 // Pixel scaling a value with Half Pixel Centers can be negative, if so set to 0
                 const unsigned int y0 = static_cast<unsigned int>(std::max(fiy, 0.0f));
 
                 // Interpolation weight (range [0,1]).
                 const float yw = iy - fiy;
 
                 for (unsigned int x = 0; x < outputWidth; ++x)
                 {
                     // Real-valued and discrete width coordinates in input image.
                     float ix = PixelScaler(x, scaleX, halfPixelCenters, resizeMethod);
 
                     // Nearest Neighbour uses rounding to align to corners
                     const float fix = resizeMethod == armnn::ResizeMethod::NearestNeighbor && alignCorners ?
                                       roundf(ix) : floorf(ix);
                     // Pixel scaling a value with Half Pixel Centers can be negative, if so set to 0
                     const unsigned int x0 = static_cast<unsigned int>(std::max(fix, 0.0f));
 
                     // Interpolation weight (range [0,1]).
                     const float xw = ix - fix;
 
                     unsigned int x1;
                     unsigned int y1;
                     // Half Pixel Centers uses the scaling to compute a weighted parameter for nearby pixels
                     if (halfPixelCenters)
                     {
                         x1 = std::min(static_cast<unsigned int>(std::ceil(ix)), inputWidth - 1u);
                         y1 = std::min(static_cast<unsigned int>(std::ceil(iy)), inputHeight - 1u);
                     }
                     // Discrete width/height coordinates of texels below and to the right of (x0, y0).
                     else
                     {
                         x1 = std::min(x0 + 1, inputWidth - 1u);
                         y1 = std::min(y0 + 1, inputHeight - 1u);
                     }
 
                     float interpolatedValue;
                     switch (resizeMethod)
                     {
                         case armnn::ResizeMethod::Bilinear:
                         {
                             in[dataLayout.GetIndex(inputShape, n, c, y0, x0)];
                             float input1 = in.Get();
                             in[dataLayout.GetIndex(inputShape, n, c, y0, x1)];
                             float input2 = in.Get();
                             in[dataLayout.GetIndex(inputShape, n, c, y1, x0)];
                             float input3 = in.Get();
                             in[dataLayout.GetIndex(inputShape, n, c, y1, x1)];
                             float input4 = in.Get();
 
                             const float ly0 = Lerp(input1, input2, xw); // lerp along row y0.
                             const float ly1 = Lerp(input3, input4, xw); // lerp along row y1.
                             interpolatedValue = Lerp(ly0, ly1, yw);
                             break;
                         }
                         case armnn::ResizeMethod::NearestNeighbor:
                         {
                             // calculate euclidean distance to the 4 neighbours
                             auto distance00 = EuclideanDistance(fix, fiy, x0, y0);
                             auto distance01 = EuclideanDistance(fix, fiy, x0, y1);
                             auto distance10 = EuclideanDistance(fix, fiy, x1, y0);
                             auto distance11 = EuclideanDistance(fix, fiy, x1, y1);
 
                             auto minimum = std::min( { distance00, distance01, distance10, distance11 } );
 
                             unsigned int xNearest = 0;
                             unsigned int yNearest = 0;
 
                             if (minimum == distance00)
                             {
                                xNearest = x0;
                                yNearest = y0;
                             }
                             else if (minimum == distance01)
                             {
                                 xNearest = x0;
                                 yNearest = y1;
                             }
                             else if (minimum == distance10)
                             {
                                 xNearest = x1;
                                 yNearest = y0;
                             }
                             else if (minimum == distance11)
                             {
                                 xNearest = x1;
                                 yNearest = y1;
                             }
                             else
                             {
                                 throw armnn::InvalidArgumentException("Resize Nearest Neighbor failure");
                             }
 
                             in[dataLayout.GetIndex(inputShape, n, c, yNearest, xNearest)];
                             interpolatedValue = in.Get();
                             break;
                         }
                         default:
                             throw armnn::InvalidArgumentException("Unknown resize method: " +
                                                                   std::to_string(static_cast<int>(resizeMethod)));
                     }
                     out[dataLayout.GetIndex(outputShape, n, c, y, x)];
                     out.Set(interpolatedValue);
                 }
             }
         }
     }
 }

◆ ReturnWithError()

OptimizationResult armnn::ReturnWithError	(	OptimizationResult	res,
		const Layer *	layer,
		const BackendSettings &	backendSettings,
		Optional< std::vector< std::string > &>	errMessages
	)

Definition at line 100 of file Network.cpp.

References GetLayerTypeAsCString(), Layer::GetType(), OptimizationResult::m_Error, BackendSettings::m_PreferredBackends, and ReportError().

Referenced by AssignBackends(), and AttemptBackendAssignment().

 {
     std::stringstream failureMsg;
     failureMsg << "Layer of type " << GetLayerTypeAsCString(layer->GetType())
                << " is not supported on any preferred backend " << backendSettings.m_PreferredBackends;
     ReportError(failureMsg.str(), errMessages);
 
     res.m_Error = true;
     return res;
 }

◆ RunClFunction()

void armnn::RunClFunction	(	arm_compute::IFunction &	function,
		const CheckLocation &	location
	)

inline

Definition at line 134 of file ClWorkloadUtils.hpp.

References Error, error, and WrapClError().

 {
     try
     {
         function.run();
     }
     catch (cl::Error& error)
     {
         throw WrapClError(error, location);
     }
 }

◆ RuntimeLoadedNetworksReserve()

void RuntimeLoadedNetworksReserve ( armnn::Runtime * runtime )

Definition at line 30 of file RuntimeTests.cpp.

References BOOST_AUTO_TEST_SUITE().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     runtime->m_LoadedNetworks.reserve(1);
 }

◆ SelectTensorHandleStrategy()

OptimizationResult SelectTensorHandleStrategy	(	Graph &	optGraph,
		BackendsMap &	backends,
		TensorHandleFactoryRegistry &	registry,
		bool	importEnabled,
		Optional< std::vector< std::string > &>	errMessages
	)

Definition at line 946 of file Network.cpp.

References ARMNN_ASSERT, CalculateEdgeStrategy(), CalculateSlotOption(), CalculateSlotOptionForInput(), CalculateSlotOptionForOutput(), Graph::ForEachLayer(), Layer::GetBackendId(), OutputSlot::GetConnections(), Layer::GetNumOutputSlots(), Layer::GetOutputSlot(), Layer::GetType(), Input, ITensorHandleFactory::LegacyFactoryId, OptimizationResult::m_Error, Output, OutputSlot::SetEdgeStrategy(), OutputSlot::SetTensorHandleFactory(), and Undefined.

Referenced by BOOST_AUTO_TEST_CASE(), and Optimize().

 {
     OptimizationResult result;
 
     optGraph.ForEachLayer([&backends, &registry, &result, &errMessages, importEnabled](Layer* layer)
     {
         ARMNN_ASSERT(layer);
 
         // Lets make sure the backend is in our list of supported backends. Something went wrong during backend
         // assignment if this check fails
         ARMNN_ASSERT(backends.find(layer->GetBackendId()) != backends.end());
 
         // Check each output separately
         for (unsigned int slotIdx = 0; slotIdx < layer->GetNumOutputSlots(); slotIdx++)
         {
             OutputSlot& outputSlot = layer->GetOutputSlot(slotIdx);
 
             ITensorHandleFactory::FactoryId slotOption = ITensorHandleFactory::LegacyFactoryId;
 
             // Calculate the factory to use which results in the fewest copies being made.
             switch(layer->GetType())
             {
                 case LayerType::Input:
                     slotOption = CalculateSlotOptionForInput(backends, outputSlot, registry);
                     break;
                 case LayerType::Output:
                     slotOption = CalculateSlotOptionForOutput(backends, outputSlot, registry);
                     break;
                 default:
                     slotOption = CalculateSlotOption(backends, outputSlot, registry);
                     break;
             }
             outputSlot.SetTensorHandleFactory(slotOption);
 
             // Now determine the "best" edge strategy for each connection given the slotOption.
             unsigned int connectionIdx = 0;
             for (auto&& connection : outputSlot.GetConnections())
             {
                 const Layer& connectedLayer = connection->GetOwningLayer();
 
                 EdgeStrategy strategy = CalculateEdgeStrategy(backends, slotOption, *layer, connectedLayer,
                                                               registry, importEnabled);
 
                 if (strategy == EdgeStrategy::Undefined)
                 {
                     result.m_Error = true;
                     if (errMessages)
                     {
                         errMessages.value().emplace_back("Could not find valid strategy required for compatibility"
                                                          " between backends.");
                     }
                     return;
                 }
 
                 outputSlot.SetEdgeStrategy(connectionIdx, strategy);
 
                 connectionIdx++;
             }
         }
     });
 
     return result;
 }

◆ SetAllLoggingSinks()

void SetAllLoggingSinks	(	bool	standardOut,
		bool	debugOut,
		bool	coloured
	)

Definition at line 142 of file Logging.cpp.

Referenced by SimpleLogger< Level >::AddSink(), BOOST_AUTO_TEST_CASE(), ConfigureLogging(), and main().

 {
     SetLoggingSinks<LogSeverity::Trace>(standardOut, debugOut, coloured);
     SetLoggingSinks<LogSeverity::Debug>(standardOut, debugOut, coloured);
     SetLoggingSinks<LogSeverity::Info>(standardOut, debugOut, coloured);
     SetLoggingSinks<LogSeverity::Warning>(standardOut, debugOut, coloured);
     SetLoggingSinks<LogSeverity::Error>(standardOut, debugOut, coloured);
     SetLoggingSinks<LogSeverity::Fatal>(standardOut, debugOut, coloured);
 }

◆ SetClSliceData()

auto armnn::SetClSliceData	(	const std::vector< unsigned int > &	m_begin,
		const std::vector< unsigned int > &	m_size
	)

inline

Definition at line 66 of file ClWorkloadUtils.hpp.

Referenced by ClSliceWorkload::ClSliceWorkload().

 {
     // This function must translate the size vector given to an end vector
     // expected by the ACL NESlice workload
     arm_compute::Coordinates starts;
     arm_compute::Coordinates ends;
 
     unsigned int num_dims = static_cast<unsigned int>(m_begin.size());
 
     // For strided slices, we have the relationship size = (end - begin) / stride
     // For slice, we assume stride to be a vector of all ones, yielding the formula
     // size = (end - begin) therefore we know end = size + begin
     for (unsigned int i = 0; i < num_dims; i++)
     {
         unsigned int revertedIndex = num_dims - i - 1;
 
         starts.set(i, static_cast<int>(m_begin[revertedIndex]));
         ends.set(i, static_cast<int>(m_begin[revertedIndex] + m_size[revertedIndex]));
     }
 
     return std::make_tuple(starts, ends);
 }

◆ SetClStridedSliceData()

auto armnn::SetClStridedSliceData	(	const std::vector< int > &	m_begin,
		const std::vector< int > &	m_end,
		const std::vector< int > &	m_stride
	)

inline

Definition at line 45 of file ClWorkloadUtils.hpp.

Referenced by ClStridedSliceWorkload::ClStridedSliceWorkload().

 {
     arm_compute::Coordinates starts;
     arm_compute::Coordinates ends;
     arm_compute::Coordinates strides;
 
     unsigned int num_dims = static_cast<unsigned int>(m_begin.size());
 
     for (unsigned int i = 0; i < num_dims; i++) {
         unsigned int revertedIndex = num_dims - i - 1;
 
         starts.set(i, static_cast<int>(m_begin[revertedIndex]));
         ends.set(i, static_cast<int>(m_end[revertedIndex]));
         strides.set(i, static_cast<int>(m_stride[revertedIndex]));
     }
 
     return std::make_tuple(starts, ends, strides);
 }

◆ SetLogFilter()

void SetLogFilter ( LogSeverity level )

Definition at line 24 of file Logging.cpp.

References ARMNN_ASSERT, ARMNN_FALLTHROUGH, Debug, SimpleLogger< Level >::Enable(), Error, Fatal, SimpleLogger< Level >::Get(), IgnoreUnused(), Info, Trace, and Warning.

Referenced by SimpleLogger< Level >::AddSink(), BOOST_AUTO_TEST_CASE(), ConfigureLogging(), and main().

 {
     SimpleLogger<LogSeverity::Trace>::Get().Enable(false);
     SimpleLogger<LogSeverity::Debug>::Get().Enable(false);
     SimpleLogger<LogSeverity::Info>::Get().Enable(false);
     SimpleLogger<LogSeverity::Warning>::Get().Enable(false);
     SimpleLogger<LogSeverity::Error>::Get().Enable(false);
     SimpleLogger<LogSeverity::Fatal>::Get().Enable(false);
     switch (level)
     {
         case LogSeverity::Trace:
             SimpleLogger<LogSeverity::Trace>::Get().Enable(true);
             ARMNN_FALLTHROUGH;
         case LogSeverity::Debug:
             SimpleLogger<LogSeverity::Debug>::Get().Enable(true);
             ARMNN_FALLTHROUGH;
         case LogSeverity::Info:
             SimpleLogger<LogSeverity::Info>::Get().Enable(true);
             ARMNN_FALLTHROUGH;
         case LogSeverity::Warning:
             SimpleLogger<LogSeverity::Warning>::Get().Enable(true);
             ARMNN_FALLTHROUGH;
         case LogSeverity::Error:
             SimpleLogger<LogSeverity::Error>::Get().Enable(true);
             ARMNN_FALLTHROUGH;
         case LogSeverity::Fatal:
             SimpleLogger<LogSeverity::Fatal>::Get().Enable(true);
             break;
         default:
             ARMNN_ASSERT(false);
     }
 }

◆ SetLoggingSinks()

void armnn::SetLoggingSinks	(	bool	standardOut,
		bool	debugOut,
		bool	coloured
	)

inline

Definition at line 118 of file Logging.cpp.

References SimpleLogger< Level >::AddSink(), SimpleLogger< Level >::Get(), and SimpleLogger< Level >::RemoveAllSinks().

 {
     SimpleLogger<Level>::Get().RemoveAllSinks();
 
     if (standardOut)
     {
         if (coloured)
         {
             SimpleLogger<Level>::Get().AddSink(
                 std::make_shared<StandardOutputColourSink>(Level));
         } else
         {
             SimpleLogger<Level>::Get().AddSink(
                 std::make_shared<StandardOutputSink>());
         }
     }
 
     if (debugOut)
     {
         SimpleLogger<Level>::Get().AddSink(
             std::make_shared<DebugOutputSink>());
     }
 }

◆ SetNeonSliceData()

auto armnn::SetNeonSliceData	(	const std::vector< unsigned int > &	m_begin,
		const std::vector< unsigned int > &	m_size
	)

inline

Definition at line 92 of file NeonWorkloadUtils.hpp.

Referenced by NeonSliceWorkload::NeonSliceWorkload().

 {
     // This function must translate the size vector given to an end vector
     // expected by the ACL NESlice workload
     arm_compute::Coordinates starts;
     arm_compute::Coordinates ends;
 
     unsigned int num_dims = static_cast<unsigned int>(m_begin.size());
 
     // For strided slices, we have the relationship size = (end - begin) / stride
     // For slice, we assume stride to be a vector of all ones, yielding the formula
     // size = (end - begin) therefore we know end = size + begin
     for (unsigned int i = 0; i < num_dims; i++)
     {
         unsigned int revertedIndex = num_dims - i - 1;
 
         starts.set(i, static_cast<int>(m_begin[revertedIndex]));
         ends.set(i, static_cast<int>(m_begin[revertedIndex] + m_size[revertedIndex]));
     }
 
     return std::make_tuple(starts, ends);
 }

◆ SetNeonStridedSliceData()

auto armnn::SetNeonStridedSliceData	(	const std::vector< int > &	m_begin,
		const std::vector< int > &	m_end,
		const std::vector< int > &	m_stride
	)

inline

Definition at line 70 of file NeonWorkloadUtils.hpp.

Referenced by NeonStridedSliceWorkload::NeonStridedSliceWorkload().

 {
     arm_compute::Coordinates starts;
     arm_compute::Coordinates ends;
     arm_compute::Coordinates strides;
 
     unsigned int num_dims = static_cast<unsigned int>(m_begin.size());
 
     for (unsigned int i = 0; i < num_dims; i++)
     {
         unsigned int revertedIndex = num_dims - i - 1;
 
         starts.set(i, static_cast<int>(m_begin[revertedIndex]));
         ends.set(i, static_cast<int>(m_end[revertedIndex]));
         strides.set(i, static_cast<int>(m_stride[revertedIndex]));
     }
 
     return std::make_tuple(starts, ends, strides);
 }

◆ SetupQuantize()

std::vector<uint8_t> armnn::SetupQuantize ( float value )

Definition at line 2908 of file QuantizerTest.cpp.

References Float32, and TensorInfo::SetQuantizationScale().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     armnn::TensorInfo inputInfo({ 1, 2, 2 }, armnn::DataType::Float32);
     inputInfo.SetQuantizationScale(1.0f);
     inputInfo.SetQuantizationOffset(1);
     std::vector<float> input({ value, 0.0f, 0.0f, 1.0f });
     const std::vector<float> &inputRef = input;
 
     auto output = armnnUtils::QuantizedVector<uint8_t>(inputRef,
                                                        inputInfo.GetQuantizationScale(),
                                                        inputInfo.GetQuantizationOffset());
 
     return output;
 }

◆ SetValueChecked()

void armnn::SetValueChecked	(	Optional< T &>	optionalRef,
		V &&	val
	)

Definition at line 17 of file LayerSupportCommon.hpp.

References OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

Referenced by FalseFuncF16(), FalseFuncF32(), FalseFuncI32(), FalseFuncU8(), FalseInputFuncF16(), FalseInputFuncF32(), FalseOutputFuncF16(), FalseOutputFuncF32(), NeonLayerSupport::IsConcatSupported(), ClLayerSupport::IsConcatSupported(), ClLayerSupport::IsSplitterSupported(), and NeonLayerSupport::IsSplitterSupported().

 {
     if (optionalRef)
     {
         optionalRef.value() = val;
     }
 }

◆ Slice()

void Slice	(	const TensorInfo &	inputInfo,
		const SliceDescriptor &	descriptor,
		const void *	inputData,
		void *	outputData,
		unsigned int	dataTypeSize
	)

Definition at line 16 of file Slice.cpp.

References ARMNN_ASSERT, TensorShape::GetNumDimensions(), TensorInfo::GetShape(), IgnoreUnused(), SliceDescriptor::m_Begin, and SliceDescriptor::m_Size.

Referenced by BOOST_AUTO_TEST_CASE().

 {
     const TensorShape& inputShape = inputInfo.GetShape();
     const unsigned int numDims    = inputShape.GetNumDimensions();
 
     ARMNN_ASSERT(descriptor.m_Begin.size() == numDims);
     ARMNN_ASSERT(descriptor.m_Size.size()  == numDims);
 
     constexpr unsigned int maxNumDims = 4;
     ARMNN_ASSERT(numDims <= maxNumDims);
 
     std::vector<unsigned int> paddedInput(4);
     std::vector<unsigned int> paddedBegin(4);
     std::vector<unsigned int> paddedSize (4);
 
     const unsigned int numPaddingDims = maxNumDims - numDims;
     for (unsigned int i = 0u; i < maxNumDims; ++i)
     {
         if (i < numPaddingDims)
         {
             paddedInput[i] = 1u;
             paddedBegin[i] = 0u;
             paddedSize[i]  = 1u;
         }
         else
         {
             const unsigned int j = i - numPaddingDims;
             paddedInput[i] = inputShape[j];
             paddedBegin[i] = descriptor.m_Begin[j];
             paddedSize[i]  = descriptor.m_Size[j];
         }
     }
 
     unsigned int dim0 = paddedInput[0];
     unsigned int dim1 = paddedInput[1];
     unsigned int dim2 = paddedInput[2];
     unsigned int dim3 = paddedInput[3];
 
     unsigned int begin0 = paddedBegin[0];
     unsigned int begin1 = paddedBegin[1];
     unsigned int begin2 = paddedBegin[2];
     unsigned int begin3 = paddedBegin[3];
 
     unsigned int size0  = paddedSize[0];
     unsigned int size1  = paddedSize[1];
     unsigned int size2  = paddedSize[2];
     unsigned int size3  = paddedSize[3];
 
     ARMNN_ASSERT(begin0 + size0 <= dim0);
     ARMNN_ASSERT(begin1 + size1 <= dim1);
     ARMNN_ASSERT(begin2 + size2 <= dim2);
     ARMNN_ASSERT(begin3 + size3 <= dim3);
 
     const unsigned char* input = reinterpret_cast<const unsigned char*>(inputData);
     unsigned char* output      = reinterpret_cast<unsigned char*>(outputData);
 
     IgnoreUnused(dim0);
     for (unsigned int idx0 = begin0; idx0 < begin0 + size0; ++idx0)
     {
         for (unsigned int idx1 = begin1; idx1 < begin1 + size1; ++idx1)
         {
             for (unsigned int idx2 = begin2; idx2 < begin2 + size2; ++idx2)
             {
                 for (unsigned int idx3 = begin3; idx3 < begin3 + size3; ++idx3)
                 {
                     const unsigned int inputOffset =
                         (((idx0 * dim1 + idx1) * dim2 + idx2) * dim3 + idx3) * dataTypeSize;
 
                     ::memcpy(output, input + inputOffset, dataTypeSize);
                     output += dataTypeSize;
                 }
             }
         }
     }
 }

◆ Softmax()

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.

Definition at line 17 of file Softmax.cpp.

References ARMNN_ASSERT_MSG, Decoder< IType >::Get(), TensorShape::GetNumDimensions(), TensorInfo::GetNumDimensions(), armnnUtils::GetNumElementsBetween(), TensorInfo::GetShape(), and Encoder< IType >::Set().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     ARMNN_ASSERT_MSG(axis < static_cast<int>(inputTensorInfo.GetNumDimensions()),
                      "Required axis index greater than number of dimensions.");
     ARMNN_ASSERT_MSG(axis >= -static_cast<int>(inputTensorInfo.GetNumDimensions()),
                      "Required axis index lower than negative of the number of dimensions");
 
     unsigned int uAxis = axis < 0  ?
                          inputTensorInfo.GetNumDimensions() - static_cast<unsigned int>(abs(axis))
                          : static_cast<unsigned int>(axis);
 
     const TensorShape& inputShape = inputTensorInfo.GetShape();
     const unsigned int outerSize  = armnnUtils::GetNumElementsBetween(inputShape, 0, uAxis);
     const unsigned int axisSize   = inputShape[uAxis];
     const unsigned int innerSize  = armnnUtils::GetNumElementsBetween(inputShape,
                                                                       uAxis + 1,
                                                                       inputShape.GetNumDimensions());
 
     for (unsigned int outer = 0; outer < outerSize; ++outer)
     {
         unsigned int inputBeginIdx  = outer * axisSize * innerSize;
         unsigned int inputEndIdx    = inputBeginIdx + axisSize * innerSize;
         unsigned int outputBeginIdx = outer * axisSize * innerSize;
 
         for (unsigned int inner = 0; inner < innerSize; ++inner, ++inputBeginIdx, ++inputEndIdx, ++outputBeginIdx)
         {
             // Find max
             float maxValue = std::numeric_limits<float>::lowest();
             for (unsigned int iter = inputBeginIdx; iter < inputEndIdx; iter += innerSize)
             {
                 in[iter];
                 maxValue = std::max(maxValue, in.Get());
             }
 
             // Compute sum
             float sum = 0.0f;
             for (unsigned int iter = inputBeginIdx; iter < inputEndIdx; iter += innerSize)
             {
                 in[iter];
                 sum += std::exp((in.Get() - maxValue) * beta);
             }
 
             // Compute result
             unsigned int outputIter = outputBeginIdx;
             out[outputIter];
             for (unsigned int iter = inputBeginIdx; iter < inputEndIdx; iter += innerSize, outputIter += innerSize)
             {
                 out[outputIter];
                 in[iter];
                 out.Set(std::exp((in.Get() - maxValue) * beta) / sum);
             }
         }
     }
 }

◆ SpaceToBatchNd()

void SpaceToBatchNd	(	const TensorInfo &	inputInfo,
		const TensorInfo &	outputInfo,
		const SpaceToBatchNdDescriptor &	params,
		Decoder< float > &	inputData,
		Encoder< float > &	outputData
	)

Definition at line 34 of file SpaceToBatchNd.cpp.

References Decoder< IType >::Get(), DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), GetOffset(), TensorInfo::GetShape(), DataLayoutIndexed::GetWidthIndex(), SpaceToBatchNdDescriptor::m_BlockShape, SpaceToBatchNdDescriptor::m_DataLayout, SpaceToBatchNdDescriptor::m_PadList, Encoder< IType >::Set(), and SpaceToBatchNd().

Referenced by BOOST_AUTO_TEST_CASE(), SpaceToBatchNd(), and SpaceToBatchNdLayer::SpaceToBatchNdLayer().

 {
     DataLayoutIndexed dataLayout = params.m_DataLayout;
 
     const TensorShape& inputShape = inputInfo.GetShape();
     const TensorShape& outputShape = outputInfo.GetShape();
 
     const unsigned int channels = inputShape[dataLayout.GetChannelsIndex()];
 
     const unsigned int inputBatchSize = inputShape[0];
     const unsigned int inputHeight = inputShape[dataLayout.GetHeightIndex()];
     const unsigned int inputWidth = inputShape[dataLayout.GetWidthIndex()];
 
     const unsigned int outputBatchSize = outputShape[0];
     const unsigned int outputHeight = outputShape[dataLayout.GetHeightIndex()];
     const unsigned int outputWidth = outputShape[dataLayout.GetWidthIndex()];
 
     const unsigned int blockHeight = params.m_BlockShape[0];
     const unsigned int blockWidth = params.m_BlockShape[1];
 
     const unsigned int paddingTop = params.m_PadList[0].first;
     const unsigned int paddingLeft = params.m_PadList[1].first;
 
     for (unsigned int outB = 0; outB < outputBatchSize; outB++)
     {
         unsigned int inB = outB % inputBatchSize;
 
         unsigned int shiftW = (outB / inputBatchSize) % blockWidth;
         unsigned int shiftH = (outB / inputBatchSize) / blockWidth;
 
         for (unsigned int outH = 0; outH < outputHeight; outH++)
         {
             for (unsigned int outW = 0; outW < outputWidth; outW++)
             {
                 if (outH * blockHeight + shiftH < paddingTop ||
                     outH * blockHeight + shiftH >= paddingTop + inputHeight ||
                     outW * blockWidth + shiftW < paddingLeft ||
                     outW * blockWidth + shiftW >= paddingLeft + inputWidth)
                 {
                     for (unsigned int c = 0; c < channels; c++)
                     {
                         unsigned int outOffset = GetOffset(outputShape,
                                                            outB,
                                                            outH,
                                                            outW,
                                                            c,
                                                            dataLayout);
                         outputData += outOffset;
                         outputData.Set(0);
                         outputData -= outOffset;
                     }
                 }
                 else
                 {
                     for (unsigned int c = 0; c < channels; c++)
                     {
                         unsigned int inOffset = GetOffset(inputShape,
                                                           inB,
                                                           (outH * blockHeight + shiftH) - paddingTop,
                                                           (outW * blockWidth + shiftW) - paddingLeft,
                                                           c,
                                                           dataLayout);
 
                         unsigned int outOffset = GetOffset(outputShape,
                                                            outB,
                                                            outH,
                                                            outW,
                                                            c,
                                                            dataLayout);
 
                         outputData += outOffset;
                         inputData += inOffset;
                         outputData.Set(inputData.Get());
                         inputData -= inOffset;
                         outputData -= outOffset;
                     }
                 }
             }
         }
     }
 }

◆ SpaceToDepth()

void SpaceToDepth	(	const TensorInfo &	inputInfo,
		const TensorInfo &	outputInfo,
		const SpaceToDepthDescriptor &	params,
		Decoder< float > &	inputData,
		Encoder< float > &	outputData
	)

Definition at line 36 of file SpaceToDepth.cpp.

References Decoder< IType >::Get(), DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), GetOffset(), TensorInfo::GetShape(), DataLayoutIndexed::GetWidthIndex(), SpaceToDepthDescriptor::m_BlockSize, SpaceToDepthDescriptor::m_DataLayout, Encoder< IType >::Set(), and SpaceToDepth().

Referenced by BOOST_AUTO_TEST_CASE(), SpaceToDepth(), and SpaceToDepthLayer::SpaceToDepthLayer().

 {
     DataLayoutIndexed dataLayout = params.m_DataLayout;
 
     const TensorShape& inputShape = inputInfo.GetShape();
     const TensorShape& outputShape = outputInfo.GetShape();
 
     const unsigned int inputBatchSize = inputShape[0];
     const unsigned int inputChannels = inputShape[dataLayout.GetChannelsIndex()];
 
     const unsigned int outputHeight = outputShape[dataLayout.GetHeightIndex()];
     const unsigned int outputWidth = outputShape[dataLayout.GetWidthIndex()];
     const unsigned int outputChannels = outputShape[dataLayout.GetChannelsIndex()];
 
     const unsigned int blockSize = params.m_BlockSize;
 
     if (blockSize == 0)
     {
         throw InvalidArgumentException(
             "Input shape must be divisible by block size in all spatial dimensions: Block size is"
             " equal to zero");
     }
 
     for (unsigned int outChannelIndex = 0; outChannelIndex < outputChannels; outChannelIndex++)
     {
         unsigned int inChannelIndex = outChannelIndex % inputChannels;
 
         unsigned int shiftW = (outChannelIndex / inputChannels) % blockSize;
         unsigned int shiftH = (outChannelIndex / inputChannels) / blockSize;
 
         for (unsigned int outH = 0; outH < outputHeight; outH++)
         {
             for (unsigned int outW = 0; outW < outputWidth; outW++)
             {
                 for (unsigned int inBatchIndex = 0; inBatchIndex < inputBatchSize; inBatchIndex++)
                 {
                     unsigned int inOffset = GetOffset(inputShape,
                         inChannelIndex,
                         (outH * blockSize + shiftH),
                         (outW * blockSize + shiftW),
                         inBatchIndex,
                         dataLayout);
 
                     unsigned int outOffset = GetOffset(outputShape,
                         outChannelIndex,
                         outH,
                         outW,
                         inBatchIndex,
                         dataLayout);
 
                     outputData += outOffset;
                     inputData += inOffset;
                     outputData.Set(inputData.Get());
                     inputData -= inOffset;
                     outputData -= outOffset;
                 }
             }
         }
     }
 }

◆ Split()

void Split ( const SplitterQueueDescriptor & data )

Definition at line 21 of file Splitter.cpp.

References ARMNN_ASSERT, Encoder< IType >::Get(), TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), GetTensorInfo(), QueueDescriptor::m_Inputs, SplitterQueueDescriptor::ViewOrigin::m_Origin, QueueDescriptor::m_Outputs, SplitterQueueDescriptor::m_ViewOrigins, and MaxNumOfTensorDimensions.

Referenced by RefSplitterWorkload::Execute(), and Splitter().

 {
     const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[0]);
 
     std::unique_ptr<Decoder<float>> decoderPtr =
         MakeDecoder<float>(inputInfo, data.m_Inputs[0]->Map());
     Decoder<float>& decoder = *decoderPtr;
 
     for (unsigned int index = 0; index < inputInfo.GetNumElements(); ++index)
     {
         unsigned int indices[MaxNumOfTensorDimensions] = { 0 };
 
         unsigned int indexRemainder = index;
         unsigned int dimensionStride = inputInfo.GetNumElements();
 
         for (unsigned int i = 0; i<inputInfo.GetNumDimensions(); i++)
         {
             dimensionStride /= inputInfo.GetShape()[i];
             indices[i] = indexRemainder / dimensionStride; // Use integer division to round down.
             indexRemainder -= indices[i] * dimensionStride;
         }
 
         for (unsigned int viewIdx = 0; viewIdx < data.m_ViewOrigins.size(); ++viewIdx)
         {
             SplitterQueueDescriptor::ViewOrigin const& view = data.m_ViewOrigins[viewIdx];
 
             //Split view extents are defined by the size of (the corresponding) input tensor.
             const TensorInfo& outputInfo = GetTensorInfo(data.m_Outputs[viewIdx]);
             ARMNN_ASSERT(outputInfo.GetNumDimensions() == inputInfo.GetNumDimensions());
 
             // Check all dimensions to see if this element is inside the given input view.
             bool insideView = true;
             for (unsigned int i = 0; i<outputInfo.GetNumDimensions(); i++)
             {
                 if (indices[i] < view.m_Origin[i])
                 {
                     insideView = false;
                 }
                 if (indices[i] >= view.m_Origin[i] + outputInfo.GetShape()[i])
                 {
                     insideView = false;
                 }
             }
 
             if (insideView)
             {
                 std::unique_ptr<Encoder<float>> encoderPtr =
                     MakeEncoder<float>(outputInfo, data.m_Outputs[viewIdx]->Map());
                 Encoder<float>& encoder = *encoderPtr;
 
                 unsigned int outIndex = 0;
                 unsigned int dimensionStride = 1;
                 float inputValue = 0.f;
 
                 for (unsigned int i = outputInfo.GetNumDimensions(); i-- > 0;)
                 {
                     outIndex += dimensionStride * (indices[i] - view.m_Origin[i]);
                     dimensionStride *= outputInfo.GetShape()[i];
                 }
 
                 decoder += index;
                 inputValue = decoder.Get();
                 decoder -= index;
 
                 encoder += outIndex;
                 encoder.Set(inputValue);
                 break;
             }
         }
     }
 }

◆ Splitter()

void armnn::Splitter ( const SplitterQueueDescriptor & data )

Definition at line 17 of file Splitter.hpp.

References ARMNN_ASSERT, TensorInfo::GetNumDimensions(), TensorInfo::GetNumElements(), TensorInfo::GetShape(), GetTensorInfo(), QueueDescriptor::m_Inputs, SplitterQueueDescriptor::ViewOrigin::m_Origin, QueueDescriptor::m_Outputs, SplitterQueueDescriptor::m_ViewOrigins, MaxNumOfTensorDimensions, and Split().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     const TensorInfo& inputInfo0 = GetTensorInfo(data.m_Inputs[0]);
 
     for (unsigned int index = 0; index < inputInfo0.GetNumElements(); ++index)
     {
         unsigned int indices[MaxNumOfTensorDimensions] = { 0 };
 
         unsigned int indexRemainder = index;
         unsigned int dimensionStride = inputInfo0.GetNumElements();
 
         for (unsigned int i = 0; i<inputInfo0.GetNumDimensions(); i++)
         {
             dimensionStride /= inputInfo0.GetShape()[i];
             indices[i] = indexRemainder / dimensionStride; // Use integer division to round down.
             indexRemainder -= indices[i] * dimensionStride;
         }
 
         for (unsigned int viewIdx = 0; viewIdx < data.m_ViewOrigins.size(); ++viewIdx)
         {
             SplitterQueueDescriptor::ViewOrigin const& view = data.m_ViewOrigins[viewIdx];
 
             //Split view extents are defined by the size of (the corresponding) input tensor.
             const TensorInfo& outputInfo = GetTensorInfo(data.m_Outputs[viewIdx]);
             ARMNN_ASSERT(outputInfo.GetNumDimensions() == inputInfo0.GetNumDimensions());
 
             // Check all dimensions to see if this element is inside the given input view.
             bool insideView = true;
             for (unsigned int i = 0; i<outputInfo.GetNumDimensions(); i++)
             {
                 if (indices[i] < view.m_Origin[i])
                 {
                     insideView = false;
                 }
                 if (indices[i] >= view.m_Origin[i] + outputInfo.GetShape()[i])
                 {
                     insideView = false;
                 }
             }
 
             if (insideView)
             {
                 unsigned int outIndex = 0;
                 unsigned int dimensionStride = 1;
 
                 for (unsigned int i = outputInfo.GetNumDimensions(); i-- > 0;)
                 {
                     outIndex += dimensionStride * (indices[i] - view.m_Origin[i]);
                     dimensionStride *= outputInfo.GetShape()[i];
                 }
 
                 //We are within the view, to copy input data to the output corresponding to this view.
                 DataType* outputData = GetOutputTensorData<DataType>(viewIdx, data);
                 ARMNN_ASSERT(outputData);
 
                 const DataType* inputData = GetInputTensorData<DataType>(0, data);
                 ARMNN_ASSERT(inputData);
 
                 outputData[outIndex] = inputData[index];
             }
         }
     }
 }

◆ Stack()

void Stack	(	const StackQueueDescriptor &	data,
		std::vector< std::unique_ptr< Decoder< float >>> &	inputs,
		Encoder< float > &	output
	)

Definition at line 12 of file Stack.cpp.

References TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), GetTensorInfo(), StackDescriptor::m_Axis, QueueDescriptor::m_Inputs, QueueDescriptor::m_Outputs, QueueDescriptorWithParameters< LayerDescriptor >::m_Parameters, and Encoder< IType >::Set().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     const TensorInfo& outputInfo = GetTensorInfo(data.m_Outputs[0]);
     const TensorInfo& inputInfo = GetTensorInfo(data.m_Inputs[0]);
 
     unsigned int outputNumDims = outputInfo.GetNumDimensions();
     unsigned int inputNumDims = inputInfo.GetNumDimensions();
 
     const armnn::TensorShape& outputDims = outputInfo.GetShape();
     const armnn::TensorShape& inputDims = inputInfo.GetShape();
 
     unsigned int axis = data.m_Parameters.m_Axis;
 
     // Initialise output data
     unsigned int numOutputElements = 1;
     for (unsigned int i=0; i<outputNumDims; ++i)
     {
         numOutputElements *= outputDims[i];
     }
 
     const unsigned int iNumTensors = static_cast<unsigned int>(data.m_Inputs.size());
     const unsigned int iBatchSize  = inputDims[0];
     const unsigned int iChannels   = (inputNumDims > 1) ? inputDims[1] : 1;
     const unsigned int iHeight     = (inputNumDims > 2) ? inputDims[2] : 1;
     const unsigned int iWidth      = (inputNumDims > 3) ? inputDims[3] : 1;
 
     const unsigned int oBatchSize  = outputDims[1];
     const unsigned int oChannels   = (outputNumDims > 2) ? outputDims[2] : 1;
     const unsigned int oHeight     = (outputNumDims > 3) ? outputDims[3] : 1;
     const unsigned int oWidth      = (outputNumDims > 4) ? outputDims[4] : 1;
 
     // Array to store the input coordinates
     // iCoordinates[0] = i, iCoordinates[1] = bi, iCoordinates[2] = ci
     // iCoordinates[3] = hi, iCoordinates[4] = wi, iCoordinates[5] = 0
     // iCoordinates[5] will be always zero and used for not incrementing
     // the output when the input has less than 4 dimensions
     std::array<unsigned int, 6> iCoordinates{ 0 };
 
     // Array of pointers used to map the output coordinates to the input ones, in accordance with the axis
     // This array is initialized with &iCoordinates[5] since this will be always zero
     std::array<unsigned int *, 5> oCoordinates = { &iCoordinates[5],
                                                    &iCoordinates[5],
                                                    &iCoordinates[5],
                                                    &iCoordinates[5],
                                                    &iCoordinates[5] };
 
     // Set the axis coordinate
     oCoordinates[axis] = &iCoordinates[0];
 
     // Map the output coordinates, accounting for the axis
     unsigned int dim_shift = 0;
     for(unsigned int dim = 0; dim < inputNumDims; ++dim)
     {
         if(dim == axis)
         {
             dim_shift++;
         }
         oCoordinates[dim + dim_shift] = &iCoordinates[dim + 1];
     }
 
     // Alias for the input coordinates
     unsigned int &i  = iCoordinates[0];
     unsigned int &bi = iCoordinates[1];
     unsigned int &ci = iCoordinates[2];
     unsigned int &hi = iCoordinates[3];
     unsigned int &wi = iCoordinates[4];
 
     // Alias for the output coordinates
     unsigned int &o  = *(oCoordinates[0]);
     unsigned int &bo = *(oCoordinates[1]);
     unsigned int &co = *(oCoordinates[2]);
     unsigned int &ho = *(oCoordinates[3]);
     unsigned int &wo = *(oCoordinates[4]);
 
     // Stack tensors
     for(; i < iNumTensors; ++(i))
     {
         for(bi = 0; bi < iBatchSize; ++(bi))
         {
             for(ci = 0; ci < iChannels; ++(ci))
             {
                 for(hi = 0; hi < iHeight; ++(hi))
                 {
                     for(wi = 0; wi < iWidth; ++(wi))
                     {
                         output[o  * oWidth * oHeight * oChannels * oBatchSize +
                                bo * oWidth * oHeight * oChannels +
                                co * oWidth * oHeight +
                                ho * oWidth +
                                wo];
 
                         output.Set(inputs[i]->Get());
 
                         ++(*(inputs[i]));
                     }
                 }
             }
         }
     }
 }

◆ StrEqual()

constexpr bool armnn::StrEqual	(	const char *	strA,
		const char(&)	strB[N]
	)

Definition at line 136 of file TypesUtils.hpp.

Referenced by ParseComputeDevice().

 {
     bool isEqual = true;
     for (unsigned i = 0; isEqual && (i < N); ++i)
     {
         isEqual = (strA[i] == strB[i]);
     }
     return isEqual;
 }

◆ StridedSlice()

void StridedSlice	(	const TensorInfo &	inputInfo,
		const StridedSliceDescriptor &	params,
		const void *	inputData,
		void *	outputData,
		unsigned int	dataTypeSize
	)

Definition at line 91 of file StridedSlice.cpp.

References TensorInfo::GetShape(), and numeric_cast().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     const unsigned char* input = reinterpret_cast<const unsigned char*>(inputData);
     unsigned char* output = reinterpret_cast<unsigned char*>(outputData);
 
     const TensorShape inputShape = ExtendShape(inputInfo.GetShape(), 4);
 
     StridedSliceDescriptor paddedParams = params;
 
     // Pad parameters to 4 dimensions
     PadParams(paddedParams, 4);
 
     const int start0 = paddedParams.GetStartForAxis(inputShape, 0);
     const int stop0  = paddedParams.GetStopForAxis (inputShape, 0, start0);
 
     const int start1 = paddedParams.GetStartForAxis(inputShape, 1);
     const int stop1  = paddedParams.GetStopForAxis (inputShape, 1, start1);
 
     const int start2 = paddedParams.GetStartForAxis(inputShape, 2);
     const int stop2  = paddedParams.GetStopForAxis (inputShape, 2, start2);
 
     const int start3 = paddedParams.GetStartForAxis(inputShape, 3);
     const int stop3  = paddedParams.GetStopForAxis (inputShape, 3, start3);
 
     const int step = boost::numeric_cast<int>(dataTypeSize);
 
     for (int in0 = start0;
          !LoopCondition(in0, stop0, paddedParams.m_Stride[0]);
          in0 += paddedParams.m_Stride[0])
     {
         for (int in1 = start1;
              !LoopCondition(in1, stop1, paddedParams.m_Stride[1]);
              in1 += paddedParams.m_Stride[1])
         {
             for (int in2 = start2;
                  !LoopCondition(in2, stop2, paddedParams.m_Stride[2]);
                  in2 += paddedParams.m_Stride[2])
             {
                 for (int in3 = start3;
                      !LoopCondition(in3, stop3, paddedParams.m_Stride[3]);
                      in3 += paddedParams.m_Stride[3])
                 {
                     int dim1 = boost::numeric_cast<int>(inputShape[1]);
                     int dim2 = boost::numeric_cast<int>(inputShape[2]);
                     int dim3 = boost::numeric_cast<int>(inputShape[3]);
 
                     int inputOffset = (((in0 * dim1 + in1) * dim2 + in2) * dim3 + in3) * step;
                     ::memcpy(output, input + inputOffset, dataTypeSize);
                     output += step;
                 }
             }
         }
     }
 }

◆ swap() [1/2]

void armnn::swap	(	OriginsDescriptor &	first,
		OriginsDescriptor &	second
	)

Definition at line 344 of file Descriptors.cpp.

References ViewsDescriptor::swap, and swap().

Referenced by FullyConnectedFloat32Test(), FullyConnectedLargeTestCommon(), BackendId::operator=(), BufferManager::Reset(), SquashEqualSiblingsImpl< Comparable >::Run(), and BackendRegistry::Swap().

 {
     using std::swap;
     swap(first.m_NumViews, second.m_NumViews);
     swap(first.m_NumDimensions, second.m_NumDimensions);
     swap(first.m_ViewOrigins, second.m_ViewOrigins);
     swap(first.m_ConcatAxis, second.m_ConcatAxis);
 }

◆ swap() [2/2]

void armnn::swap	(	ViewsDescriptor &	first,
		ViewsDescriptor &	second
	)

Definition at line 353 of file Descriptors.cpp.

References ViewsDescriptor::swap.

Referenced by swap().

 {
     using std::swap;
     swap(first.m_Origins, second.m_Origins);
     swap(first.m_ViewSizes, second.m_ViewSizes);
 }

◆ TestQuantizeConvolution2d()

void armnn::TestQuantizeConvolution2d ( bool useBiases )

Definition at line 1227 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IgnoreUnused(), info, Convolution2dDescriptor::m_BiasEnabled, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     class TestConv2dQuantization : public TestQuantization
     {
     public:
         TestConv2dQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestConv2dQuantization(const QuantizerOptions& options,
                                const TensorShape& inputShape,
                                const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitConvolution2dLayer(const IConnectableLayer *layer,
                                      const Convolution2dDescriptor& convolution2dDescriptor,
                                      const ConstTensor& weights,
                                      const Optional<ConstTensor>& biases,
                                      const char *name = nullptr) override
         {
             IgnoreUnused(convolution2dDescriptor, name);
             TestQuantizationOnLayersWithBiases(layer, weights, biases);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     TensorShape shape{3U};
     TensorInfo info(shape, DataType::Float32);
 
     std::vector<float> weightsData{-1.0f, 1.5f, 2.0f};
     ConstTensor weights(info, weightsData);
 
     Convolution2dDescriptor descriptor;
     descriptor.m_BiasEnabled = useBiases;
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* conv2d;
     Optional<ConstTensor> optionalBiases;
     std::vector<float> biasesData{-1.0f, 1.5f, 2.0f};
     if (useBiases)
     {
         ConstTensor biases(info, biasesData);
         optionalBiases = Optional<ConstTensor>(biases);
     }
     conv2d = network->AddConvolution2dLayer(descriptor, weights, optionalBiases);
     IConnectableLayer* output = network->AddOutputLayer(1);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(conv2d->GetInputSlot(0));
     conv2d->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     // Set TensorInfo
     input0->GetOutputSlot(0).SetTensorInfo(info);
     conv2d->GetOutputSlot(0).SetTensorInfo(info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestConv2dQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestConv2dQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestConv2dQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions Qsymm16Options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), Qsymm16Options)->ExportNetwork();
     TestConv2dQuantization validatorQSymmS16(Qsymm16Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ TestQuantizeDepthwiseConvolution2d()

void armnn::TestQuantizeDepthwiseConvolution2d ( bool useBiases )

Definition at line 1313 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IgnoreUnused(), info, DepthwiseConvolution2dDescriptor::m_BiasEnabled, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     class TestDepthwiseConv2dQuantization : public TestQuantization
     {
     public:
         TestDepthwiseConv2dQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestDepthwiseConv2dQuantization(const QuantizerOptions& options,
                                         const TensorShape& inputShape,
                                         const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitDepthwiseConvolution2dLayer(const IConnectableLayer *layer,
                                               const DepthwiseConvolution2dDescriptor& convolution2dDescriptor,
                                               const ConstTensor& weights,
                                               const Optional<ConstTensor>& biases,
                                               const char *name = nullptr) override
         {
             IgnoreUnused(convolution2dDescriptor, name);
             TestQuantizationOnLayersWithBiases(layer, weights, biases);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     TensorShape shape{3U};
     TensorInfo info(shape, DataType::Float32);
 
     std::vector<float> weightsData{-1.0f, 1.5f, 2.0f};
     ConstTensor weights(info, weightsData);
 
     DepthwiseConvolution2dDescriptor descriptor;
     descriptor.m_BiasEnabled = useBiases;
 
     // Add the layers
     IConnectableLayer* input0 = network->AddInputLayer(0);
     IConnectableLayer* depthwiseConv2d;
     Optional<ConstTensor> optionalBiases;
     std::vector<float> biasesData{-1.0f, 1.5f, 2.0f};
     if (useBiases)
     {
         ConstTensor biases(info, biasesData);
         optionalBiases = Optional<ConstTensor>(biases);
     }
     depthwiseConv2d = network->AddDepthwiseConvolution2dLayer(descriptor, weights, optionalBiases);
     IConnectableLayer* output = network->AddOutputLayer(1);
 
     // Establish connections
     input0->GetOutputSlot(0).Connect(depthwiseConv2d->GetInputSlot(0));
     depthwiseConv2d->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     //Set TensorInfo
     input0->GetOutputSlot(0).SetTensorInfo(info);
     depthwiseConv2d->GetOutputSlot(0).SetTensorInfo(info);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestDepthwiseConv2dQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestDepthwiseConv2dQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestDepthwiseConv2dQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions Qsymm16Options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), Qsymm16Options)->ExportNetwork();
     TestDepthwiseConv2dQuantization validatorQSymmS16(Qsymm16Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ TestQuantizeTransposeConvolution2d()

void armnn::TestQuantizeTransposeConvolution2d ( bool useBiases )

Definition at line 2669 of file QuantizerTest.cpp.

References IOutputSlot::Connect(), INetworkQuantizer::Create(), INetwork::Create(), Float32, IConnectableLayer::GetInputSlot(), IConnectableLayer::GetOutputSlot(), IgnoreUnused(), info, TransposeConvolution2dDescriptor::m_BiasEnabled, QAsymmS8, QSymmS16, QSymmS8, IOutputSlot::SetTensorInfo(), and VisitLayersTopologically().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     class TestTransposeConvolution2dQuantization : public TestQuantization
     {
     public:
         TestTransposeConvolution2dQuantization(const TensorShape& inputShape, const TensorShape& outputShape) :
             TestQuantization(inputShape, outputShape)
         {}
 
         TestTransposeConvolution2dQuantization(const QuantizerOptions& options,
                                                const TensorShape& inputShape,
                                                const TensorShape& outputShape) :
             TestQuantization(options, inputShape, outputShape)
         {}
 
         void VisitTransposeConvolution2dLayer(const IConnectableLayer *layer,
                                               const TransposeConvolution2dDescriptor& descriptor,
                                               const ConstTensor& weights,
                                               const Optional<ConstTensor>& biases,
                                               const char *name = nullptr) override
         {
             IgnoreUnused(descriptor, name);
             TestQuantizationOnLayersWithBiases(layer, weights, biases);
         }
     };
 
     INetworkPtr network = INetwork::Create();
 
     TensorShape shape{ 3 };
     TensorInfo info(shape, DataType::Float32);
 
     std::initializer_list<float> floatData{ -1.0f, 1.5f, 2.0f };
     std::vector<float> weightsData(floatData);
     ConstTensor weights(info, weightsData);
 
     TransposeConvolution2dDescriptor descriptor;
     descriptor.m_BiasEnabled = useBiases;
 
     // construct network
     IConnectableLayer* input = network->AddInputLayer(0);
     Optional<ConstTensor> optionalBiases;
     std::vector<float> biasesData(floatData);
     if (useBiases)
     {
         ConstTensor biases(info, biasesData);
         optionalBiases = Optional<ConstTensor>(biases);
     }
     IConnectableLayer* transposeConv2d = network->AddTransposeConvolution2dLayer(descriptor, weights, optionalBiases);
     IConnectableLayer* output = network->AddOutputLayer(1);
 
     input->GetOutputSlot(0).Connect(transposeConv2d->GetInputSlot(0));
     transposeConv2d->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 
     input->GetOutputSlot(0).SetTensorInfo(info);
     transposeConv2d->GetOutputSlot(0).SetTensorInfo(info);
 
     // test QAsymmU8 quantization
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestTransposeConvolution2dQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     //test QAsymmS8 quantization
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestTransposeConvolution2dQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     // test QSymmS8 quantization
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestTransposeConvolution2dQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     // test QSymmS16 quantization
     const QuantizerOptions qSymmS16options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), qSymmS16options)->ExportNetwork();
     TestTransposeConvolution2dQuantization validatorQSymmS16(qSymmS16options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ TopKSort()

void TopKSort	(	unsigned int	k,
		unsigned int *	indices,
		const float *	values,
		unsigned int	numElement
	)

Definition at line 25 of file DetectionPostProcess.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), DetectionPostProcess(), and NonMaxSuppression().

 {
     std::partial_sort(indices, indices + k, indices + numElement,
                       [&values](unsigned int i, unsigned int j) { return values[i] > values[j]; });
 }

◆ TransposeConvolution2dImpl()

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
	)

Definition at line 15 of file TransposeConvolution2d.cpp.

References Decoder< IType >::Get(), DataLayoutIndexed::GetChannelsIndex(), DataLayoutIndexed::GetHeightIndex(), DataLayoutIndexed::GetIndex(), TensorShape::GetNumElements(), DataLayoutIndexed::GetWidthIndex(), TransposeConvolution2dDescriptor::m_BiasEnabled, TransposeConvolution2dDescriptor::m_DataLayout, TransposeConvolution2dDescriptor::m_PadLeft, TransposeConvolution2dDescriptor::m_PadTop, TransposeConvolution2dDescriptor::m_StrideX, TransposeConvolution2dDescriptor::m_StrideY, Encoder< IType >::Set(), and BaseIterator::SetIndex().

Referenced by RefTransposeConvolution2dWorkload::Execute().

 {
     if (descriptor.m_BiasEnabled && !biasesDecoder)
     {
         throw InvalidArgumentException("Biases enabled but no bias data provided");
     }
     const DataLayoutIndexed dataLayoutIndexed(descriptor.m_DataLayout);
     const unsigned int channelsIndex = dataLayoutIndexed.GetChannelsIndex();
     const unsigned int heightIndex   = dataLayoutIndexed.GetHeightIndex();
     const unsigned int widthIndex    = dataLayoutIndexed.GetWidthIndex();
 
     unsigned int numBatches = inputShape[0];
 
     unsigned int inputWidth  = inputShape[widthIndex];
     unsigned int inputHeight = inputShape[heightIndex];
     unsigned int inputDepth  = inputShape[channelsIndex];
 
     unsigned int weightsHeight = weightsShape[heightIndex];
     unsigned int weightsWidth  = weightsShape[widthIndex];
 
     unsigned int outputHeight = outputShape[heightIndex];
     unsigned int outputWidth  = outputShape[widthIndex];
     unsigned int outputDepth  = outputShape[channelsIndex];
 
     unsigned int paddingLeft = descriptor.m_PadLeft;
     unsigned int paddingTop  = descriptor.m_PadTop;
 
     unsigned int strideX = descriptor.m_StrideX;
     unsigned int strideY = descriptor.m_StrideY;
 
     std::vector<float> outputBuffer(outputShape.GetNumElements(), 0);
 
     for (unsigned int batch = 0u; batch < numBatches; ++batch)
     {
         for (unsigned int yInput = 0u; yInput < inputHeight; ++yInput)
         {
             for (unsigned int xInput = 0u; xInput < inputWidth; ++xInput)
             {
                 unsigned int xOutputOrigin = xInput * strideX - paddingLeft;
                 unsigned int yOutputOrigin = yInput * strideY - paddingTop;
 
                 for (unsigned int dOutput = 0u; dOutput < outputDepth; ++dOutput)
                 {
                     for (unsigned int yWeights = 0u; yWeights < weightsHeight; ++yWeights)
                     {
                         for (unsigned int xWeights = 0u; xWeights < weightsWidth; ++xWeights)
                         {
                             unsigned int yOutput = yOutputOrigin + yWeights;
                             unsigned int xOutput = xOutputOrigin + xWeights;
 
                             if (yOutput < outputHeight && xOutput< outputWidth)
                             {
                                 for (unsigned int dInput = 0u; dInput < inputDepth; dInput++)
                                 {
                                     const unsigned int inputIndex =
                                         dataLayoutIndexed.GetIndex(inputShape, batch, dInput, yInput, xInput);
                                     inputDecoder[inputIndex];
 
                                     const unsigned int weightsIndex =
                                         dataLayoutIndexed.GetIndex(weightsShape, dOutput, dInput, yWeights, xWeights);
                                     weightsDecoder.SetIndex(weightsIndex, dOutput);
 
                                     const unsigned int outputIndex =
                                         dataLayoutIndexed.GetIndex(outputShape, batch, dOutput, yOutput, xOutput);
                                     outputEncoder[outputIndex];
 
                                     float output = outputBuffer[outputIndex];
                                     output += inputDecoder.Get() * weightsDecoder.Get();
                                     outputBuffer[outputIndex] = output;
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
 
     // Apply bias (if enabled)
     if (descriptor.m_BiasEnabled)
     {
         outputEncoder[0];
         Decoder<float>& rBiasesDecoder = *biasesDecoder;
 
         for (unsigned int batch = 0u; batch < numBatches; ++batch)
         {
             for (unsigned int dOutput = 0u; dOutput < outputDepth; ++dOutput)
             {
                 rBiasesDecoder.SetIndex(dOutput, dOutput);
                 for (unsigned int yOutput = 0u; yOutput < outputHeight; ++yOutput)
                 {
                     for (unsigned int xOutput = 0u; xOutput < outputWidth; ++xOutput)
                     {
                         const unsigned int outputIndex =
                             dataLayoutIndexed.GetIndex(outputShape, batch, dOutput, yOutput, xOutput);
                         outputBuffer[outputIndex] += rBiasesDecoder.Get();
                     }
                 }
             }
         }
     }
     outputEncoder[0];
     for (float output : outputBuffer)
     {
         outputEncoder.Set(output);
         ++outputEncoder;
     }
 }

◆ TrueFunc()

bool armnn::TrueFunc	(	Optional< std::string &>	reasonIfUnsupported,
		Params &&...	params
	)

Definition at line 54 of file LayerSupportCommon.hpp.

References IgnoreUnused().

 {
     IgnoreUnused(reasonIfUnsupported);
     IgnoreUnused(params...);
     return true;
 }

◆ ValidateFullyConnectedLayer()

void armnn::ValidateFullyConnectedLayer ( const bool biasEnabled )

Definition at line 1099 of file QuantizerTest.cpp.

References INetworkQuantizer::Create(), CreateNetworkWithFullyConnectedLayer(), IgnoreUnused(), QAsymmS8, QSymmS16, QSymmS8, and VisitLayersTopologically().

Referenced by BOOST_AUTO_TEST_CASE().

 {
     class TestFullyConnectedQuantization : public TestQuantization
     {
     public:
         TestFullyConnectedQuantization(const TensorShape& inputShape, const TensorShape& outputShape)
         : TestQuantization(inputShape, outputShape) {}
 
         TestFullyConnectedQuantization(const QuantizerOptions& options,
                                        const TensorShape& inputShape,
                                        const TensorShape& outputShape)
         : TestQuantization(options, inputShape, outputShape) {}
 
         void VisitFullyConnectedLayer(const IConnectableLayer* layer,
                                       const FullyConnectedDescriptor& desc,
                                       const ConstTensor& weights,
                                       const Optional<ConstTensor>& biases,
                                       const char* name = nullptr) override
         {
             IgnoreUnused(desc, name);
             TestQuantizationOnLayersWithBiases(layer, weights, biases);
         }
     };
 
     const TensorShape shape{3U};
     INetworkPtr network = CreateNetworkWithFullyConnectedLayer(biasEnabled, shape, shape);
 
     INetworkPtr quantizedNetworkQAsymmU8 = INetworkQuantizer::Create(network.get())->ExportNetwork();
     TestFullyConnectedQuantization validatorQAsymmU8(shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmU8.get(), validatorQAsymmU8);
 
     const QuantizerOptions qAsymmS8Options(DataType::QAsymmS8);
     INetworkPtr quantizedNetworkQAsymmS8 = INetworkQuantizer::Create(network.get(), qAsymmS8Options)->ExportNetwork();
     TestFullyConnectedQuantization validatorQAsymmS8(qAsymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQAsymmS8.get(), validatorQAsymmS8);
 
     const QuantizerOptions qSymmS8Options(DataType::QSymmS8);
     INetworkPtr quantizedNetworkQSymmS8 = INetworkQuantizer::Create(network.get(), qSymmS8Options)->ExportNetwork();
     TestFullyConnectedQuantization validatorQSymmS8(qSymmS8Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS8.get(), validatorQSymmS8);
 
     const QuantizerOptions Qsymm16Options(DataType::QSymmS16);
     INetworkPtr quantizedNetworkQSymmS16 = INetworkQuantizer::Create(network.get(), Qsymm16Options)->ExportNetwork();
     TestFullyConnectedQuantization validatorQSymmS16(Qsymm16Options, shape, shape);
     VisitLayersTopologically(quantizedNetworkQSymmS16.get(), validatorQSymmS16);
 }

◆ VerifyTensorInfoDataType()

void armnn::VerifyTensorInfoDataType	(	const armnn::TensorInfo &	info,
		armnn::DataType	dataType
	)

inline

Definition at line 296 of file TypesUtils.hpp.

References TensorInfo::GetDataType(), GetDataTypeName(), and TensorInfo::GetShape().

Referenced by ParserFlatbuffersSerializeFixture::RunTest(), and ParserFlatbuffersFixture::RunTest().

 {
     if (info.GetDataType() != dataType)
     {
         std::stringstream ss;
         ss << "Unexpected datatype:" << armnn::GetDataTypeName(info.GetDataType())
            << " for tensor:" << info.GetShape()
            << ". The type expected to be: " << armnn::GetDataTypeName(dataType);
         throw armnn::Exception(ss.str());
     }
 }

◆ VisitLayers()

void armnn::VisitLayers	(	const LayerContainer &	layerContainer,
		ILayerVisitor &	visitor
	)

Definition at line 49 of file NetworkQuantizerUtils.hpp.

References ILayerVisitor::FinishVisit(), and ILayerVisitor::StartVisit().

Referenced by BOOST_AUTO_TEST_CASE(), NetworkQuantizer::ExportNetwork(), NetworkQuantizer::OverrideInputRange(), NetworkQuantizer::Refine(), and VisitLayersTopologically().

 {
     visitor.StartVisit();
     for (auto layer : layerContainer)
     {
         layer->Accept(visitor);
     }
     visitor.FinishVisit();
 }

◆ VisitLayersTopologically()

void armnn::VisitLayersTopologically	(	const INetwork *	inputNetwork,
		ILayerVisitor &	visitor
	)

Definition at line 192 of file QuantizerTest.cpp.

References g_AsymmS8QuantizationBase, g_AsymmU8QuantizationBase, g_SymmS16QuantizationBase, g_SymmS8QuantizationBase, IConnectableLayer::GetOutputSlot(), IOutputSlot::GetTensorInfo(), IgnoreUnused(), info, and VisitLayers().

Referenced by BOOST_AUTO_TEST_CASE(), PreserveTypeTestImpl(), TestQuantizeConvolution2d(), TestQuantizeDepthwiseConvolution2d(), TestQuantizeTransposeConvolution2d(), and ValidateFullyConnectedLayer().

 {
     auto network = PolymorphicDowncast<const Network*>(inputNetwork);
     auto graph = network->GetGraph().TopologicalSort();
 
     VisitLayers(graph, visitor);
 }

◆ WrapClError()

RuntimeException armnn::WrapClError	(	const cl::Error &	clError,
		const CheckLocation &	location
	)

inline

Definition at line 126 of file ClWorkloadUtils.hpp.

References Exception::what().

Referenced by ClWorkloadFactory::GetBackendId(), and RunClFunction().

 {
     std::stringstream message;
     message << "CL error: " << clError.what() << ". Error code: " << clError.err();
 
     return RuntimeException(message.str(), location);
 }

Variable Documentation

◆ g_AggregateProfilingEventsByInference

constexpr bool g_AggregateProfilingEventsByInference = true

Definition at line 38 of file Profiling.cpp.

◆ g_AsymmS8QuantizationBase

const float g_AsymmS8QuantizationBase = 255.0f

Definition at line 34 of file QuantizerTest.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), and VisitLayersTopologically().

◆ g_AsymmU8QuantizationBase

const float g_AsymmU8QuantizationBase = 255.0f

Definition at line 32 of file QuantizerTest.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), and VisitLayersTopologically().

◆ g_ProfilingEventCountHint

constexpr std::size_t g_ProfilingEventCountHint = 1024

Definition at line 30 of file Profiling.cpp.

◆ g_SymmS16QuantizationBase

const float g_SymmS16QuantizationBase = 32767.0f

Definition at line 36 of file QuantizerTest.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), and VisitLayersTopologically().

◆ g_SymmS8QuantizationBase

const float g_SymmS8QuantizationBase = 127.0f

Definition at line 35 of file QuantizerTest.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), and VisitLayersTopologically().

◆ g_TestTolerance

const float g_TestTolerance = 0.000001f

Definition at line 37 of file QuantizerTest.cpp.

◆ g_WriteProfilingEventSequence

constexpr bool g_WriteProfilingEventSequence = true

Definition at line 33 of file Profiling.cpp.

◆ g_WriteReportToStdOutOnProfilerDestruction

constexpr bool g_WriteReportToStdOutOnProfilerDestruction = false

Definition at line 42 of file Profiling.cpp.

◆ LOWEST_CAPTURE_PERIOD

constexpr unsigned int LOWEST_CAPTURE_PERIOD = 10000u

The lowest performance data capture interval we support is 10 miliseconds.

Definition at line 21 of file Types.hpp.

Referenced by BOOST_AUTO_TEST_CASE(), and PeriodicCounterSelectionCommandHandler::operator()().

◆ MaxNumOfTensorDimensions

constexpr unsigned int MaxNumOfTensorDimensions = 5U

Definition at line 18 of file Types.hpp.

Referenced by BOOST_FIXTURE_TEST_CASE(), armnnTfLiteParser::ComputeWrappedIndex(), Concatenate(), CopyTensorContentsGeneric(), TensorShape::IsAtLeastOneDimensionSpecified(), TfLiteParser::OutputShapeOfReshape(), PermutationVector::PermutationVector(), armnnUtils::Permuted(), Split(), Splitter(), and armnnUtils::TransposeTensorShape().

◆ paddingRequiredLayers

const std::set<armnn::LayerType> paddingRequiredLayers

Initial value:

{
    LayerType::ArgMinMax,
    LayerType::Convolution2d,
    LayerType::DepthToSpace,
    LayerType::DepthwiseConvolution2d,
    LayerType::Dequantize,
    LayerType::FullyConnected,
    LayerType::Gather,
    LayerType::Lstm,
    LayerType::Mean,
    LayerType::Permute,
    LayerType::Pooling2d,
    LayerType::Quantize,
    LayerType::QuantizedLstm,
    LayerType::Resize,
    LayerType::Stack,
    LayerType::TransposeConvolution2d
}

Definition at line 16 of file NeonTensorHandleFactory.hpp.

Referenced by NeonTensorHandleFactory::GetCapabilities().

◆ tl_Profiler

thread_local Profiler* tl_Profiler = nullptr

Definition at line 484 of file Profiling.cpp.

Referenced by ProfilerManager::GetProfiler().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ BackendIdSet

◆ BackendIdVector

◆ BackendsMap

◆ BaseFloat32ComparisonWorkload

◆ BaseUint8ComparisonWorkload

◆ BFloat16ToFloat32Workload

◆ BindingPointInfo

◆ BooleanWorkload

◆ CompiledBlobDeleter

◆ CompiledBlobPtr

◆ ConcatDescriptor

◆ Coordinates

◆ DebugCallbackFunction

◆ DepthToSpaceDescriptor

◆ Dimensions

◆ DynamicBackendPtr

◆ FactoryId

◆ Float16ToFloat32Workload

◆ Float32ToBFloat16Workload

◆ Float32ToFloat16Workload

◆ Float32Workload

◆ FloatWorkload

◆ Half

◆ IBackendContextUniquePtr

◆ IBackendInternalUniquePtr

◆ IBackendSharedPtr

◆ IBackendUniquePtr

◆ IGpuAccTunedParametersPtr

◆ ILayerSupportSharedPtr

◆ IMemoryManagerUniquePtr

◆ INetworkPtr

◆ INetworkQuantizerPtr

◆ InputQueueDescriptor

◆ InputTensors

◆ instead

◆ Int32Workload

◆ IOptimizedNetworkPtr

◆ IReportStructure

◆ IRuntimePtr

◆ LayerBindingId

◆ LayerGuid

◆ LayerPriority

◆ LayerTypeOf

◆ LoadedNetworks

◆ LogSoftmaxDescriptor

◆ MemorySourceFlags

◆ MergerDescriptor

◆ MergerQueueDescriptor

◆ MinMaxRange

◆ MinMaxRangeMap

◆ MinMaxRanges

◆ NetworkId

◆ NetworkOptions

◆ OffsetScalePair

◆ OutputQueueDescriptor

◆ OutputTensors

◆ ParameterStringifyFunction

◆ PreCompiledObjectDeleter

◆ PreCompiledObjectPtr

◆ RefAdditionWorkload

◆ RefDebugBFloat16Workload

◆ RefDebugFloat16Workload

◆ RefDebugFloat32Workload

◆ RefDebugQAsymmS8Workload

◆ RefDebugQAsymmU8Workload

◆ RefDebugQSymmS16Workload

◆ RefDebugQSymmS8Workload

◆ RefDebugSigned32Workload

◆ RefDivisionWorkload

◆ RefMaximumWorkload

◆ RefMinimumWorkload

◆ RefMultiplicationWorkload