GpuFsaWorkloadFactory Class Reference

#include <GpuFsaWorkloadFactory.hpp>

Inheritance diagram for GpuFsaWorkloadFactory:

Collaboration diagram for GpuFsaWorkloadFactory:

Public Member Functions
	GpuFsaWorkloadFactory (const std::shared_ptr< GpuFsaMemoryManager > &memoryManager)
	GpuFsaWorkloadFactory ()
	~GpuFsaWorkloadFactory ()
const BackendId &	GetBackendId () const override
bool	SupportsSubTensors () const override
std::unique_ptr< ITensorHandle >	CreateSubTensorHandle (ITensorHandle &, TensorShape const &, unsigned int const *) const override
std::unique_ptr< ITensorHandle >	CreateTensorHandle (const TensorInfo &tensorInfo, const bool IsMemoryManaged=true) const override
std::unique_ptr< ITensorHandle >	CreateTensorHandle (const TensorInfo &tensorInfo, DataLayout dataLayout, const bool IsMemoryManaged=true) const override
void	InitializeCLCompileContext ()
std::unique_ptr< IWorkload >	CreateWorkload (LayerType type, const QueueDescriptor &descriptor, const WorkloadInfo &info) const override
	Backends should implement their own CreateWorkload function with a switch statement. More...
Public Member Functions inherited from IWorkloadFactory
virtual	~IWorkloadFactory ()
virtual void	AfterWorkloadsCreated ()

Static Public Member Functions
static bool	IsLayerSupported (const Layer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
Static Public Member Functions inherited from IWorkloadFactory
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 17 of file GpuFsaWorkloadFactory.hpp.

Constructor & Destructor Documentation

GpuFsaWorkloadFactory() [1/2]

GpuFsaWorkloadFactory ( const std::shared_ptr< GpuFsaMemoryManager > &  memoryManager )

explicit

Definition at line 48 of file GpuFsaWorkloadFactory.cpp.

    : m_MemoryManager(memoryManager)
{
    InitializeCLCompileContext();
}

References GpuFsaWorkloadFactory::InitializeCLCompileContext().

GpuFsaWorkloadFactory() [2/2]

GpuFsaWorkloadFactory

(

)

Definition at line 54 of file GpuFsaWorkloadFactory.cpp.

    : m_MemoryManager(new GpuFsaMemoryManager())
{
    InitializeCLCompileContext();
}

References GpuFsaWorkloadFactory::InitializeCLCompileContext().

~GpuFsaWorkloadFactory()

~GpuFsaWorkloadFactory ( )

inline

Definition at line 23 of file GpuFsaWorkloadFactory.hpp.

{}

Member Function Documentation

CreateSubTensorHandle()

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

inlineoverridevirtual

Implements IWorkloadFactory.

Definition at line 34 of file GpuFsaWorkloadFactory.hpp.

    {
        return nullptr;
    }

CreateTensorHandle() [1/2]

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

overridevirtual

Implements IWorkloadFactory.

Definition at line 72 of file GpuFsaWorkloadFactory.cpp.

{
    std::unique_ptr<GpuFsaTensorHandle> tensorHandle = std::make_unique<GpuFsaTensorHandle>(tensorInfo);
    tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
 
    return tensorHandle;
}

CreateTensorHandle() [2/2]

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

overridevirtual

Implements IWorkloadFactory.

Definition at line 81 of file GpuFsaWorkloadFactory.cpp.

{
    std::unique_ptr<GpuFsaTensorHandle> tensorHandle = std::make_unique<GpuFsaTensorHandle>(tensorInfo, dataLayout);
    tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
 
    return tensorHandle;
}

CreateWorkload()

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

overridevirtual

Backends should implement their own CreateWorkload function with a switch statement.

The case for the switch should be the LayerType and based on that they will call their specific workload creation functionality.

Implements IWorkloadFactory.

Definition at line 99 of file GpuFsaWorkloadFactory.cpp.

{
    switch(type)
    {
        case LayerType::Constant :
        {
            auto constQueueDescriptor = PolymorphicDowncast<const ConstantQueueDescriptor*>(&descriptor);
            return std::make_unique<GpuFsaConstantWorkload>(*constQueueDescriptor, info, m_CLCompileContext);
        }
        case LayerType::Input :
        {
            auto inputQueueDescriptor = PolymorphicDowncast<const InputQueueDescriptor*>(&descriptor);
            return std::make_unique<CopyMemGenericWorkload>(*inputQueueDescriptor, info);
        }
        case LayerType::Output :
        {
            auto outputQueueDescriptor = PolymorphicDowncast<const OutputQueueDescriptor*>(&descriptor);
            return std::make_unique<CopyMemGenericWorkload>(*outputQueueDescriptor, info);
        }
        case LayerType::MemCopy :
        {
            auto memCopyQueueDescriptor = PolymorphicDowncast<const MemCopyQueueDescriptor*>(&descriptor);
            if (memCopyQueueDescriptor->m_Inputs.empty() || !memCopyQueueDescriptor->m_Inputs[0])
            {
                throw InvalidArgumentException("GpuFsaWorkloadFactory: Invalid null input for MemCopy workload");
            }
            return std::make_unique<CopyMemGenericWorkload>(*memCopyQueueDescriptor, info);
        }
        case LayerType::PreCompiled :
        {
            auto precompiledQueueDescriptor = PolymorphicDowncast<const PreCompiledQueueDescriptor*>(&descriptor);
            return std::make_unique<GpuFsaPreCompiledWorkload>(*precompiledQueueDescriptor, info);
        }
        default :
            return nullptr;
    }
}

References armnn::Constant, armnn::info, armnn::Input, armnn::MemCopy, armnn::Output, and armnn::PreCompiled.

GetBackendId()

const BackendId & GetBackendId ( ) const

overridevirtual

Implements IWorkloadFactory.

Definition at line 60 of file GpuFsaWorkloadFactory.cpp.

{
    return s_Id;
}

InitializeCLCompileContext()

void InitializeCLCompileContext

(

)

Definition at line 92 of file GpuFsaWorkloadFactory.cpp.

                                                       {
    // Initialize our m_CLCompileContext using default device and context
    auto context = arm_compute::CLKernelLibrary::get().context();
    auto device = arm_compute::CLKernelLibrary::get().get_device();
    m_CLCompileContext = arm_compute::CLCompileContext(context, device);
}

Referenced by GpuFsaWorkloadFactory::GpuFsaWorkloadFactory().

IsLayerSupported()

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

static

Definition at line 65 of file GpuFsaWorkloadFactory.cpp.

{
    return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported);
}

References IWorkloadFactory::IsLayerSupported().

SupportsSubTensors()

bool SupportsSubTensors ( ) const

inlineoverridevirtual

Implements IWorkloadFactory.

Definition at line 31 of file GpuFsaWorkloadFactory.hpp.

{ return false; }

---

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

• src/backends/gpuFsa/GpuFsaWorkloadFactory.hpp
• src/backends/gpuFsa/GpuFsaWorkloadFactory.cpp