+ +

#include <LoadedNetwork.hpp>

+ + + + +

+Public Types
using	WorkloadQueue = std::vector< std::unique_ptr< IWorkload > >

+ + + + + + + + + + + + + + + +

+Public Member Functions
	~LoadedNetwork ()

TensorInfo	GetInputTensorInfo (LayerBindingId layerId) const

TensorInfo	GetOutputTensorInfo (LayerBindingId layerId) const

Status	EnqueueWorkload (const InputTensors &inputTensors, const OutputTensors &outputTensors)

const std::shared_ptr< Profiler > &	GetProfiler () const

void	FreeWorkingMemory ()

void	RegisterDebugCallback (const DebugCallbackFunction &func)

+ + + +

+Static Public Member Functions
static std::unique_ptr< LoadedNetwork >	MakeLoadedNetwork (std::unique_ptr< OptimizedNetwork > net, std::string &errorMessage, const INetworkProperties &networkProperties)

+

Detailed Description

+

Definition at line 33 of file LoadedNetwork.hpp.

+

Member Typedef Documentation

+ +

◆ WorkloadQueue

+ +

+

+ + + + +

using WorkloadQueue = std::vector< std::unique_ptr<IWorkload> >

+

+ +

Definition at line 36 of file LoadedNetwork.hpp.

+ +

+

Constructor & Destructor Documentation

+ +

◆ ~LoadedNetwork()

+ +

+

+ + + + + +

+ + + + + + + +

~LoadedNetwork ( )

+

+inline

+

+ +

Definition at line 37 of file LoadedNetwork.hpp.

+ +

References armnn::GetInputTensorInfo().

+

37 { FreeWorkingMemory(); }

armnn::LoadedNetwork::FreeWorkingMemory

void FreeWorkingMemory()

Definition: LoadedNetwork.cpp:660

+

Member Function Documentation

+ +

◆ EnqueueWorkload()

+ +

+

+ + + + + + + + + + + + + + + + + + +

Status EnqueueWorkload	(	const InputTensors &	inputTensors,
		const OutputTensors &	outputTensors
	)

+

+ +

Definition at line 412 of file LoadedNetwork.cpp.

+ +

References ARMNN_LOG, LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS, LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS, ARMNN_SCOPED_HEAP_PROFILING, ARMNN_SCOPED_PROFILING_EVENT, armnn::CheckFlag(), armnn::Failure, ITensorHandle::GetImportFlags(), Graph::GetInputLayers(), Layer::GetInputSlots(), Graph::GetNumInputs(), Layer::GetNumInputSlots(), Graph::GetNumLayers(), Graph::GetNumOutputs(), Layer::GetNumOutputSlots(), Layer::GetOutputHandler(), Graph::GetOutputLayers(), TimelineUtilityMethods::GetTimelineUtils(), Layer::GetType(), ITensorHandle::Import(), ProfilingService::IncrementCounterValue(), LabelsAndEventClasses::INFERENCE_GUID, armnn::info, armnn::Input, ProfilingService::Instance(), QueueDescriptor::m_Inputs, WorkloadInfo::m_InputTensorInfos, QueueDescriptor::m_Outputs, WorkloadInfo::m_OutputTensorInfos, armnn::Malloc, ITensorHandle::Map(), ProfilingService::NextGuid(), armnn::Output, armnn::profiling::RetentionLink, armnn::Success, armnn::Undefined, ITensorHandle::Unmap(), and armnn::warning.

+ +

Referenced by Runtime::EnqueueWorkload().

+

 {
     ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, "EnqueueWorkload");
 
     const Graph& graph = m_OptimizedNetwork->GetGraph();
 
     // Walk graph to determine the order of execution.
     if (graph.GetNumLayers() < 2)
     {
         ARMNN_LOG(warning) << "IRuntime::EnqueueWorkload()::Less than two nodes in graph";
         return Status::Failure;
     }
 
     // Data that must be kept alive for the entire execution of the workload.
     WorkloadData workloadData(inputTensors, outputTensors);
 
     if (graph.GetNumInputs() != inputTensors.size())
     {
         throw InvalidArgumentException("Number of inputs provided does not match network.");
     }
 
     // For each input to the network, call EnqueueInput with the data passed by the user.
     m_InputQueue.clear();
     m_InputQueue.reserve(graph.GetNumInputs());
     for (const BindableLayer* inputLayer : graph.GetInputLayers())
     {
         const TensorPin& pin = workloadData.GetInputTensorPin(inputLayer->GetBindingId());
         EnqueueInput(*inputLayer, pin.GetTensorHandle(), pin.GetTensorInfo());
     }
 
     // For each output to the network, call EnqueueOutput with the data passed by the user.
     m_OutputQueue.clear();
     m_OutputQueue.reserve(graph.GetNumOutputs());
     for (const BindableLayer* outputLayer : graph.GetOutputLayers())
     {
         const TensorPin& pin = workloadData.GetOutputTensorPin(outputLayer->GetBindingId());
         EnqueueOutput(*outputLayer, pin.GetTensorHandle(), pin.GetTensorInfo());
     }
 
     std::unique_ptr<TimelineUtilityMethods> timelineUtils = TimelineUtilityMethods::GetTimelineUtils();
     ProfilingGuid inferenceGuid = ProfilingService::Instance().NextGuid();
     if (timelineUtils)
     {
         // Add inference timeline trace if profiling is enabled.
         ProfilingGuid networkGuid = m_OptimizedNetwork->GetGuid();
         timelineUtils->CreateTypedEntity(inferenceGuid, LabelsAndEventClasses::INFERENCE_GUID);
         timelineUtils->CreateRelationship(ProfilingRelationshipType::RetentionLink, networkGuid, inferenceGuid);
         timelineUtils->RecordEvent(inferenceGuid, LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS);
     }
 
     bool executionSucceeded = true;
 
     {
         if (profiling::ProfilingService::Instance().IsProfilingEnabled())
         {
             profiling::ProfilingService::Instance().IncrementCounterValue(armnn::profiling::INFERENCES_RUN);
         }
         ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, "Execute");
         ARMNN_SCOPED_HEAP_PROFILING("Executing");
         executionSucceeded = Execute(timelineUtils, inferenceGuid);
     }
 
     if (timelineUtils)
     {
         // Add end of life of the inference timeline if profiling is enabled.
         timelineUtils->RecordEvent(inferenceGuid, LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS);
         timelineUtils->Commit();
     }
     return executionSucceeded ? Status::Success : Status::Failure;
 }

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+

+ +

◆ FreeWorkingMemory()

+ +

+

+ + + + + + + +

void FreeWorkingMemory ( )

+

+ +

Definition at line 660 of file LoadedNetwork.cpp.

+ +

References ARMNN_LOG, and armnn::error.

+ +

Referenced by Runtime::EnqueueWorkload().

+

 {
     std::lock_guard<std::mutex> lockGuard(m_WorkingMemMutex);
     if (!m_IsWorkingMemAllocated)
     {
         return;
     }
     // Informs the memory managers to release memory in it's respective memory group
     for (auto&& workloadFactory : m_WorkloadFactories)
     {
         IBackendInternal::IMemoryManagerSharedPtr memoryManager = workloadFactory.second.second;
         if (memoryManager)
         {
             memoryManager->Release();
         }
     }
     m_TensorHandleFactoryRegistry.ReleaseMemory();
     m_IsWorkingMemAllocated = false;
 }

+
+

+

+ +

◆ GetInputTensorInfo()

+ +

+

+ + + + + + + + +

TensorInfo GetInputTensorInfo ( LayerBindingId layerId ) const

+

+ +

Definition at line 263 of file LoadedNetwork.cpp.

+ +

Referenced by Runtime::GetInputTensorInfo().

+

 {
     for (auto&& inputLayer : m_OptimizedNetwork->GetGraph().GetInputLayers())
     {
         BOOST_ASSERT_MSG(inputLayer->GetNumOutputSlots() == 1, "Input layer should have exactly 1 output slot");
         if (inputLayer->GetBindingId() == layerId)
         {
             return inputLayer->GetOutputSlot(0).GetTensorInfo();
         }
     }
 
     throw InvalidArgumentException(boost::str(boost::format("No input layer is associated with id %1%") % layerId));
 }

+

+ +

◆ GetOutputTensorInfo()

+ +

+

+ + + + + + + + +

TensorInfo GetOutputTensorInfo ( LayerBindingId layerId ) const

+

+ +

Definition at line 277 of file LoadedNetwork.cpp.

+ +

References CHECK_LOCATION, BackendId::Get(), Layer::GetBackendId(), Layer::GetNameStr(), armnn::IgnoreUnused(), armnn::info, and IWorkloadFactory::IsLayerSupported().

+ +

Referenced by Runtime::GetOutputTensorInfo().

+

 {
     for (auto&& outputLayer : m_OptimizedNetwork->GetGraph().GetOutputLayers())
     {
         BOOST_ASSERT_MSG(outputLayer->GetNumInputSlots() == 1, "Output layer should have exactly 1 input slot");
         BOOST_ASSERT_MSG(outputLayer->GetInputSlot(0).GetConnection(), "Input slot on Output layer must be connected");
         if (outputLayer->GetBindingId() == layerId)
         {
             return outputLayer->GetInputSlot(0).GetConnection()->GetTensorInfo();
         }
     }
 
     throw InvalidArgumentException(boost::str(boost::format("No output layer is associated with id %1%") % layerId));
 }

+

+ +

◆ GetProfiler()

+ +

+

+ + + + + +

+ + + + + + + +

const std::shared_ptr<Profiler>& GetProfiler ( ) const

+

+inline

+

+ +

Definition at line 51 of file LoadedNetwork.hpp.

+

51 { return m_Profiler; }

+

+ +

◆ MakeLoadedNetwork()

+ +

+

+ + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + +

std::unique_ptr< LoadedNetwork > MakeLoadedNetwork	(	std::unique_ptr< OptimizedNetwork >	net,
		std::string &	errorMessage,
		const INetworkProperties &	networkProperties
	)

+

+static

+

+ +

Definition at line 85 of file LoadedNetwork.cpp.

+ +

References ARMNN_LOG, armnn::BackendRegistryInstance(), IBackendInternal::CreateMemoryManager(), IBackendInternal::CreateWorkloadFactory(), armnn::error, BackendRegistry::GetFactory(), ProfilerManager::GetInstance(), TimelineUtilityMethods::GetTimelineUtils(), armnn::Input, INetworkProperties::m_ExportEnabled, INetworkProperties::m_ImportEnabled, LabelsAndEventClasses::NETWORK_GUID, armnn::Output, ProfilerManager::RegisterProfiler(), IBackendInternal::RegisterTensorHandleFactories(), IBackendInternal::SupportsTensorAllocatorAPI(), and Graph::TopologicalSort().

+ +

Referenced by Runtime::LoadNetwork().

+

 {
     std::unique_ptr<LoadedNetwork> loadedNetwork;
 
     auto Fail = [&](const std::exception& error) -> std::unique_ptr<LoadedNetwork>
     {
         errorMessage = ToErrorMessage("An error occurred when preparing the network workloads: ", error);
         ARMNN_LOG(error) << errorMessage;
 
         return std::unique_ptr<LoadedNetwork>();
     };
 
     try
     {
         loadedNetwork.reset(new LoadedNetwork(std::move(net), networkProperties));
     }
     catch (const armnn::RuntimeException& error)
     {
         return Fail(error);
     }
     catch (const armnn::Exception& error)
     {
         return Fail(error);
     }
     catch (const std::runtime_error& error)
     {
         return Fail(error);
     }
 
     return loadedNetwork;
 }

+
+
+
+

+

+ +

◆ RegisterDebugCallback()

+ +

+

+ + + + + + + + +

void RegisterDebugCallback ( const DebugCallbackFunction & func )

+

+ +

Definition at line 750 of file LoadedNetwork.cpp.

+ +

Referenced by Runtime::RegisterDebugCallback().

+

 {
     for (auto&& workloadPtr: m_WorkloadQueue)
     {
         workloadPtr.get()->RegisterDebugCallback(func);
     }
 }

+

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

src/armnn/LoadedNetwork.hpp
src/armnn/LoadedNetwork.cpp

+

+Public Types

+Public Member Functions

+Static Public Member Functions

Detailed Description

Member Typedef Documentation

◆ WorkloadQueue

Constructor & Destructor Documentation

◆ ~LoadedNetwork()

Member Function Documentation

◆ EnqueueWorkload()

◆ FreeWorkingMemory()

◆ GetInputTensorInfo()

◆ GetOutputTensorInfo()

◆ GetProfiler()

◆ MakeLoadedNetwork()

◆ RegisterDebugCallback()