IWorkloadFactory Class Reference

#include <WorkloadFactory.hpp>

Inheritance diagram for IWorkloadFactory:

Public Member Functions
virtual	~IWorkloadFactory ()
virtual void	AfterWorkloadsCreated ()
virtual const BackendId &	GetBackendId () const =0
virtual bool	SupportsSubTensors () const =0
virtual std::unique_ptr< ITensorHandle >	CreateSubTensorHandle (ITensorHandle &parent, TensorShape const &subTensorShape, unsigned int const *subTensorOrigin) const =0
virtual std::unique_ptr< ITensorHandle >	CreateTensorHandle (const TensorInfo &tensorInfo, const bool IsMemoryManaged=true) const =0
virtual std::unique_ptr< ITensorHandle >	CreateTensorHandle (const TensorInfo &tensorInfo, DataLayout dataLayout, const bool IsMemoryManaged=true) const =0
virtual std::unique_ptr< IWorkload >	CreateWorkload (LayerType type, const QueueDescriptor &descriptor, const WorkloadInfo &info) const

Static Public Member Functions
static bool	IsLayerSupported (const BackendId &backendId, const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
static bool	IsLayerSupported (const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
static bool	IsLayerSupported (const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported, const ModelOptions &modelOptions)
static bool	IsLayerSupported (const BackendId &backendId, const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported, const ModelOptions &modelOptions)

Detailed Description

Definition at line 22 of file WorkloadFactory.hpp.

Constructor & Destructor Documentation

~IWorkloadFactory()

virtual ~IWorkloadFactory ( )

inlinevirtual

Definition at line 25 of file WorkloadFactory.hpp.

{ }

Member Function Documentation

AfterWorkloadsCreated()

virtual void AfterWorkloadsCreated ( )

inlinevirtual

Reimplemented in ClWorkloadFactory.

Definition at line 27 of file WorkloadFactory.hpp.

{};

CreateSubTensorHandle()

virtual std::unique_ptr<ITensorHandle> CreateSubTensorHandle ( ITensorHandle &  parent, TensorShape const &  subTensorShape, unsigned int const *  subTensorOrigin  ) const

pure virtual

Implemented in RefWorkloadFactory, ClWorkloadFactory, NeonWorkloadFactory, TosaRefWorkloadFactory, WorkloadFactoryBase, and SampleDynamicWorkloadFactory.

CreateTensorHandle() [1/2]

virtual std::unique_ptr<ITensorHandle> CreateTensorHandle ( const TensorInfo &  tensorInfo, const bool  IsMemoryManaged = true  ) const

pure virtual

Implemented in RefWorkloadFactory, ClWorkloadFactory, TosaRefWorkloadFactory, NeonWorkloadFactory, WorkloadFactoryBase, and SampleDynamicWorkloadFactory.

Referenced by OutputHandler::CreateTensorHandles().

CreateTensorHandle() [2/2]

virtual std::unique_ptr<ITensorHandle> CreateTensorHandle ( const TensorInfo &  tensorInfo, DataLayout  dataLayout, const bool  IsMemoryManaged = true  ) const

pure virtual

Implemented in RefWorkloadFactory, ClWorkloadFactory, TosaRefWorkloadFactory, NeonWorkloadFactory, WorkloadFactoryBase, and SampleDynamicWorkloadFactory.

CreateWorkload()

ARMNN_NO_DEPRECATE_WARN_BEGIN std::unique_ptr< IWorkload > CreateWorkload ( LayerType  type, const QueueDescriptor &  descriptor, const WorkloadInfo &  info  ) const

virtual

Reimplemented in WorkloadFactoryBase, RefWorkloadFactory, ClWorkloadFactory, TosaRefWorkloadFactory, and NeonWorkloadFactory.

Definition at line 1590 of file WorkloadFactory.cpp.

{
    switch(type)
    {
        case LayerType::Activation :
        {
            auto activationQueueDescriptor = PolymorphicDowncast<const ActivationQueueDescriptor*>(&descriptor);
            return CreateActivation(*activationQueueDescriptor, info);
        }
        case LayerType::Addition :
        {
            auto additionQueueDescriptor = PolymorphicDowncast<const AdditionQueueDescriptor*>(&descriptor);
            return CreateAddition(*additionQueueDescriptor, info);
        }
        case LayerType::ArgMinMax :
        {
            auto argMinMaxQueueDescriptor = PolymorphicDowncast<const ArgMinMaxQueueDescriptor*>(&descriptor);
            return CreateArgMinMax(*argMinMaxQueueDescriptor, info);
        }
        case LayerType::BatchNormalization :
        {
            auto batchNormQueueDescriptor = PolymorphicDowncast<const BatchNormalizationQueueDescriptor*>(&descriptor);
            return CreateBatchNormalization(*batchNormQueueDescriptor, info);
        }
        case LayerType::BatchToSpaceNd :
        {
            auto batchToSpaceNdQueueDescriptor
                    = PolymorphicDowncast<const BatchToSpaceNdQueueDescriptor*>(&descriptor);
            return CreateBatchToSpaceNd(*batchToSpaceNdQueueDescriptor, info);
        }
        case LayerType::Cast :
        {
            auto castQueueDescriptor = PolymorphicDowncast<const CastQueueDescriptor*>(&descriptor);
            return CreateCast(*castQueueDescriptor, info);
        }
        case LayerType::ChannelShuffle :
        {
            auto channelShuffleQueueDescriptor
                    = PolymorphicDowncast<const ChannelShuffleQueueDescriptor*>(&descriptor);
            return CreateChannelShuffle(*channelShuffleQueueDescriptor, info);
        }
        case LayerType::Comparison :
        {
            auto comparisonQueueDescriptor = PolymorphicDowncast<const ComparisonQueueDescriptor*>(&descriptor);
            return CreateComparison(*comparisonQueueDescriptor, info);
        }
        case LayerType::Concat :
        {
            auto concatQueueDescriptor = PolymorphicDowncast<const ConcatQueueDescriptor*>(&descriptor);
            return CreateConcat(*concatQueueDescriptor, info);
        }
        case LayerType::Constant :
        {
            auto constantQueueDescriptor = PolymorphicDowncast<const ConstantQueueDescriptor*>(&descriptor);
            return CreateConstant(*constantQueueDescriptor, info);
        }
        case LayerType::ConvertFp16ToFp32:
        {
            auto convertFp16ToFp32QueueDescriptor
                    = PolymorphicDowncast<const ConvertFp16ToFp32QueueDescriptor*>(&descriptor);
            return CreateConvertFp16ToFp32(*convertFp16ToFp32QueueDescriptor, info);
        }
        case LayerType::ConvertFp32ToFp16:
        {
            auto convertFp32ToFp16QueueDescriptor
                    = PolymorphicDowncast<const ConvertFp32ToFp16QueueDescriptor*>(&descriptor);
            return CreateConvertFp32ToFp16(*convertFp32ToFp16QueueDescriptor, info);
        }
        case LayerType::Convolution2d:
        {
            auto convolution2dQueueDescriptor = PolymorphicDowncast<const Convolution2dQueueDescriptor*>(&descriptor);
            return CreateConvolution2d(*convolution2dQueueDescriptor, info);
        }
        case LayerType::Convolution3d:
        {
            auto convolution3dQueueDescriptor = PolymorphicDowncast<const Convolution3dQueueDescriptor*>(&descriptor);
            return CreateConvolution3d(*convolution3dQueueDescriptor, info);
        }
        case LayerType::Debug:
        {
            auto debugQueueDescriptor = PolymorphicDowncast<const DebugQueueDescriptor*>(&descriptor);
            return CreateDebug(*debugQueueDescriptor, info);
        }
        case LayerType::DepthToSpace:
        {
            auto depthToSpaceQueueDescriptor = PolymorphicDowncast<const DepthToSpaceQueueDescriptor*>(&descriptor);
            return CreateDepthToSpace(*depthToSpaceQueueDescriptor, info);
        }
        case LayerType::DepthwiseConvolution2d:
        {
            auto depthwiseConvolution2DQueueDescriptor
                    = PolymorphicDowncast<const DepthwiseConvolution2dQueueDescriptor*>(&descriptor);
            return CreateDepthwiseConvolution2d(*depthwiseConvolution2DQueueDescriptor, info);
        }
        case LayerType::Dequantize:
        {
            auto dequantizeQueueDescriptor = PolymorphicDowncast<const DequantizeQueueDescriptor*>(&descriptor);
            return CreateDequantize(*dequantizeQueueDescriptor, info);
        }
        case LayerType::DetectionPostProcess:
        {
            auto detectionPostProcessQueueDescriptor
                    = PolymorphicDowncast<const DetectionPostProcessQueueDescriptor*>(&descriptor);
            return CreateDetectionPostProcess(*detectionPostProcessQueueDescriptor, info);
        }
        case LayerType::Division:
        {
            auto divisionQueueDescriptor = PolymorphicDowncast<const DivisionQueueDescriptor*>(&descriptor);
            return CreateDivision(*divisionQueueDescriptor, info);
        }
        case LayerType::ElementwiseBinary:
        {
            auto queueDescriptor = PolymorphicDowncast<const ElementwiseBinaryQueueDescriptor*>(&descriptor);
            return CreateWorkload(LayerType::ElementwiseBinary, *queueDescriptor, info);
        }
        case LayerType::ElementwiseUnary:
        {
            auto elementwiseUnaryQueueDescriptor
                    = PolymorphicDowncast<const ElementwiseUnaryQueueDescriptor*>(&descriptor);
            return CreateElementwiseUnary(*elementwiseUnaryQueueDescriptor, info);
 
        }
        case LayerType::FakeQuantization:
        {
            auto fakeQuantizationQueueDescriptor
                    = PolymorphicDowncast<const FakeQuantizationQueueDescriptor*>(&descriptor);
            return CreateFakeQuantization(*fakeQuantizationQueueDescriptor, info);
        }
        case LayerType::Fill:
        {
            auto fillQueueDescriptor = PolymorphicDowncast<const FillQueueDescriptor*>(&descriptor);
            return CreateFill(*fillQueueDescriptor, info);
        }
        case LayerType::Floor:
        {
            auto floorQueueDescriptor = PolymorphicDowncast<const FloorQueueDescriptor*>(&descriptor);
            return CreateFloor(*floorQueueDescriptor, info);
        }
        case LayerType::FullyConnected:
        {
            auto fullyConnectedQueueDescriptor
                    = PolymorphicDowncast<const FullyConnectedQueueDescriptor*>(&descriptor);
            return CreateFullyConnected(*fullyConnectedQueueDescriptor, info);
        }
        case LayerType::Gather:
        {
            auto gatherQueueDescriptor = PolymorphicDowncast<const GatherQueueDescriptor*>(&descriptor);
            return CreateGather(*gatherQueueDescriptor, info);
        }
        case LayerType::Input:
        {
            auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
            return CreateInput(*inputQueueDescriptor, info);
        }
        case LayerType::InstanceNormalization:
        {
            auto instanceNormalizationQueueDescriptor
                    = PolymorphicDowncast<const InstanceNormalizationQueueDescriptor*>(&descriptor);
            return CreateInstanceNormalization(*instanceNormalizationQueueDescriptor, info);
        }
        case LayerType::L2Normalization:
        {
            auto l2NormalizationQueueDescriptor
                    = PolymorphicDowncast<const L2NormalizationQueueDescriptor*>(&descriptor);
            return CreateL2Normalization(*l2NormalizationQueueDescriptor, info);
        }
        case LayerType::LogicalBinary:
        {
            auto logicalBinaryQueueDescriptor = PolymorphicDowncast<const LogicalBinaryQueueDescriptor*>(&descriptor);
            return CreateLogicalBinary(*logicalBinaryQueueDescriptor, info);
        }
        case LayerType::LogSoftmax:
        {
            auto logSoftmaxQueueDescriptor = PolymorphicDowncast<const LogSoftmaxQueueDescriptor*>(&descriptor);
            return CreateLogSoftmax(*logSoftmaxQueueDescriptor, info);
        }
        case LayerType::Lstm:
        {
            auto lstmQueueDescriptor = PolymorphicDowncast<const LstmQueueDescriptor*>(&descriptor);
            return CreateLstm(*lstmQueueDescriptor, info);
        }
        case LayerType::Maximum:
        {
            auto maximumQueueDescriptor = PolymorphicDowncast<const MaximumQueueDescriptor*>(&descriptor);
            return CreateMaximum(*maximumQueueDescriptor, info);
        }
        case LayerType::Mean:
        {
            auto meanQueueDescriptor = PolymorphicDowncast<const MeanQueueDescriptor*>(&descriptor);
            return CreateMean(*meanQueueDescriptor, info);
        }
        case LayerType::MemCopy:
        {
            auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor);
            return CreateMemCopy(*memCopyQueueDescriptor, info);
        }
        case LayerType::MemImport:
        {
            auto memImportQueueDescriptor = PolymorphicDowncast<const MemImportQueueDescriptor*>(&descriptor);
            return CreateMemImport(*memImportQueueDescriptor, info);
        }
        case LayerType::Minimum:
        {
            auto minimumQueueDescriptor = PolymorphicDowncast<const MinimumQueueDescriptor*>(&descriptor);
            return CreateMinimum(*minimumQueueDescriptor, info);
        }
        case LayerType::Multiplication:
        {
            auto multiplicationQueueDescriptor
                    = PolymorphicDowncast<const MultiplicationQueueDescriptor*>(&descriptor);
            return CreateMultiplication(*multiplicationQueueDescriptor, info);
        }
        case LayerType::Normalization:
        {
            auto normalizationQueueDescriptor = PolymorphicDowncast<const NormalizationQueueDescriptor*>(&descriptor);
            return CreateNormalization(*normalizationQueueDescriptor, info);
        }
        case LayerType::Output:
        {
            auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
            return CreateOutput(*outputQueueDescriptor, info);
        }
        case LayerType::Pad:
        {
            auto padQueueDescriptor = PolymorphicDowncast<const PadQueueDescriptor*>(&descriptor);
            return CreatePad(*padQueueDescriptor, info);
        }
        case LayerType::Permute:
        {
            auto permuteQueueDescriptor = PolymorphicDowncast<const PermuteQueueDescriptor*>(&descriptor);
            return CreatePermute(*permuteQueueDescriptor, info);
        }
        case LayerType::Pooling2d:
        {
            auto pooling2dQueueDescriptor = PolymorphicDowncast<const Pooling2dQueueDescriptor*>(&descriptor);
            return CreatePooling2d(*pooling2dQueueDescriptor, info);
        }
        case LayerType::Pooling3d:
        {
            auto pooling3dQueueDescriptor = PolymorphicDowncast<const Pooling3dQueueDescriptor*>(&descriptor);
            return CreatePooling3d(*pooling3dQueueDescriptor, info);
        }
        case LayerType::PreCompiled:
        {
            auto preCompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
            return CreatePreCompiled(*preCompiledQueueDescriptor, info);
        }
        case LayerType::Prelu:
        {
            auto preluQueueDescriptor = PolymorphicDowncast<const PreluQueueDescriptor*>(&descriptor);
            return CreatePrelu(*preluQueueDescriptor, info);
        }
        case LayerType::QLstm:
        {
            auto qlstmQueueDescriptor = PolymorphicDowncast<const QLstmQueueDescriptor*>(&descriptor);
            return CreateQLstm(*qlstmQueueDescriptor, info);
        }
        case LayerType::Quantize:
        {
            auto quantizeQueueDescriptor = PolymorphicDowncast<const QuantizeQueueDescriptor*>(&descriptor);
            return CreateQuantize(*quantizeQueueDescriptor, info);
        }
        case LayerType::Rank:
        {
            auto rankQueueDescriptor = PolymorphicDowncast<const RankQueueDescriptor*>(&descriptor);
            return CreateRank(*rankQueueDescriptor, info);
        }
        case LayerType::Reduce:
        {
            auto reduceQueueDescriptor = PolymorphicDowncast<const ReduceQueueDescriptor*>(&descriptor);
            return CreateReduce(*reduceQueueDescriptor, info);
        }
        case LayerType::Reshape:
        {
            auto reshapeQueueDescriptor = PolymorphicDowncast<const ReshapeQueueDescriptor*>(&descriptor);
            return CreateReshape(*reshapeQueueDescriptor, info);
        }
        case LayerType::Resize:
        {
            auto resizeQueueDescriptor = PolymorphicDowncast<const ResizeQueueDescriptor*>(&descriptor);
            return CreateResize(*resizeQueueDescriptor, info);
        }
        case LayerType::Shape:
        {
            auto shapeQueueDescriptor = PolymorphicDowncast<const ShapeQueueDescriptor*>(&descriptor);
            return CreateShape(*shapeQueueDescriptor, info);
        }
        case LayerType::Slice:
        {
            auto sliceQueueDescriptor = PolymorphicDowncast<const SliceQueueDescriptor*>(&descriptor);
            return CreateSlice(*sliceQueueDescriptor, info);
        }
        case LayerType::Softmax:
        {
            auto softmaxQueueDescriptor = PolymorphicDowncast<const SoftmaxQueueDescriptor*>(&descriptor);
            return CreateSoftmax(*softmaxQueueDescriptor, info);
        }
        case LayerType::SpaceToBatchNd:
        {
            auto spaceToBatchNdQueueDescriptor
                    = PolymorphicDowncast<const SpaceToBatchNdQueueDescriptor*>(&descriptor);
            return CreateSpaceToBatchNd(*spaceToBatchNdQueueDescriptor, info);
        }
        case LayerType::SpaceToDepth:
        {
            auto spaceToDepthQueueDescriptor = PolymorphicDowncast<const SpaceToDepthQueueDescriptor*>(&descriptor);
            return CreateSpaceToDepth(*spaceToDepthQueueDescriptor, info);
        }
        case LayerType::Splitter:
        {
            auto splitterQueueDescriptor = PolymorphicDowncast<const SplitterQueueDescriptor*>(&descriptor);
            return CreateSplitter(*splitterQueueDescriptor, info);
        }
        case LayerType::Stack:
        {
            auto stackQueueDescriptor = PolymorphicDowncast<const StackQueueDescriptor*>(&descriptor);
            return CreateStack(*stackQueueDescriptor, info);
        }
        case LayerType::StridedSlice:
        {
            auto stridedSliceQueueDescriptor = PolymorphicDowncast<const StridedSliceQueueDescriptor*>(&descriptor);
            return CreateStridedSlice(*stridedSliceQueueDescriptor, info);
        }
        case LayerType::Subtraction:
        {
            auto subtractionQueueDescriptor = PolymorphicDowncast<const SubtractionQueueDescriptor*>(&descriptor);
            return CreateSubtraction(*subtractionQueueDescriptor, info);
        }
        case LayerType::Transpose:
        {
            auto transposeQueueDescriptor = PolymorphicDowncast<const TransposeQueueDescriptor*>(&descriptor);
            return CreateTranspose(*transposeQueueDescriptor, info);
        }
        case LayerType::TransposeConvolution2d:
        {
            auto transposeConvolution2dQueueDescriptor
                    = PolymorphicDowncast<const TransposeConvolution2dQueueDescriptor*>(&descriptor);
            return CreateTransposeConvolution2d(*transposeConvolution2dQueueDescriptor, info);
        }
        case LayerType::UnidirectionalSequenceLstm:
        {
            auto unidirectionalSequenceLstmQueueDescriptor
                    = PolymorphicDowncast<const UnidirectionalSequenceLstmQueueDescriptor*>(&descriptor);
            return CreateUnidirectionalSequenceLstm(*unidirectionalSequenceLstmQueueDescriptor, info);
        }
        default:
            return nullptr;
    }
}

References armnn::Activation, armnn::Addition, armnn::ArgMinMax, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::Cast, armnn::ChannelShuffle, armnn::Comparison, armnn::Concat, armnn::Constant, armnn::ConvertFp16ToFp32, armnn::ConvertFp32ToFp16, armnn::Convolution2d, armnn::Convolution3d, armnn::Debug, armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::Dequantize, armnn::DetectionPostProcess, armnn::Division, armnn::ElementwiseBinary, armnn::ElementwiseUnary, armnn::FakeQuantization, armnn::Fill, armnn::Floor, armnn::FullyConnected, armnn::Gather, armnn::info, armnn::Input, armnn::InstanceNormalization, armnn::L2Normalization, armnn::LogicalBinary, armnn::LogSoftmax, armnn::Lstm, armnn::Maximum, armnn::Mean, armnn::MemCopy, armnn::MemImport, armnn::Minimum, armnn::Multiplication, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::Pooling2d, armnn::Pooling3d, armnn::PreCompiled, armnn::Prelu, armnn::QLstm, armnn::Quantize, armnn::Rank, armnn::Reduce, armnn::Reshape, armnn::Resize, armnn::Shape, armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::Stack, armnn::StridedSlice, armnn::Subtraction, armnn::Transpose, armnn::TransposeConvolution2d, and armnn::UnidirectionalSequenceLstm.

Referenced by ActivationLayer::CreateWorkload(), ConvertFp32ToFp16Layer::CreateWorkload(), FillLayer::CreateWorkload(), QuantizeLayer::CreateWorkload(), RankLayer::CreateWorkload(), AbsLayer::CreateWorkload(), StridedSliceLayer::CreateWorkload(), StackLayer::CreateWorkload(), CastLayer::CreateWorkload(), DebugLayer::CreateWorkload(), L2NormalizationLayer::CreateWorkload(), SoftmaxLayer::CreateWorkload(), SwitchLayer::CreateWorkload(), ShapeLayer::CreateWorkload(), RsqrtLayer::CreateWorkload(), BatchMatMulLayer::CreateWorkload(), DequantizeLayer::CreateWorkload(), NormalizationLayer::CreateWorkload(), Pooling2dLayer::CreateWorkload(), ConcatLayer::CreateWorkload(), Pooling3dLayer::CreateWorkload(), FakeQuantizationLayer::CreateWorkload(), ConvertFp16ToFp32Layer::CreateWorkload(), ResizeLayer::CreateWorkload(), FloorLayer::CreateWorkload(), AdditionLayer::CreateWorkload(), BatchToSpaceNdLayer::CreateWorkload(), SliceLayer::CreateWorkload(), GatherNdLayer::CreateWorkload(), SplitterLayer::CreateWorkload(), InstanceNormalizationLayer::CreateWorkload(), MeanLayer::CreateWorkload(), SpaceToBatchNdLayer::CreateWorkload(), SpaceToDepthLayer::CreateWorkload(), SubtractionLayer::CreateWorkload(), LogicalBinaryLayer::CreateWorkload(), ArgMinMaxLayer::CreateWorkload(), LogSoftmaxLayer::CreateWorkload(), DepthToSpaceLayer::CreateWorkload(), MaximumLayer::CreateWorkload(), MinimumLayer::CreateWorkload(), ComparisonLayer::CreateWorkload(), PadLayer::CreateWorkload(), PermuteLayer::CreateWorkload(), ReduceLayer::CreateWorkload(), DivisionLayer::CreateWorkload(), ElementwiseBinaryLayer::CreateWorkload(), TransposeLayer::CreateWorkload(), ElementwiseUnaryLayer::CreateWorkload(), PreluLayer::CreateWorkload(), MultiplicationLayer::CreateWorkload(), GatherLayer::CreateWorkload(), ConstantLayer::CreateWorkload(), ChannelShuffleLayer::CreateWorkload(), ReshapeLayer::CreateWorkload(), Convolution2dLayer::CreateWorkload(), FullyConnectedLayer::CreateWorkload(), DepthwiseConvolution2dLayer::CreateWorkload(), Convolution3dLayer::CreateWorkload(), DetectionPostProcessLayer::CreateWorkload(), TransposeConvolution2dLayer::CreateWorkload(), PreCompiledLayer::CreateWorkload(), UnidirectionalSequenceLstmLayer::CreateWorkload(), LstmLayer::CreateWorkload(), BatchNormalizationLayer::CreateWorkload(), QuantizedLstmLayer::CreateWorkload(), and QLstmLayer::CreateWorkload().

GetBackendId()

virtual const BackendId& GetBackendId ( ) const

pure virtual

Implemented in RefWorkloadFactory, ClWorkloadFactory, NeonWorkloadFactory, TosaRefWorkloadFactory, and SampleDynamicWorkloadFactory.

IsLayerSupported() [1/4]

bool IsLayerSupported ( const BackendId &  backendId, const IConnectableLayer &  layer, Optional< DataType >  dataType, std::string &  outReasonIfUnsupported  )

static

Definition at line 1548 of file WorkloadFactory.cpp.

{
    return IsLayerConfigurationSupported(backendId, connectableLayer, dataType, outReasonIfUnsupported);
}

Referenced by armnn::AttemptBackendAssignment(), TosaRefWorkloadFactory::IsLayerSupported(), NeonWorkloadFactory::IsLayerSupported(), ClWorkloadFactory::IsLayerSupported(), and RefWorkloadFactory::IsLayerSupported().

IsLayerSupported() [2/4]

bool IsLayerSupported ( const BackendId &  backendId, const IConnectableLayer &  layer, Optional< DataType >  dataType, std::string &  outReasonIfUnsupported, const ModelOptions &  modelOptions  )

static

Definition at line 1577 of file WorkloadFactory.cpp.

{
    return IsLayerConfigurationSupported(backendId,
                                         connectableLayer,
                                         dataType,
                                         outReasonIfUnsupported,
                                         modelOptions);
}

IsLayerSupported() [3/4]

bool IsLayerSupported ( const IConnectableLayer &  layer, Optional< DataType >  dataType, std::string &  outReasonIfUnsupported  )

static

Definition at line 1556 of file WorkloadFactory.cpp.

{
    auto layer = PolymorphicDowncast<const Layer*>(&connectableLayer);
    return IsLayerConfigurationSupported(layer->GetBackendId(), connectableLayer, dataType, outReasonIfUnsupported);
}

IsLayerSupported() [4/4]

bool IsLayerSupported ( const IConnectableLayer &  layer, Optional< DataType >  dataType, std::string &  outReasonIfUnsupported, const ModelOptions &  modelOptions  )

static

Definition at line 1564 of file WorkloadFactory.cpp.

{
    auto layer = PolymorphicDowncast<const Layer*>(&connectableLayer);
    return IsLayerConfigurationSupported(layer->GetBackendId(),
                                         connectableLayer,
                                         dataType,
                                         outReasonIfUnsupported,
                                         modelOptions);
}

SupportsSubTensors()

virtual bool SupportsSubTensors ( ) const

pure virtual

Implemented in RefWorkloadFactory, ClWorkloadFactory, NeonWorkloadFactory, TosaRefWorkloadFactory, SampleDynamicWorkloadFactory, and WorkloadFactoryBase.

---

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

• include/armnn/backends/WorkloadFactory.hpp
• src/backends/backendsCommon/WorkloadFactory.cpp