EthosnRefBackend.cpp

Go to the documentation of this file.

//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include "EthosnRefBackend.hpp"
#include "EthosnRefBackendId.hpp"
#include "EthosnRefWorkloadFactory.hpp"
#include "EthosnRefLayerSupport.hpp"
#include "EthosnRefTensorHandleFactory.hpp"

#include <armnn/BackendRegistry.hpp>

#include <armnn/backends/IBackendContext.hpp>
#include <armnn/backends/IMemoryManager.hpp>

#include <Optimizer.hpp>

#include <armnn/utility/PolymorphicDowncast.hpp>

namespace armnn
{

static bool VarGlobal_EnableWinograd;
static std::string VarGlobal_BlockConfigs;

const BackendId& EthosnRefBackend::GetIdStatic()
{
    static const BackendId s_Id{EthosnRefBackendId()};
    return s_Id;
}

IBackendInternal::IWorkloadFactoryPtr EthosnRefBackend::CreateWorkloadFactory(
    const IBackendInternal::IMemoryManagerSharedPtr& memoryManager) const
{
    return std::make_unique<EthosnRefWorkloadFactory>(PolymorphicPointerDowncast<EthosnRefMemoryManager>(memoryManager), VarGlobal_EnableWinograd, VarGlobal_BlockConfigs);
}

IBackendInternal::IWorkloadFactoryPtr EthosnRefBackend::CreateWorkloadFactory(
    class TensorHandleFactoryRegistry& tensorHandleFactoryRegistry) const
{
    auto memoryManager = std::make_shared<EthosnRefMemoryManager>();

    tensorHandleFactoryRegistry.RegisterMemoryManager(memoryManager);
    tensorHandleFactoryRegistry.RegisterFactory(std::make_unique<EthosnRefTensorHandleFactory>(memoryManager));

    return std::make_unique<EthosnRefWorkloadFactory>(PolymorphicPointerDowncast<EthosnRefMemoryManager>(memoryManager), VarGlobal_EnableWinograd, VarGlobal_BlockConfigs);
}

IBackendInternal::IBackendContextPtr EthosnRefBackend::CreateBackendContext(const IRuntime::CreationOptions& creationOptions) const
{
   VarGlobal_EnableWinograd = false;
   VarGlobal_BlockConfigs = "";

   for (auto optionsGroup : creationOptions.m_BackendOptions)
   {
      if (optionsGroup.GetBackendId() == EthosnRefBackend::GetId())
      {
         for (size_t i=0; i < optionsGroup.GetOptionCount(); i++)
         {
            const BackendOptions::BackendOption option = optionsGroup.GetOption(i);

            if(option.GetName() == "EnableWinograd" && option.GetValue().IsBool() == true) {
               VarGlobal_EnableWinograd = option.GetValue().AsBool();
            }
            if(option.GetName() == "BlockConfigs" && option.GetValue().IsString() == true) {
               VarGlobal_BlockConfigs = option.GetValue().AsString();
            }
         }
      }
   }
   return IBackendContextPtr{};
}

IBackendInternal::IBackendProfilingContextPtr EthosnRefBackend::CreateBackendProfilingContext(
    const IRuntime::CreationOptions&, IBackendProfilingPtr&)
{
    return IBackendProfilingContextPtr{};
}

IBackendInternal::IMemoryManagerUniquePtr EthosnRefBackend::CreateMemoryManager() const
{
    return std::make_unique<EthosnRefMemoryManager>();
}

IBackendInternal::Optimizations EthosnRefBackend::GetOptimizations() const
{
    return Optimizations{};
}

IBackendInternal::ILayerSupportSharedPtr EthosnRefBackend::GetLayerSupport() const
{
    static ILayerSupportSharedPtr layerSupport{new EthosnRefLayerSupport};
    return layerSupport;
}

OptimizationViews EthosnRefBackend::OptimizeSubgraphView(const SubgraphView& subgraph) const
{
    OptimizationViews optimizationViews;

    optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph));

    return optimizationViews;
}

std::vector<ITensorHandleFactory::FactoryId> EthosnRefBackend::GetHandleFactoryPreferences() const
{
    return std::vector<ITensorHandleFactory::FactoryId> { EthosnRefTensorHandleFactory::GetIdStatic() };
}

void EthosnRefBackend::RegisterTensorHandleFactories(class TensorHandleFactoryRegistry& registry)
{
    auto memoryManager = std::make_shared<EthosnRefMemoryManager>();

    registry.RegisterMemoryManager(memoryManager);
    registry.RegisterFactory(std::make_unique<EthosnRefTensorHandleFactory>(memoryManager));
}

} // namespace armnn