#include <Runtime.hpp>

Inheritance diagram for RuntimeImpl:

Collaboration diagram for RuntimeImpl:

Public Member Functions
Status	LoadNetwork (NetworkId &networkIdOut, IOptimizedNetworkPtr network)
	Loads a complete network into the Runtime. More...

Status	LoadNetwork (NetworkId &networkIdOut, IOptimizedNetworkPtr network, std::string &errorMessage)
	Load a complete network into the IRuntime. More...

Status	LoadNetwork (NetworkId &networkIdOut, IOptimizedNetworkPtr network, std::string &errorMessage, const INetworkProperties &networkProperties)

armnn::TensorInfo	GetInputTensorInfo (NetworkId networkId, LayerBindingId layerId) const

armnn::TensorInfo	GetOutputTensorInfo (NetworkId networkId, LayerBindingId layerId) const

std::vector< ImportedInputId >	ImportInputs (NetworkId networkId, const InputTensors &inputTensors, MemorySource forceImportMemorySource)

std::vector< ImportedOutputId >	ImportOutputs (NetworkId networkId, const OutputTensors &outputTensors, MemorySource forceImportMemorySource)

void	ClearImportedInputs (NetworkId networkId, const std::vector< ImportedInputId > inputIds)

void	ClearImportedOutputs (NetworkId networkId, const std::vector< ImportedOutputId > outputIds)

Status	EnqueueWorkload (NetworkId networkId, const InputTensors &inputTensors, const OutputTensors &outputTensors, std::vector< ImportedInputId > preImportedInputIds={}, std::vector< ImportedOutputId > preImportedOutputIds={})

Status	Execute (IWorkingMemHandle &workingMemHandle, const InputTensors &inputTensors, const OutputTensors &outputTensors, std::vector< ImportedInputId > preImportedInputs, std::vector< ImportedOutputId > preImportedOutputs)
	This is an experimental function. More...

Status	UnloadNetwork (NetworkId networkId)
	Unloads a network from the Runtime. More...

const IDeviceSpec &	GetDeviceSpec () const

const std::shared_ptr< IProfiler >	GetProfiler (NetworkId networkId) const
	Gets the profiler corresponding to the given network id. More...

std::unique_ptr< IWorkingMemHandle >	CreateWorkingMemHandle (NetworkId networkId)
	Create a new unique WorkingMemHandle object. More...

void	RegisterDebugCallback (NetworkId networkId, const DebugCallbackFunction &func)
	Registers a callback function to debug layers performing custom computations on intermediate tensors. More...

	RuntimeImpl (const IRuntime::CreationOptions &options)
	Creates a runtime for workload execution. More...

	~RuntimeImpl ()

void	ReportStructure (arm::pipe::IProfilingService &profilingService) override

void	InitialiseProfilingService (arm::pipe::IProfilingService &profilingService) override

Friends
void	RuntimeLoadedNetworksReserve (RuntimeImpl *runtime)

arm::pipe::IProfilingService &	GetProfilingService (RuntimeImpl *runtime)

Detailed Description

Definition at line 30 of file Runtime.hpp.

Constructor & Destructor Documentation

◆ RuntimeImpl()

RuntimeImpl ( const IRuntime::CreationOptions & options )

Creates a runtime for workload execution.

Definition at line 323 of file Runtime.cpp.

     : m_NetworkIdCounter(0)
 {
     m_ProfilingService = arm::pipe::IProfilingService::CreateProfilingService(
         arm::pipe::MAX_ARMNN_COUNTER,
         *this,
         arm::pipe::ARMNN_SOFTWARE_INFO,
         arm::pipe::ARMNN_SOFTWARE_VERSION,
         arm::pipe::ARMNN_HARDWARE_VERSION,
         *this);
     const auto start_time = armnn::GetTimeNow();
     ARMNN_LOG(info) << "ArmNN v" << ARMNN_VERSION;
     if ( options.m_ProfilingOptions.m_TimelineEnabled && !options.m_ProfilingOptions.m_EnableProfiling )
     {
         throw RuntimeException(
                 "It is not possible to enable timeline reporting without profiling being enabled");
     }
 #if !defined(ARMNN_DISABLE_DYNAMIC_BACKENDS)
     // Load any available/compatible dynamic backend before the runtime
     // goes through the backend registry
     LoadDynamicBackends(options.m_DynamicBackendsPath);
 #endif
     armnn::BackendIdSet supportedBackends;
     for (const auto& id : BackendRegistryInstance().GetBackendIds())
     {
         // Store backend contexts for the supported ones
         try {
             auto factoryFun = BackendRegistryInstance().GetFactory(id);
             ARMNN_ASSERT(factoryFun != nullptr);
             auto backend = factoryFun();
             ARMNN_ASSERT(backend != nullptr);
             ARMNN_ASSERT(backend.get() != nullptr);
  
             auto customAllocatorMapIterator = options.m_CustomAllocatorMap.find(id);
             if (customAllocatorMapIterator != options.m_CustomAllocatorMap.end() &&
                 customAllocatorMapIterator->second == nullptr)
             {
 #if !defined(ARMNN_DISABLE_DYNAMIC_BACKENDS)
                 // We need to manually clean up  the dynamic backends before throwing an exception.
                 DynamicBackendUtils::DeregisterDynamicBackends(m_DeviceSpec.GetDynamicBackends());
                 m_DeviceSpec.ClearDynamicBackends();
 #endif
                 throw armnn::Exception("Allocator associated with id " + id.Get() + " is null");
             }
  
             // If the runtime is created in protected mode only add backends that support this mode
             if (options.m_ProtectedMode)
             {
                 // check if backend supports ProtectedMode
                 using BackendCapability = BackendOptions::BackendOption;
                 BackendCapability protectedContentCapability {"ProtectedContentAllocation", true};
                 if (!HasMatchingCapability(protectedContentCapability, id))
                 {
                     // Protected Content Allocation is not supported by the backend
                     // backend should not be registered
                     ARMNN_LOG(warning) << "Backend "
                                        << id
                                        << " is not registered as does not support protected content allocation.";
                     continue;
                 }
                 // The user is responsible to provide a custom memory allocator which allows to allocate
                 // protected memory
                 if (customAllocatorMapIterator != options.m_CustomAllocatorMap.end())
                 {
                     std::string err;
                     if (customAllocatorMapIterator->second->GetMemorySourceType()
                         == armnn::MemorySource::DmaBufProtected)
                     {
                         if (!backend->UseCustomMemoryAllocator(customAllocatorMapIterator->second, err))
                         {
                             ARMNN_LOG(error) << "The backend "
                                              << id
                                              << " reported an error when entering protected mode. Backend won't be"
                                              << " used. ErrorMsg: " << err;
                             continue;
                         }
                         // No errors so register the Custom Allocator with the BackendRegistry
                         BackendRegistryInstance().RegisterAllocator(id, customAllocatorMapIterator->second);
                         m_AllocatorsAddedByThisRuntime.emplace(id);
                     }
                     else
                     {
                         ARMNN_LOG(error) << "The CustomAllocator provided with the runtime options doesn't support "
                                      "protected memory. Protected mode can't be activated. The backend "
                                      << id
                                      << " is not going to be used. MemorySource must be MemorySource::DmaBufProtected";
                         continue;
                     }
                 }
                 else
                 {
                     ARMNN_LOG(error) << "Protected mode can't be activated for backend: "
                                      << id
                                      << " no custom allocator was provided to the runtime options.";
                     continue;
                 }
             }
             else
             {
                 // If a custom memory allocator is provided make the backend use that instead of the default
                 if (customAllocatorMapIterator != options.m_CustomAllocatorMap.end())
                 {
                     std::string err;
                     if (!backend->UseCustomMemoryAllocator(customAllocatorMapIterator->second, err))
                     {
                         ARMNN_LOG(error) << "The backend "
                                          << id
                                          << " reported an error when trying to use the provided custom allocator."
                                             " Backend won't be used."
                                          << " ErrorMsg: " << err;
                         continue;
                     }
                     // No errors so register the Custom Allocator with the BackendRegistry
                     BackendRegistryInstance().RegisterAllocator(id, customAllocatorMapIterator->second);
                     m_AllocatorsAddedByThisRuntime.emplace(id);
                 }
             }
  
             // check if custom memory optimizer strategy map is set
             if (!options.m_MemoryOptimizerStrategyMap.empty())
             {
                 auto customMemoryOptimizerStrategyMapIterator = options.m_MemoryOptimizerStrategyMap.find(id);
                 // if a memory optimizer strategy is provided make the backend use that instead of the default
                 if (customMemoryOptimizerStrategyMapIterator != options.m_MemoryOptimizerStrategyMap.end())
                 {
                     // no errors.. register the memory optimizer strategy with the BackendRegistry
                     BackendRegistryInstance().RegisterMemoryOptimizerStrategy(
                         id, customMemoryOptimizerStrategyMapIterator->second);
  
                     ARMNN_LOG(info) << "MemoryOptimizerStrategy  "
                                     << customMemoryOptimizerStrategyMapIterator->second->GetName()
                                     << " set for the backend " << id << ".";
                 }
             }
             else
             {
                 // check if to use one of the existing memory optimizer strategies is set
                 std::string memoryOptimizerStrategyName = "";
                 ParseOptions(options.m_BackendOptions, id, [&](std::string name, const BackendOptions::Var& value)
                 {
                     if (name == "MemoryOptimizerStrategy")
                     {
                         memoryOptimizerStrategyName = ParseStringBackendOption(value, "");
                     }
                 });
                 if (memoryOptimizerStrategyName != "")
                 {
                     std::shared_ptr<IMemoryOptimizerStrategy> strategy =
                             GetMemoryOptimizerStrategy(memoryOptimizerStrategyName);
  
                     if (!strategy)
                     {
                         ARMNN_LOG(warning) << "MemoryOptimizerStrategy: " << memoryOptimizerStrategyName
                                            << " was not found.";
                     }
                     else
                     {
                         using BackendCapability = BackendOptions::BackendOption;
                         auto strategyType = GetMemBlockStrategyTypeName(strategy->GetMemBlockStrategyType());
                         BackendCapability memOptimizeStrategyCapability {strategyType, true};
                         if (HasMatchingCapability(memOptimizeStrategyCapability, id))
                         {
                             BackendRegistryInstance().RegisterMemoryOptimizerStrategy(id, strategy);
  
                             ARMNN_LOG(info) << "MemoryOptimizerStrategy: "
                                             << memoryOptimizerStrategyName << " set for the backend " << id << ".";
                         }
                         else
                         {
                             ARMNN_LOG(warning) << "Backend "
                                                << id
                                                << " does not have multi-axis packing capability and cannot support"
                                                << "MemoryOptimizerStrategy: " << memoryOptimizerStrategyName << ".";
                         }
                     }
                 }
             }
  
             auto context = backend->CreateBackendContext(options);
  
             // backends are allowed to return nullptrs if they
             // don't wish to create a backend specific context
             if (context)
             {
                 m_BackendContexts.emplace(std::make_pair(id, std::move(context)));
             }
             supportedBackends.emplace(id);
  
             unique_ptr<arm::pipe::IBackendProfiling> profilingIface =
                 arm::pipe::IBackendProfiling::CreateBackendProfiling(
                     arm::pipe::ConvertExternalProfilingOptions(options.m_ProfilingOptions),
                     *m_ProfilingService.get(),
                     id.Get());
  
             // Backends may also provide a profiling context. Ask for it now.
             auto profilingContext = backend->CreateBackendProfilingContext(options, profilingIface);
             // Backends that don't support profiling will return a null profiling context.
             if (profilingContext)
             {
                 // Pass the context onto the profiling service.
                 m_ProfilingService->AddBackendProfilingContext(id, profilingContext);
             }
         }
         catch (const BackendUnavailableException&)
         {
             // Ignore backends which are unavailable
         }
     }
  
     BackendRegistryInstance().SetProfilingService(*m_ProfilingService.get());
     // pass configuration info to the profiling service
     m_ProfilingService->ConfigureProfilingService(
         arm::pipe::ConvertExternalProfilingOptions(options.m_ProfilingOptions));
     if (options.m_ProfilingOptions.m_EnableProfiling)
     {
         // try to wait for the profiling service to initialise
         m_ProfilingService->WaitForProfilingServiceActivation(3000);
     }
  
     m_DeviceSpec.AddSupportedBackends(supportedBackends);
  
     ARMNN_LOG(info) << "Initialization time: " << std::setprecision(2)
                     << std::fixed << armnn::GetTimeDuration(start_time).count() << " ms.";
 }

◆ ~RuntimeImpl()

~RuntimeImpl ( )

Definition at line 548 of file Runtime.cpp.

 {
     const auto startTime = armnn::GetTimeNow();
     std::vector<int> networkIDs;
     try
     {
         // Coverity fix: The following code may throw an exception of type std::length_error.
         std::transform(m_LoadedNetworks.begin(), m_LoadedNetworks.end(),
                        std::back_inserter(networkIDs),
                        [](const auto &pair) { return pair.first; });
     }
     catch (const std::exception& e)
     {
         // Coverity fix: BOOST_LOG_TRIVIAL (typically used to report errors) may throw an
         // exception of type std::length_error.
         // Using stderr instead in this context as there is no point in nesting try-catch blocks here.
         std::cerr << "WARNING: An error has occurred when getting the IDs of the networks to unload: " << e.what()
                   << "\nSome of the loaded networks may not be unloaded" << std::endl;
     }
     // We then proceed to unload all the networks which IDs have been appended to the list
     // up to the point the exception was thrown (if any).
  
     for (auto networkID : networkIDs)
     {
         try
         {
             // Coverity fix: UnloadNetwork() may throw an exception of type std::length_error,
             // boost::log::v2s_mt_posix::odr_violation or boost::log::v2s_mt_posix::system_error
             UnloadNetwork(networkID);
         }
         catch (const std::exception& e)
         {
             // Coverity fix: BOOST_LOG_TRIVIAL (typically used to report errors) may throw an
             // exception of type std::length_error.
             // Using stderr instead in this context as there is no point in nesting try-catch blocks here.
             std::cerr << "WARNING: An error has occurred when unloading network " << networkID << ": " << e.what()
                       << std::endl;
         }
     }
 #if !defined(ARMNN_DISABLE_DYNAMIC_BACKENDS)
     // Clear all dynamic backends.
     DynamicBackendUtils::DeregisterDynamicBackends(m_DeviceSpec.GetDynamicBackends());
     m_DeviceSpec.ClearDynamicBackends();
 #endif
     m_BackendContexts.clear();
  
     BackendRegistryInstance().SetProfilingService(armnn::EmptyOptional());
     // Remove custom allocators that this runtime has added.
     // Note: that as backends can be per process and there can be many instances of a runtime in a process an allocator
     // may have been overwritten by another runtime.
     for_each(m_AllocatorsAddedByThisRuntime.begin(), m_AllocatorsAddedByThisRuntime.end(),
              [](BackendId id) {BackendRegistryInstance().DeregisterAllocator(id);});
  
     ARMNN_LOG(info) << "Shutdown time: " << std::setprecision(2)
                     << std::fixed << armnn::GetTimeDuration(startTime).count() << " ms.";
 }

References ARMNN_LOG, armnn::BackendRegistryInstance(), DeviceSpec::ClearDynamicBackends(), DynamicBackendUtils::DeregisterDynamicBackends(), DeviceSpec::GetDynamicBackends(), armnn::GetTimeDuration(), armnn::GetTimeNow(), armnn::info, BackendRegistry::SetProfilingService(), and RuntimeImpl::UnloadNetwork().

Member Function Documentation

◆ ClearImportedInputs()

void ClearImportedInputs	(	NetworkId	networkId,
		const std::vector< ImportedInputId >	inputIds
	)

Definition at line 635 of file Runtime.cpp.

 {
     return GetLoadedNetworkPtr(networkId)->ClearImportedInputs(inputIds);
 }

References LoadedNetwork::ClearImportedInputs().

◆ ClearImportedOutputs()

void ClearImportedOutputs	(	NetworkId	networkId,
		const std::vector< ImportedOutputId >	outputIds
	)

Definition at line 639 of file Runtime.cpp.

 {
     return GetLoadedNetworkPtr(networkId)->ClearImportedOutputs(outputIds);
 }

References LoadedNetwork::ClearImportedOutputs().

◆ CreateWorkingMemHandle()

std::unique_ptr< IWorkingMemHandle > CreateWorkingMemHandle ( NetworkId networkId )

Create a new unique WorkingMemHandle object.

Create multiple handles if you wish to have overlapped Execution by calling this function from different threads.

Definition at line 735 of file Runtime.cpp.

 {
     LoadedNetwork* loadedNetwork = GetLoadedNetworkPtr(networkId);
  
     if (!loadedNetwork)
     {
         ARMNN_LOG(error) << "A Network with an id of " << networkId << " does not exist.";
         return nullptr;
     }
     if (!loadedNetwork->IsAsyncEnabled())
     {
         ARMNN_LOG(error) << "Network " << networkId << " is not async enabled.";
         return nullptr;
     }
     ProfilerManager::GetInstance().RegisterProfiler(loadedNetwork->GetProfiler().get());
  
     ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, "CreateWorkingMemHandle");
  
     static thread_local NetworkId lastId = networkId;
     if (lastId != networkId)
     {
         LoadedNetworkFuncSafe(lastId, [](LoadedNetwork* network)
         {
             network->FreeWorkingMemory();
         });
     }
     lastId=networkId;
  
     return loadedNetwork->CreateWorkingMemHandle(networkId);
 }

References ARMNN_LOG, ARMNN_SCOPED_PROFILING_EVENT, LoadedNetwork::CreateWorkingMemHandle(), armnn::error, LoadedNetwork::FreeWorkingMemory(), ProfilerManager::GetInstance(), LoadedNetwork::GetProfiler(), LoadedNetwork::IsAsyncEnabled(), ProfilerManager::RegisterProfiler(), and armnn::Undefined.

◆ EnqueueWorkload()

Status EnqueueWorkload	(	NetworkId	networkId,
		const InputTensors &	inputTensors,
		const OutputTensors &	outputTensors,
		std::vector< ImportedInputId >	preImportedInputIds = `{}`,
		std::vector< ImportedOutputId >	preImportedOutputIds = `{}`
	)

Definition at line 644 of file Runtime.cpp.

 {
     const auto startTime = armnn::GetTimeNow();
  
     LoadedNetwork* loadedNetwork = GetLoadedNetworkPtr(networkId);
  
     if (!loadedNetwork)
     {
         ARMNN_LOG(error) << "A Network with an id of " << networkId << " does not exist.";
         return Status::Failure;
     }
     if (loadedNetwork->IsAsyncEnabled())
     {
         ARMNN_LOG(error) << "Network " << networkId << " is async enabled.";
         return Status::Failure;
     }
     ProfilerManager::GetInstance().RegisterProfiler(loadedNetwork->GetProfiler().get());
  
     ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, "EnqueueWorkload");
  
     static thread_local NetworkId lastId = networkId;
     if (lastId != networkId)
     {
         LoadedNetworkFuncSafe(lastId, [](LoadedNetwork* network)
             {
                 network->FreeWorkingMemory();
             });
     }
     lastId=networkId;
  
     auto status = loadedNetwork->EnqueueWorkload(inputTensors, outputTensors,
                                                  preImportedInputIds, preImportedOutputIds);
  
  
     // Check if we imported, if not there's no need to call the After EnqueueWorkload events
     if (!preImportedInputIds.empty() || !preImportedOutputIds.empty())
     {
         // Call After EnqueueWorkload events
         for (auto&& context : m_BackendContexts)
         {
             context.second->AfterEnqueueWorkload(networkId);
         }
     }
     ARMNN_LOG(info) << "Execution time: " << std::setprecision(2)
                     << std::fixed << armnn::GetTimeDuration(startTime).count() << " ms.";
     return status;
 }

References ARMNN_LOG, ARMNN_SCOPED_PROFILING_EVENT, LoadedNetwork::EnqueueWorkload(), armnn::error, armnn::Failure, LoadedNetwork::FreeWorkingMemory(), ProfilerManager::GetInstance(), LoadedNetwork::GetProfiler(), armnn::GetTimeDuration(), armnn::GetTimeNow(), armnn::info, LoadedNetwork::IsAsyncEnabled(), ProfilerManager::RegisterProfiler(), and armnn::Undefined.

◆ Execute()

Status Execute	(	IWorkingMemHandle &	workingMemHandle,
		const InputTensors &	inputTensors,
		const OutputTensors &	outputTensors,
		std::vector< ImportedInputId >	preImportedInputs,
		std::vector< ImportedOutputId >	preImportedOutputs
	)

This is an experimental function.

Evaluates a network using input in inputTensors and outputs filled into outputTensors. This function performs a thread safe execution of the network. Returns once execution is complete. Will block until this and any other thread using the same workingMem object completes.

Definition at line 696 of file Runtime.cpp.

 {
     const auto startTime = armnn::GetTimeNow();
  
     NetworkId networkId = iWorkingMemHandle.GetNetworkId();
     LoadedNetwork* loadedNetwork = GetLoadedNetworkPtr(networkId);
  
     if (!loadedNetwork)
     {
         ARMNN_LOG(error) << "A Network with an id of " << networkId << " does not exist.";
         return Status::Failure;
     }
     if (!loadedNetwork->IsAsyncEnabled())
     {
         ARMNN_LOG(error) << "Attempting execute " << networkId << " when it is not async enabled.";
         return Status::Failure;
     }
     ProfilerManager::GetInstance().RegisterProfiler(loadedNetwork->GetProfiler().get());
  
     ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, "Execute");
  
     auto status = loadedNetwork->Execute(inputTensors,
                                          outputTensors,
                                          iWorkingMemHandle,
                                          preImportedInputs,
                                          preImportedOutputs);
  
     ARMNN_LOG(info) << "Execution time: " << std::setprecision(2)
                     << std::fixed << armnn::GetTimeDuration(startTime).count() << " ms.";
  
     return status;
 }

References ARMNN_LOG, ARMNN_SCOPED_PROFILING_EVENT, armnn::error, LoadedNetwork::Execute(), armnn::Failure, ProfilerManager::GetInstance(), IWorkingMemHandle::GetNetworkId(), LoadedNetwork::GetProfiler(), armnn::GetTimeDuration(), armnn::GetTimeNow(), armnn::info, LoadedNetwork::IsAsyncEnabled(), ProfilerManager::RegisterProfiler(), and armnn::Undefined.

◆ GetDeviceSpec()

const IDeviceSpec& GetDeviceSpec ( ) const

inline

Definition at line 90 of file Runtime.hpp.

90 { return m_DeviceSpec; }

◆ GetInputTensorInfo()

TensorInfo GetInputTensorInfo	(	NetworkId	networkId,
		LayerBindingId	layerId
	)		const

Definition at line 613 of file Runtime.cpp.

 {
     return GetLoadedNetworkPtr(networkId)->GetInputTensorInfo(layerId);
 }

References LoadedNetwork::GetInputTensorInfo().

◆ GetOutputTensorInfo()

TensorInfo GetOutputTensorInfo	(	NetworkId	networkId,
		LayerBindingId	layerId
	)		const

Definition at line 618 of file Runtime.cpp.

 {
     return GetLoadedNetworkPtr(networkId)->GetOutputTensorInfo(layerId);
 }

References LoadedNetwork::GetOutputTensorInfo().

◆ GetProfiler()

const std::shared_ptr< IProfiler > GetProfiler ( NetworkId networkId ) const

Gets the profiler corresponding to the given network id.

Parameters

networkId The id of the network for which to get the profile.

Returns: A pointer to the requested profiler, or nullptr if not found.

Definition at line 290 of file Runtime.cpp.

 {
     auto it = m_LoadedNetworks.find(networkId);
     if (it != m_LoadedNetworks.end())
     {
         auto& loadedNetwork = it->second;
         return loadedNetwork->GetProfiler();
     }
  
     return nullptr;
 }

◆ ImportInputs()

std::vector< ImportedInputId > ImportInputs	(	NetworkId	networkId,
		const InputTensors &	inputTensors,
		MemorySource	forceImportMemorySource
	)

Definition at line 623 of file Runtime.cpp.

 {
     return GetLoadedNetworkPtr(networkId)->ImportInputs(inputTensors, forceImportMemorySource);
 }

References LoadedNetwork::ImportInputs().

◆ ImportOutputs()

std::vector< ImportedOutputId > ImportOutputs	(	NetworkId	networkId,
		const OutputTensors &	outputTensors,
		MemorySource	forceImportMemorySource
	)

Definition at line 629 of file Runtime.cpp.

 {
     return GetLoadedNetworkPtr(networkId)->ImportOutputs(outputTensors, forceImportMemorySource);
 }

References LoadedNetwork::ImportOutputs().

◆ InitialiseProfilingService()

void InitialiseProfilingService ( arm::pipe::IProfilingService & profilingService )

override

Definition at line 317 of file Runtime.cpp.

 {
     ArmNNProfilingServiceInitialiser initialiser;
     initialiser.InitialiseProfilingService(profilingService);
 }

References ArmNNProfilingServiceInitialiser::InitialiseProfilingService().

◆ LoadNetwork() [1/3]

Status LoadNetwork	(	NetworkId &	networkIdOut,
		IOptimizedNetworkPtr	network
	)

Loads a complete network into the Runtime.

Parameters

[out]	networkIdOut	- Unique identifier for the network is returned in this reference.
[in]	network	- Complete network to load into the Runtime. The runtime takes ownership of the network once passed in.

Returns: armnn::Status

Definition at line 166 of file Runtime.cpp.

 {
     std::string ignoredErrorMessage;
     return LoadNetwork(networkIdOut, std::move(inNetwork), ignoredErrorMessage);
 }

Referenced by RuntimeImpl::LoadNetwork().

◆ LoadNetwork() [2/3]

Status LoadNetwork	(	NetworkId &	networkIdOut,
		IOptimizedNetworkPtr	network,
		std::string &	errorMessage
	)

Load a complete network into the IRuntime.

Parameters

[out]	networkIdOut	Unique identifier for the network is returned in this reference.
[in]	network	Complete network to load into the IRuntime.
[out]	errorMessage	Error message if there were any errors. The runtime takes ownership of the network once passed in.

Returns: armnn::Status

Definition at line 172 of file Runtime.cpp.

 {
     INetworkProperties networkProperties(
             false, MemorySource::Undefined, MemorySource::Undefined);
     return LoadNetwork(networkIdOut, std::move(inNetwork), errorMessage, networkProperties);
 }

References RuntimeImpl::LoadNetwork(), and armnn::Undefined.

◆ LoadNetwork() [3/3]

Status LoadNetwork	(	NetworkId &	networkIdOut,
		IOptimizedNetworkPtr	network,
		std::string &	errorMessage,
		const INetworkProperties &	networkProperties
	)

Definition at line 181 of file Runtime.cpp.

 {
     // Register the profiler
     auto profiler = inNetwork->GetProfiler();
     ProfilerManager::GetInstance().RegisterProfiler(profiler.get());
  
     IOptimizedNetwork* rawNetwork = inNetwork.release();
  
     networkIdOut = GenerateNetworkId();
  
     for (auto&& context : m_BackendContexts)
     {
         context.second->BeforeLoadNetwork(networkIdOut);
     }
  
     unique_ptr<LoadedNetwork> loadedNetwork = LoadedNetwork::MakeLoadedNetwork(
         std::unique_ptr<IOptimizedNetwork>(rawNetwork),
         errorMessage,
         networkProperties,
         m_ProfilingService.get());
  
     if (!loadedNetwork)
     {
         return Status::Failure;
     }
  
     {
 #if !defined(ARMNN_DISABLE_THREADS)
         std::lock_guard<std::mutex> lockGuard(m_Mutex);
 #endif
  
         // Stores the network
         m_LoadedNetworks[networkIdOut] = std::move(loadedNetwork);
     }
  
     for (auto&& context : m_BackendContexts)
     {
         context.second->AfterLoadNetwork(networkIdOut);
     }
  
     if (m_ProfilingService->IsProfilingEnabled())
     {
         m_ProfilingService->IncrementCounterValue(arm::pipe::NETWORK_LOADS);
     }
  
     return Status::Success;
 }

References armnn::Failure, ProfilerManager::GetInstance(), LoadedNetwork::MakeLoadedNetwork(), ProfilerManager::RegisterProfiler(), and armnn::Success.

◆ RegisterDebugCallback()

void RegisterDebugCallback	(	NetworkId	networkId,
		const DebugCallbackFunction &	func
	)

Registers a callback function to debug layers performing custom computations on intermediate tensors.

Parameters

networkId	The id of the network to register the callback.
func	callback function to pass to the debug layer.

Definition at line 766 of file Runtime.cpp.

 {
     LoadedNetwork* loadedNetwork = GetLoadedNetworkPtr(networkId);
     loadedNetwork->RegisterDebugCallback(func);
 }

References LoadedNetwork::RegisterDebugCallback().

◆ ReportStructure()

void ReportStructure ( arm::pipe::IProfilingService & profilingService )

override

Definition at line 302 of file Runtime.cpp.

 {
     if (profilingService.IsProfilingEnabled())
     {
         LoadedNetworks::iterator it = m_LoadedNetworks.begin();
         while (it != m_LoadedNetworks.end())
         {
             auto& loadedNetwork = it->second;
             loadedNetwork->SendNetworkStructure(profilingService);
             // Increment the Iterator to point to next entry
             it++;
         }
     }
 }

◆ UnloadNetwork()

Status UnloadNetwork ( NetworkId networkId )

Unloads a network from the Runtime.

At the moment this only removes the network from the m_Impl->m_Network. This might need more work in the future to be AndroidNN compliant.

Parameters

[in] networkId Unique identifier for the network to be unloaded. Generated in LoadNetwork().

Returns: armnn::Status

Definition at line 232 of file Runtime.cpp.

 {
     bool unloadOk = true;
     for (auto&& context : m_BackendContexts)
     {
         unloadOk &= context.second->BeforeUnloadNetwork(networkId);
     }
  
     if (!unloadOk)
     {
         ARMNN_LOG(warning) << "RuntimeImpl::UnloadNetwork(): failed to unload "
                               "network with ID:" << networkId << " because BeforeUnloadNetwork failed";
         return Status::Failure;
     }
  
     std::unique_ptr<arm::pipe::TimelineUtilityMethods> timelineUtils =
         arm::pipe::TimelineUtilityMethods::GetTimelineUtils(*m_ProfilingService.get());
     {
 #if !defined(ARMNN_DISABLE_THREADS)
         std::lock_guard<std::mutex> lockGuard(m_Mutex);
 #endif
  
         // If timeline recording is on mark the Network end of life
         if (timelineUtils)
         {
             auto search = m_LoadedNetworks.find(networkId);
             if (search != m_LoadedNetworks.end())
             {
                 arm::pipe::ProfilingGuid networkGuid = search->second->GetNetworkGuid();
                 timelineUtils->RecordEvent(networkGuid,
                                            arm::pipe::LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS);
             }
         }
  
         if (m_LoadedNetworks.erase(networkId) == 0)
         {
             ARMNN_LOG(warning) << "WARNING: RuntimeImpl::UnloadNetwork(): " << networkId << " not found!";
             return Status::Failure;
         }
  
         if (m_ProfilingService->IsProfilingEnabled())
         {
             m_ProfilingService->IncrementCounterValue(arm::pipe::NETWORK_UNLOADS);
         }
     }
  
     for (auto&& context : m_BackendContexts)
     {
         context.second->AfterUnloadNetwork(networkId);
     }
  
     // Unregister the profiler
     ProfilerManager::GetInstance().RegisterProfiler(nullptr);
  
     ARMNN_LOG(debug) << "RuntimeImpl::UnloadNetwork(): Unloaded network with ID: " << networkId;
     return Status::Success;
 }

References ARMNN_LOG, armnn::debug, armnn::Failure, ProfilerManager::GetInstance(), ProfilerManager::RegisterProfiler(), armnn::Success, and armnn::warning.

Referenced by RuntimeImpl::~RuntimeImpl().

Friends And Related Function Documentation

◆ GetProfilingService

arm::pipe::IProfilingService& GetProfilingService ( RuntimeImpl * runtime )

friend

Definition at line 59 of file TestUtils.cpp.

 {
     return *(runtime->m_ProfilingService.get());
 }

◆ RuntimeLoadedNetworksReserve

void RuntimeLoadedNetworksReserve ( RuntimeImpl * runtime )

friend

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

src/armnn/Runtime.hpp
src/armnn/Runtime.cpp

Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ RuntimeImpl()

◆ ~RuntimeImpl()

Member Function Documentation

◆ ClearImportedInputs()

◆ ClearImportedOutputs()

◆ CreateWorkingMemHandle()

◆ EnqueueWorkload()

◆ Execute()

◆ GetDeviceSpec()

◆ GetInputTensorInfo()

◆ GetOutputTensorInfo()

◆ GetProfiler()

◆ ImportInputs()

◆ ImportOutputs()

◆ InitialiseProfilingService()

◆ LoadNetwork() [1/3]

◆ LoadNetwork() [2/3]

◆ LoadNetwork() [3/3]

◆ RegisterDebugCallback()

◆ ReportStructure()

◆ UnloadNetwork()

Friends And Related Function Documentation

◆ GetProfilingService

◆ RuntimeLoadedNetworksReserve