EthosnRefWorkloadFactory.cpp

Go to the documentation of this file.

//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <Layer.hpp>
#include <backendsCommon/CpuTensorHandle.hpp>
#include <backendsCommon/MemCopyWorkload.hpp>
#include <backendsCommon/MemImportWorkload.hpp>
#include <backendsCommon/MakeWorkloadHelper.hpp>
#include "EthosnRefWorkloadFactory.hpp"
#include "EthosnRefBackendId.hpp"
#include "workloads/EthosnRefWorkloads.hpp"
#include "EthosnRefTensorHandle.hpp"


namespace armnn
{

namespace
{
static const BackendId s_Id{EthosnRefBackendId()};
}

EthosnRefWorkloadFactory::EthosnRefWorkloadFactory(const std::shared_ptr<EthosnRefMemoryManager>& memoryManager, bool winograd, std::string BlockConfigs)
    : m_MemoryManager(memoryManager)
{
  m_EnableWinograd = winograd;
  m_BlockConfigs = BlockConfigs;
}

EthosnRefWorkloadFactory::EthosnRefWorkloadFactory()
    : m_MemoryManager(new EthosnRefMemoryManager())
{
}

const BackendId& EthosnRefWorkloadFactory::GetBackendId() const
{
    return s_Id;
}

bool EthosnRefWorkloadFactory::IsLayerSupported(const Layer& layer,
                                          Optional<DataType> dataType,
                                          std::string& outReasonIfUnsupported)
{
    return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported);
}

std::unique_ptr<ITensorHandle> EthosnRefWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
                                                                      const bool isMemoryManaged) const
{
    // For EthosnRef it is okay to make the TensorHandle memory managed as it can also store a pointer
    // to unmanaged memory. This also ensures memory alignment.
    IgnoreUnused(isMemoryManaged);
    return std::make_unique<EthosnRefTensorHandle>(tensorInfo, m_MemoryManager);
}

std::unique_ptr<ITensorHandle> EthosnRefWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
                                                                      DataLayout dataLayout,
                                                                      const bool isMemoryManaged) const
{
    // For EthosnRef it is okay to make the TensorHandle memory managed as it can also store a pointer
    // to unmanaged memory. This also ensures memory alignment.
    IgnoreUnused(isMemoryManaged, dataLayout);
    return std::make_unique<EthosnRefTensorHandle>(tensorInfo, m_MemoryManager);
}

// REVISIT: Use TensorHandleFactory Import/Export methods to replace Input/Output layers
std::unique_ptr<IWorkload> EthosnRefWorkloadFactory::CreateInput(const InputQueueDescriptor& descriptor,
                                                           const WorkloadInfo& info) const
{
    if (info.m_InputTensorInfos.empty() )
    {
        throw InvalidArgumentException("EthosnRefWorkloadFactory::CreateInput: Input cannot be zero length");
    }
    if (info.m_OutputTensorInfos.empty())
    {
        throw InvalidArgumentException("EthosnRefWorkloadFactory::CreateInput: Output cannot be zero length");
    }

    if (info.m_InputTensorInfos[0].GetNumBytes() != info.m_OutputTensorInfos[0].GetNumBytes())
    {
        throw InvalidArgumentException("EthosnRefWorkloadFactory::CreateInput: data input and output differ in byte count.");
    }

    return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
}

std::unique_ptr<IWorkload> EthosnRefWorkloadFactory::CreateOutput(const OutputQueueDescriptor& descriptor,
                                                            const WorkloadInfo& info) const
{
    if (info.m_InputTensorInfos.empty() )
    {
        throw InvalidArgumentException("EthosnRefWorkloadFactory::CreateOutput: Input cannot be zero length");
    }
    if (info.m_OutputTensorInfos.empty())
    {
        throw InvalidArgumentException("EthosnRefWorkloadFactory::CreateOutput: Output cannot be zero length");
    }
    if (info.m_InputTensorInfos[0].GetNumBytes() != info.m_OutputTensorInfos[0].GetNumBytes())
    {
        throw InvalidArgumentException("EthosnRefWorkloadFactory::CreateOutput: data input and output differ in byte count.");
    }

    return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
}

std::unique_ptr<IWorkload> EthosnRefWorkloadFactory::CreateConvolution2d(const Convolution2dQueueDescriptor& descriptor,
                                                                   const WorkloadInfo& info) const
{
    return std::make_unique<EthosnRefConvolution2dWorkload>(descriptor, info, m_EnableWinograd, m_BlockConfigs);
}

std::unique_ptr<IWorkload> EthosnRefWorkloadFactory::CreateDepthwiseConvolution2d(
    const DepthwiseConvolution2dQueueDescriptor& descriptor,
    const WorkloadInfo& info) const
{
    return std::make_unique<EthosnRefDepthwiseConvolution2dWorkload>(descriptor, info);
}

std::unique_ptr<IWorkload> EthosnRefWorkloadFactory::CreateTransposeConvolution2d(
    const TransposeConvolution2dQueueDescriptor& descriptor,
    const WorkloadInfo& info) const
{
    return std::make_unique<EthosnRefTransposeConvolution2dWorkload>(descriptor, info);
}

std::unique_ptr<IWorkload> EthosnRefWorkloadFactory::CreatePooling2d(const Pooling2dQueueDescriptor& descriptor,
                                                               const WorkloadInfo& info) const
{
    return std::make_unique<EthosnRefPooling2dWorkload>(descriptor, info);
}

} // namespace armnn