ProfilingService Class Reference

#include <ProfilingService.hpp>

Inheritance diagram for ProfilingService:

Public Types
using	ExternalProfilingOptions = IRuntime::CreationOptions::ExternalProfilingOptions
using	IProfilingConnectionFactoryPtr = std::unique_ptr< IProfilingConnectionFactory >
using	IProfilingConnectionPtr = std::unique_ptr< IProfilingConnection >
using	CounterIndices = std::vector< std::atomic< uint32_t > * >
using	CounterValues = std::list< std::atomic< uint32_t > >
using	BackendProfilingContext = std::unordered_map< BackendId, std::shared_ptr< armnn::profiling::IBackendProfilingContext > >

Public Member Functions
	ProfilingService (Optional< IReportStructure &> reportStructure=EmptyOptional())
	~ProfilingService ()
void	ResetExternalProfilingOptions (const ExternalProfilingOptions &options, bool resetProfilingService=false)
ProfilingState	ConfigureProfilingService (const ExternalProfilingOptions &options, bool resetProfilingService=false)
void	Update ()
void	Disconnect ()
void	AddBackendProfilingContext (const BackendId backendId, std::shared_ptr< armnn::profiling::IBackendProfilingContext > profilingContext)
void	NotifyBackendsForTimelineReporting () override
const ICounterDirectory &	GetCounterDirectory () const
ICounterRegistry &	GetCounterRegistry ()
ProfilingState	GetCurrentState () const
bool	IsCounterRegistered (uint16_t counterUid) const override
uint32_t	GetAbsoluteCounterValue (uint16_t counterUid) const override
uint32_t	GetDeltaCounterValue (uint16_t counterUid) override
uint16_t	GetCounterCount () const override
const ICounterMappings &	GetCounterMappings () const override
IRegisterCounterMapping &	GetCounterMappingRegistry ()
bool	IsProfilingEnabled () const override
CaptureData	GetCaptureData () override
void	SetCaptureData (uint32_t capturePeriod, const std::vector< uint16_t > &counterIds, const std::set< BackendId > &activeBackends)
void	SetCounterValue (uint16_t counterUid, uint32_t value) override
uint32_t	AddCounterValue (uint16_t counterUid, uint32_t value) override
uint32_t	SubtractCounterValue (uint16_t counterUid, uint32_t value) override
uint32_t	IncrementCounterValue (uint16_t counterUid) override
ProfilingDynamicGuid	NextGuid () override
	Return the next random Guid in the sequence. More...
ProfilingStaticGuid	GenerateStaticId (const std::string &str) override
	Create a ProfilingStaticGuid based on a hash of the string. More...
std::unique_ptr< ISendTimelinePacket >	GetSendTimelinePacket () const override
ISendCounterPacket &	GetSendCounterPacket () override
void	ResetGuidGenerator ()
bool	IsTimelineReportingEnabled ()
void	AddLocalPacketHandler (ILocalPacketHandlerSharedPtr localPacketHandler)
void	NotifyProfilingServiceActive () override
void	WaitForProfilingServiceActivation (unsigned int timeout) override
Public Member Functions inherited from IReadWriteCounterValues
virtual	~IReadWriteCounterValues ()
Public Member Functions inherited from IReadCounterValues
virtual	~IReadCounterValues ()
Public Member Functions inherited from IWriteCounterValues
virtual	~IWriteCounterValues ()
Public Member Functions inherited from IProfilingService
virtual	~IProfilingService ()
Public Member Functions inherited from IProfilingServiceStatus
virtual	~IProfilingServiceStatus ()
Public Member Functions inherited from INotifyBackends
virtual	~INotifyBackends ()

Static Public Member Functions
static ProfilingDynamicGuid	GetNextGuid ()
static ProfilingStaticGuid	GetStaticId (const std::string &str)

Protected Member Functions
void	SwapProfilingConnectionFactory (ProfilingService &instance, IProfilingConnectionFactory *other, IProfilingConnectionFactory *&backup)
IProfilingConnection *	GetProfilingConnection (ProfilingService &instance)
void	TransitionToState (ProfilingService &instance, ProfilingState newState)
bool	WaitForPacketSent (ProfilingService &instance, uint32_t timeout=1000)
BufferManager &	GetBufferManager (ProfilingService &instance)

Detailed Description

Definition at line 50 of file ProfilingService.hpp.

Member Typedef Documentation

BackendProfilingContext

using BackendProfilingContext = std::unordered_map<BackendId, std::shared_ptr<armnn::profiling::IBackendProfilingContext> >

Definition at line 59 of file ProfilingService.hpp.

CounterIndices

using CounterIndices = std::vector<std::atomic<uint32_t>*>

Definition at line 56 of file ProfilingService.hpp.

CounterValues

using CounterValues = std::list<std::atomic<uint32_t> >

Definition at line 57 of file ProfilingService.hpp.

ExternalProfilingOptions

using ExternalProfilingOptions = IRuntime::CreationOptions::ExternalProfilingOptions

Definition at line 53 of file ProfilingService.hpp.

IProfilingConnectionFactoryPtr

using IProfilingConnectionFactoryPtr = std::unique_ptr<IProfilingConnectionFactory>

Definition at line 54 of file ProfilingService.hpp.

IProfilingConnectionPtr

using IProfilingConnectionPtr = std::unique_ptr<IProfilingConnection>

Definition at line 55 of file ProfilingService.hpp.

Constructor & Destructor Documentation

ProfilingService()

ProfilingService ( Optional< IReportStructure &>  reportStructure = EmptyOptional() )

inline

Definition at line 61 of file ProfilingService.hpp.

References ProfilingService::AddBackendProfilingContext(), ProfilingService::AddCounterValue(), ProfilingService::ConfigureProfilingService(), ProfilingService::Disconnect(), ProfilingService::GenerateStaticId(), ProfilingService::GetAbsoluteCounterValue(), ProfilingService::GetCaptureData(), ProfilingService::GetCounterCount(), ProfilingService::GetCounterDirectory(), ProfilingService::GetCounterMappingRegistry(), ProfilingService::GetCounterMappings(), ProfilingService::GetCounterRegistry(), ProfilingService::GetCurrentState(), ProfilingService::GetDeltaCounterValue(), ProfilingService::GetSendTimelinePacket(), ProfilingService::IncrementCounterValue(), ProfilingService::IsCounterRegistered(), ProfilingService::IsProfilingEnabled(), ProfilingService::NextGuid(), ProfilingService::NotifyBackendsForTimelineReporting(), ProfilingService::ResetExternalProfilingOptions(), ProfilingService::SetCaptureData(), ProfilingService::SetCounterValue(), ProfilingService::SubtractCounterValue(), ProfilingService::Update(), and ProfilingService::~ProfilingService().

Referenced by ProfilingService::IsTimelineReportingEnabled().

        : m_Options()
        , m_TimelineReporting(false)
        , m_CounterDirectory()
        , m_ProfilingConnectionFactory(new ProfilingConnectionFactory())
        , m_ProfilingConnection()
        , m_StateMachine()
        , m_CounterIndex()
        , m_CounterValues()
        , m_CommandHandlerRegistry()
        , m_PacketVersionResolver()
        , m_CommandHandler(1000,
                           false,
                           m_CommandHandlerRegistry,
                           m_PacketVersionResolver)
        , m_BufferManager()
        , m_SendCounterPacket(m_BufferManager)
        , m_SendThread(m_StateMachine, m_BufferManager, m_SendCounterPacket)
        , m_SendTimelinePacket(m_BufferManager)
        , m_PeriodicCounterCapture(m_Holder, m_SendCounterPacket, *this, m_CounterIdMap, m_BackendProfilingContexts)
        , m_ConnectionAcknowledgedCommandHandler(0,
                                                 1,
                                                 m_PacketVersionResolver.ResolvePacketVersion(0, 1).GetEncodedValue(),
                                                 m_CounterDirectory,
                                                 m_SendCounterPacket,
                                                 m_SendTimelinePacket,
                                                 m_StateMachine,
                                                 *this,
                                                 m_BackendProfilingContexts)
        , m_RequestCounterDirectoryCommandHandler(0,
                                                  3,
                                                  m_PacketVersionResolver.ResolvePacketVersion(0, 3).GetEncodedValue(),
                                                  m_CounterDirectory,
                                                  m_SendCounterPacket,
                                                  m_SendTimelinePacket,
                                                  m_StateMachine)
        , m_PeriodicCounterSelectionCommandHandler(0,
                                                   4,
                                                   m_PacketVersionResolver.ResolvePacketVersion(0, 4).GetEncodedValue(),
                                                   m_BackendProfilingContexts,
                                                   m_CounterIdMap,
                                                   m_Holder,
                                                   MAX_ARMNN_COUNTER,
                                                   m_PeriodicCounterCapture,
                                                   *this,
                                                   m_SendCounterPacket,
                                                   m_StateMachine)
        , m_PerJobCounterSelectionCommandHandler(0,
                                                 5,
                                                 m_PacketVersionResolver.ResolvePacketVersion(0, 5).GetEncodedValue(),
                                                 m_StateMachine)
        , m_ActivateTimelineReportingCommandHandler(0,
                                                    6,
                                                    m_PacketVersionResolver.ResolvePacketVersion(0, 6)
                                                                           .GetEncodedValue(),
                                                    m_SendTimelinePacket,
                                                    m_StateMachine,
                                                    reportStructure,
                                                    m_TimelineReporting,
                                                    *this)
        , m_DeactivateTimelineReportingCommandHandler(0,
                                                      7,
                                                      m_PacketVersionResolver.ResolvePacketVersion(0, 7)
                                                                             .GetEncodedValue(),
                                                      m_TimelineReporting,
                                                      m_StateMachine,
                                                      *this)
        , m_TimelinePacketWriterFactory(m_BufferManager)
        , m_MaxGlobalCounterId(armnn::profiling::INFERENCES_RUN)
        , m_ServiceActive(false)
    {
        // Register the "Connection Acknowledged" command handler
        m_CommandHandlerRegistry.RegisterFunctor(&m_ConnectionAcknowledgedCommandHandler);

        // Register the "Request Counter Directory" command handler
        m_CommandHandlerRegistry.RegisterFunctor(&m_RequestCounterDirectoryCommandHandler);

        // Register the "Periodic Counter Selection" command handler
        m_CommandHandlerRegistry.RegisterFunctor(&m_PeriodicCounterSelectionCommandHandler);

        // Register the "Per-Job Counter Selection" command handler
        m_CommandHandlerRegistry.RegisterFunctor(&m_PerJobCounterSelectionCommandHandler);

        m_CommandHandlerRegistry.RegisterFunctor(&m_ActivateTimelineReportingCommandHandler);

        m_CommandHandlerRegistry.RegisterFunctor(&m_DeactivateTimelineReportingCommandHandler);
    }

~ProfilingService()

~ProfilingService

(

)

Definition at line 540 of file ProfilingService.cpp.

Referenced by ProfilingService::ProfilingService().

{
    Stop();
}

Member Function Documentation

AddBackendProfilingContext()

void AddBackendProfilingContext	(	const BackendId	backendId,
		std::shared_ptr< armnn::profiling::IBackendProfilingContext >	profilingContext
	)

Definition at line 214 of file ProfilingService.cpp.

References ARMNN_ASSERT.

Referenced by ProfilingService::ProfilingService(), and RuntimeImpl::RuntimeImpl().

{
    ARMNN_ASSERT(profilingContext != nullptr);
    // Register the backend counters
    m_MaxGlobalCounterId = profilingContext->RegisterCounters(m_MaxGlobalCounterId);
    m_BackendProfilingContexts.emplace(backendId, std::move(profilingContext));
}

AddCounterValue()

uint32_t AddCounterValue ( uint16_t  counterUid, uint32_t  value  )

overridevirtual

Implements IWriteCounterValues.

Definition at line 295 of file ProfilingService.cpp.

References ARMNN_ASSERT.

Referenced by ProfilingService::ProfilingService(), and TEST_SUITE().

{
    CheckCounterUid(counterUid);
    std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
    ARMNN_ASSERT(counterValuePtr);
    return counterValuePtr->fetch_add(value, std::memory_order::memory_order_relaxed);
}

AddLocalPacketHandler()

void AddLocalPacketHandler

(

ILocalPacketHandlerSharedPtr

localPacketHandler

)

Referenced by ProfilingService::IsTimelineReportingEnabled().

ConfigureProfilingService()

ProfilingState ConfigureProfilingService	(	const ExternalProfilingOptions &	options,
		bool	resetProfilingService = false
	)

Definition at line 62 of file ProfilingService.cpp.

References ProfilingStateMachine::GetCurrentState(), IRuntime::CreationOptions::ExternalProfilingOptions::m_EnableProfiling, armnn::profiling::NotConnected, ProfilingService::ResetExternalProfilingOptions(), armnn::profiling::Uninitialised, ProfilingService::Update(), and armnn::profiling::WaitingForAck.

Referenced by ProfilingService::ProfilingService(), RuntimeImpl::RuntimeImpl(), and TEST_SUITE().

{
    ResetExternalProfilingOptions(options, resetProfilingService);
    ProfilingState currentState = m_StateMachine.GetCurrentState();
    if (options.m_EnableProfiling)
    {
        switch (currentState)
        {
            case ProfilingState::Uninitialised:
                Update(); // should transition to NotConnected
                Update(); // will either stay in NotConnected because there is no server
                          // or will enter WaitingForAck.
                currentState = m_StateMachine.GetCurrentState();
                if (currentState == ProfilingState::WaitingForAck)
                {
                    Update(); // poke it again to send out the metadata packet
                }
                currentState = m_StateMachine.GetCurrentState();
                return currentState;
            case ProfilingState::NotConnected:
                Update(); // will either stay in NotConnected because there is no server
                          // or will enter WaitingForAck
                currentState = m_StateMachine.GetCurrentState();
                if (currentState == ProfilingState::WaitingForAck)
                {
                    Update(); // poke it again to send out the metadata packet
                }
                currentState = m_StateMachine.GetCurrentState();
                return currentState;
            default:
                return currentState;
        }
    }
    else
    {
        // Make sure profiling is shutdown
        switch (currentState)
        {
            case ProfilingState::Uninitialised:
            case ProfilingState::NotConnected:
                return currentState;
            default:
                Stop();
                return m_StateMachine.GetCurrentState();
        }
    }
}

Disconnect()

void Disconnect

(

)

Definition at line 193 of file ProfilingService.cpp.

References armnn::profiling::Active, ProfilingStateMachine::GetCurrentState(), armnn::profiling::NotConnected, armnn::profiling::Uninitialised, and armnn::profiling::WaitingForAck.

Referenced by ProfilingService::ProfilingService().

{
    ProfilingState currentState = m_StateMachine.GetCurrentState();
    switch (currentState)
    {
    case ProfilingState::Uninitialised:
    case ProfilingState::NotConnected:
    case ProfilingState::WaitingForAck:
        return; // NOP
    case ProfilingState::Active:
        // Stop the command thread (if running)
        Stop();

        break;
    default:
        throw RuntimeException(fmt::format("Unknown profiling service state: {}",
                                           static_cast<int>(currentState)));
    }
}

GenerateStaticId()

ProfilingStaticGuid GenerateStaticId ( const std::string &  str )

override

Create a ProfilingStaticGuid based on a hash of the string.

Definition at line 324 of file ProfilingService.cpp.

References ProfilingService::GetStaticId().

Referenced by ProfilingService::ProfilingService().

{
    return ProfilingService::GetStaticId(str);
}

GetAbsoluteCounterValue()

uint32_t GetAbsoluteCounterValue ( uint16_t  counterUid ) const

overridevirtual

Implements IReadCounterValues.

Definition at line 247 of file ProfilingService.cpp.

References ARMNN_ASSERT.

Referenced by ProfilingService::ProfilingService(), and TEST_SUITE().

{
    CheckCounterUid(counterUid);
    std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
    ARMNN_ASSERT(counterValuePtr);
    return counterValuePtr->load(std::memory_order::memory_order_relaxed);
}

GetBufferManager()

BufferManager& GetBufferManager ( ProfilingService &  instance )

inlineprotected

Definition at line 307 of file ProfilingService.hpp.

    {
        return instance.m_BufferManager;
    }

GetCaptureData()

CaptureData GetCaptureData ( )

overridevirtual

Implements IProfilingService.

Reimplemented in MockProfilingService.

Definition at line 275 of file ProfilingService.cpp.

References Holder::GetCaptureData().

Referenced by BackendProfiling::GetActiveCounters(), BackendProfiling::GetCounterStatus(), and ProfilingService::ProfilingService().

{
    return m_Holder.GetCaptureData();
}

GetCounterCount()

uint16_t GetCounterCount ( ) const

overridevirtual

Implements IReadCounterValues.

Definition at line 237 of file ProfilingService.cpp.

References CounterDirectory::GetCounterCount().

Referenced by ProfilingService::ProfilingService().

{
    return m_CounterDirectory.GetCounterCount();
}

GetCounterDirectory()

const ICounterDirectory & GetCounterDirectory

(

)

const

Definition at line 222 of file ProfilingService.cpp.

Referenced by ProfilingService::ProfilingService(), and TEST_SUITE().

{
    return m_CounterDirectory;
}

GetCounterMappingRegistry()

IRegisterCounterMapping & GetCounterMappingRegistry

(

)

Definition at line 270 of file ProfilingService.cpp.

Referenced by ProfilingService::ProfilingService(), and RegisterBackendCounters::RegisterCounter().

{
    return m_CounterIdMap;
}

GetCounterMappings()

const ICounterMappings & GetCounterMappings ( ) const

overridevirtual

Implements IProfilingService.

Reimplemented in MockProfilingService.

Definition at line 265 of file ProfilingService.cpp.

Referenced by BackendProfiling::GetActiveCounters(), BackendProfiling::GetCounterStatus(), ProfilingService::ProfilingService(), BackendProfiling::ReportCounters(), and TEST_SUITE().

{
    return m_CounterIdMap;
}

GetCounterRegistry()

ICounterRegistry & GetCounterRegistry

(

)

Definition at line 227 of file ProfilingService.cpp.

Referenced by ProfilingService::ProfilingService().

{
    return m_CounterDirectory;
}

GetCurrentState()

ProfilingState GetCurrentState

(

)

const

Definition at line 232 of file ProfilingService.cpp.

References ProfilingStateMachine::GetCurrentState().

Referenced by TimelineUtilityMethods::GetTimelineUtils(), ProfilingService::ProfilingService(), and TEST_SUITE().

{
    return m_StateMachine.GetCurrentState();
}

GetDeltaCounterValue()

uint32_t GetDeltaCounterValue ( uint16_t  counterUid )

overridevirtual

Implements IReadCounterValues.

Definition at line 255 of file ProfilingService.cpp.

References ARMNN_ASSERT, and ProfilingService::SubtractCounterValue().

Referenced by ProfilingService::ProfilingService(), and TEST_SUITE().

{
    CheckCounterUid(counterUid);
    std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
    ARMNN_ASSERT(counterValuePtr);
    const uint32_t counterValue = counterValuePtr->load(std::memory_order::memory_order_relaxed);
    SubtractCounterValue(counterUid, counterValue);
    return counterValue;
}

GetNextGuid()

ProfilingDynamicGuid GetNextGuid ( )

static

Definition at line 26 of file ProfilingService.cpp.

Referenced by TimelineUtilityMethods::CreateConnectionRelationship(), TimelineUtilityMethods::CreateNamedTypedChildEntity(), TimelineUtilityMethods::CreateNamedTypedEntity(), TimelineUtilityMethods::CreateRelationship(), ProfilingService::GetSendCounterPacket(), TimelineUtilityMethods::MarkEntityWithLabel(), TimelineUtilityMethods::MarkEntityWithType(), ProfilingService::NextGuid(), TimelineUtilityMethods::RecordEvent(), TimelineUtilityMethods::RecordWorkloadInferenceAndStartOfLifeEvent(), and TEST_SUITE().

{
    return m_GuidGenerator.NextGuid();
}

GetProfilingConnection()

IProfilingConnection* GetProfilingConnection ( ProfilingService &  instance )

inlineprotected

Definition at line 294 of file ProfilingService.hpp.

    {
        return instance.m_ProfilingConnection.get();
    }

GetSendCounterPacket()

ISendCounterPacket& GetSendCounterPacket ( )

inlineoverridevirtual

Implements IProfilingService.

Reimplemented in MockProfilingService.

Definition at line 204 of file ProfilingService.hpp.

References ProfilingService::GetNextGuid(), ProfilingService::GetStaticId(), and ProfilingService::ResetGuidGenerator().

Referenced by BackendProfiling::ReportCounters().

    {
        return m_SendCounterPacket;
    }

GetSendTimelinePacket()

std::unique_ptr< ISendTimelinePacket > GetSendTimelinePacket ( ) const

overridevirtual

Implements IProfilingService.

Reimplemented in MockProfilingService.

Definition at line 329 of file ProfilingService.cpp.

References ARMNN_ASSERT, armnn::BackendRegistryInstance(), CounterDirectory::Clear(), TimelinePacketWriterFactory::GetSendTimelinePacket(), CounterDirectory::IsCategoryRegistered(), CounterDirectory::IsCounterRegistered(), ProfilingService::IsCounterRegistered(), Counter::m_Uid, armnn::profiling::NotConnected, CounterDirectory::RegisterCategory(), CounterDirectory::RegisterCounter(), BufferManager::Reset(), ProfilingStateMachine::Reset(), CounterIdMap::Reset(), ProfilingService::SetCounterValue(), SendThread::Stop(), CommandHandler::Stop(), PeriodicCounterCapture::Stop(), and ProfilingStateMachine::TransitionToState().

Referenced by BackendProfiling::GetSendTimelinePacket(), TimelineUtilityMethods::GetTimelineUtils(), ProfilingService::ProfilingService(), and TEST_SUITE().

{
    return m_TimelinePacketWriterFactory.GetSendTimelinePacket();
}

GetStaticId()

ProfilingStaticGuid GetStaticId ( const std::string &  str )

static

Definition at line 31 of file ProfilingService.cpp.

Referenced by TimelineUtilityMethods::DeclareLabel(), ProfilingService::GenerateStaticId(), ProfilingService::GetSendCounterPacket(), TEST_SUITE(), and VerifyTimelineLabelBinaryPacketData().

{
    return m_GuidGenerator.GenerateStaticId(str);
}

IncrementCounterValue()

uint32_t IncrementCounterValue ( uint16_t  counterUid )

overridevirtual

Implements IWriteCounterValues.

Definition at line 311 of file ProfilingService.cpp.

References ARMNN_ASSERT.

Referenced by ProfilingService::ProfilingService(), and TEST_SUITE().

{
    CheckCounterUid(counterUid);
    std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
    ARMNN_ASSERT(counterValuePtr);
    return counterValuePtr->operator++(std::memory_order::memory_order_relaxed);
}

IsCounterRegistered()

bool IsCounterRegistered ( uint16_t  counterUid ) const

overridevirtual

Implements IReadCounterValues.

Definition at line 242 of file ProfilingService.cpp.

References CounterDirectory::IsCounterRegistered().

Referenced by ProfilingService::GetSendTimelinePacket(), and ProfilingService::ProfilingService().

{
    return m_CounterDirectory.IsCounterRegistered(counterUid);
}

IsProfilingEnabled()

bool IsProfilingEnabled ( ) const

overridevirtual

Implements IProfilingService.

Reimplemented in MockProfilingService.

Definition at line 57 of file ProfilingService.cpp.

References IRuntime::CreationOptions::ExternalProfilingOptions::m_EnableProfiling.

Referenced by BackendProfiling::IsProfilingEnabled(), and ProfilingService::ProfilingService().

{
    return m_Options.m_EnableProfiling;
}

IsTimelineReportingEnabled()

bool IsTimelineReportingEnabled ( )

inline

Definition at line 215 of file ProfilingService.hpp.

References ProfilingService::AddLocalPacketHandler(), ProfilingService::NotifyProfilingServiceActive(), ProfilingService::ProfilingService(), and ProfilingService::WaitForProfilingServiceActivation().

Referenced by TimelineUtilityMethods::GetTimelineUtils().

    {
        return m_TimelineReporting;
    }

NextGuid()

ProfilingDynamicGuid NextGuid ( )

override

Return the next random Guid in the sequence.

Definition at line 319 of file ProfilingService.cpp.

References ProfilingService::GetNextGuid().

Referenced by ProfilingService::ProfilingService(), and TEST_SUITE().

{
    return ProfilingService::GetNextGuid();
}

NotifyBackendsForTimelineReporting()

void NotifyBackendsForTimelineReporting ( )

overridevirtual

Implements INotifyBackends.

Definition at line 495 of file ProfilingService.cpp.

Referenced by ProfilingService::ProfilingService().

{
    BackendProfilingContext::iterator it = m_BackendProfilingContexts.begin();
    while (it != m_BackendProfilingContexts.end())
    {
        auto& backendProfilingContext = it->second;
        backendProfilingContext->EnableTimelineReporting(m_TimelineReporting);
        // Increment the Iterator to point to next entry
        it++;
    }
}

NotifyProfilingServiceActive()

void NotifyProfilingServiceActive ( )

overridevirtual

Implements IProfilingServiceStatus.

Definition at line 507 of file ProfilingService.cpp.

Referenced by ProfilingService::IsTimelineReportingEnabled().

{
    {   // only lock when we are updating the inference completed variable
        std::unique_lock<std::mutex> lck(m_ServiceActiveMutex);
        m_ServiceActive = true;
    }
    m_ServiceActiveConditionVariable.notify_one();
}

ResetExternalProfilingOptions()

void ResetExternalProfilingOptions	(	const ExternalProfilingOptions &	options,
		bool	resetProfilingService = false
	)

Definition at line 41 of file ProfilingService.cpp.

References IRuntime::CreationOptions::ExternalProfilingOptions::m_TimelineEnabled, and ConnectionAcknowledgedCommandHandler::setTimelineEnabled().

Referenced by ProfilingService::ConfigureProfilingService(), ProfilingService::ProfilingService(), TEST_SUITE(), and VerifyPostOptimisationStructureTestImpl().

{
    // Update the profiling options
    m_Options = options;
    m_TimelineReporting = options.m_TimelineEnabled;
    m_ConnectionAcknowledgedCommandHandler.setTimelineEnabled(options.m_TimelineEnabled);

    // Check if the profiling service needs to be reset
    if (resetProfilingService)
    {
        // Reset the profiling service
        Reset();
    }
}

ResetGuidGenerator()

void ResetGuidGenerator

(

)

Definition at line 36 of file ProfilingService.cpp.

Referenced by ProfilingService::GetSendCounterPacket(), and TEST_SUITE().

{
    m_GuidGenerator.Reset();
}

SetCaptureData()

void SetCaptureData	(	uint32_t	capturePeriod,
		const std::vector< uint16_t > &	counterIds,
		const std::set< BackendId > &	activeBackends
	)

Definition at line 280 of file ProfilingService.cpp.

References Holder::SetCaptureData().

Referenced by ProfilingService::ProfilingService().

{
    m_Holder.SetCaptureData(capturePeriod, counterIds, activeBackends);
}

SetCounterValue()

void SetCounterValue ( uint16_t  counterUid, uint32_t  value  )

overridevirtual

Implements IWriteCounterValues.

Definition at line 287 of file ProfilingService.cpp.

References ARMNN_ASSERT.

Referenced by ProfilingService::GetSendTimelinePacket(), ProfilingService::ProfilingService(), and TEST_SUITE().

{
    CheckCounterUid(counterUid);
    std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
    ARMNN_ASSERT(counterValuePtr);
    counterValuePtr->store(value, std::memory_order::memory_order_relaxed);
}

SubtractCounterValue()

uint32_t SubtractCounterValue ( uint16_t  counterUid, uint32_t  value  )

overridevirtual

Implements IWriteCounterValues.

Definition at line 303 of file ProfilingService.cpp.

References ARMNN_ASSERT.

Referenced by ProfilingService::GetDeltaCounterValue(), ProfilingService::ProfilingService(), and TEST_SUITE().

{
    CheckCounterUid(counterUid);
    std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
    ARMNN_ASSERT(counterValuePtr);
    return counterValuePtr->fetch_sub(value, std::memory_order::memory_order_relaxed);
}

SwapProfilingConnectionFactory()

void SwapProfilingConnectionFactory ( ProfilingService &  instance, IProfilingConnectionFactory *  other, IProfilingConnectionFactory *&  backup  )

inlineprotected

Definition at line 284 of file ProfilingService.hpp.

References ARMNN_ASSERT.

    {
        ARMNN_ASSERT(instance.m_ProfilingConnectionFactory);
        ARMNN_ASSERT(other);

        backup = instance.m_ProfilingConnectionFactory.release();
        instance.m_ProfilingConnectionFactory.reset(other);
    }

TransitionToState()

void TransitionToState ( ProfilingService &  instance, ProfilingState  newState  )

inlineprotected

Definition at line 298 of file ProfilingService.hpp.

References ProfilingStateMachine::TransitionToState().

    {
        instance.m_StateMachine.TransitionToState(newState);
    }

Update()

void Update

(

)

Definition at line 112 of file ProfilingService.cpp.

References armnn::profiling::Active, ARMNN_ASSERT, ARMNN_LOG, ProfilingStateMachine::GetCurrentState(), IRuntime::CreationOptions::ExternalProfilingOptions::m_EnableProfiling, armnn::profiling::NotConnected, SendThread::Start(), CommandHandler::Start(), SendThread::Stop(), CommandHandler::Stop(), PeriodicCounterCapture::Stop(), ProfilingStateMachine::TransitionToState(), armnn::profiling::Uninitialised, armnn::profiling::WaitingForAck, armnn::warning, and Exception::what().

Referenced by ProfilingService::ConfigureProfilingService(), ProfilingService::ProfilingService(), and TEST_SUITE().

{
    if (!m_Options.m_EnableProfiling)
    {
        // Don't run if profiling is disabled
        return;
    }

    ProfilingState currentState = m_StateMachine.GetCurrentState();
    switch (currentState)
    {
    case ProfilingState::Uninitialised:

        // Initialize the profiling service
        Initialize();

        // Move to the next state
        m_StateMachine.TransitionToState(ProfilingState::NotConnected);
        break;
    case ProfilingState::NotConnected:
        // Stop the command thread (if running)
        m_CommandHandler.Stop();

        // Stop the send thread (if running)
        m_SendThread.Stop(false);

        // Stop the periodic counter capture thread (if running)
        m_PeriodicCounterCapture.Stop();

        // Reset any existing profiling connection
        m_ProfilingConnection.reset();

        try
        {
            // Setup the profiling connection
            ARMNN_ASSERT(m_ProfilingConnectionFactory);
            m_ProfilingConnection = m_ProfilingConnectionFactory->GetProfilingConnection(m_Options);
        }
        catch (const Exception& e)
        {
            ARMNN_LOG(warning) << "An error has occurred when creating the profiling connection: "
                                       << e.what();
        }
        catch (const arm::pipe::SocketConnectionException& e)
        {
            ARMNN_LOG(warning) << "An error has occurred when creating the profiling connection ["
                                       << e.what() << "] on socket [" << e.GetSocketFd() << "].";
        }

        // Move to the next state
        m_StateMachine.TransitionToState(m_ProfilingConnection
                                         ? ProfilingState::WaitingForAck  // Profiling connection obtained, wait for ack
                                         : ProfilingState::NotConnected); // Profiling connection failed, stay in the
                                                                          // "NotConnected" state
        break;
    case ProfilingState::WaitingForAck:
        ARMNN_ASSERT(m_ProfilingConnection);

        // Start the command thread
        m_CommandHandler.Start(*m_ProfilingConnection);

        // Start the send thread, while in "WaitingForAck" state it'll send out a "Stream MetaData" packet waiting for
        // a valid "Connection Acknowledged" packet confirming the connection
        m_SendThread.Start(*m_ProfilingConnection);

        // The connection acknowledged command handler will automatically transition the state to "Active" once a
        // valid "Connection Acknowledged" packet has been received

        break;
    case ProfilingState::Active:

        // The period counter capture thread is started by the Periodic Counter Selection command handler upon
        // request by an external profiling service

        break;
    default:
        throw RuntimeException(fmt::format("Unknown profiling service state: {}",
                                           static_cast<int>(currentState)));
    }
}

WaitForPacketSent()

bool WaitForPacketSent ( ProfilingService &  instance, uint32_t  timeout = 1000  )

inlineprotected

Definition at line 302 of file ProfilingService.hpp.

References SendThread::WaitForPacketSent().

Referenced by SwapProfilingConnectionFactoryHelper::WaitForPacketsSent().

    {
        return instance.m_SendThread.WaitForPacketSent(timeout);
    }

WaitForProfilingServiceActivation()

void WaitForProfilingServiceActivation ( unsigned int  timeout )

overridevirtual

Implements IProfilingServiceStatus.

Definition at line 516 of file ProfilingService.cpp.

References ARMNN_LOG, and armnn::warning.

Referenced by ProfilingService::IsTimelineReportingEnabled(), and RuntimeImpl::RuntimeImpl().

{
    std::unique_lock<std::mutex> lck(m_ServiceActiveMutex);

    auto start = std::chrono::high_resolution_clock::now();
    // Here we we will go back to sleep after a spurious wake up if
    // m_InferenceCompleted is not yet true.
    if (!m_ServiceActiveConditionVariable.wait_for(lck,
                                                   std::chrono::milliseconds(timeout),
                                                   [&]{return m_ServiceActive == true;}))
    {
        if (m_ServiceActive == true)
        {
            return;
        }
        auto finish = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double, std::milli> elapsed = finish - start;
        std::stringstream ss;
        ss << "Timed out waiting on profiling service activation for " << elapsed.count() << " ms";
        ARMNN_LOG(warning) << ss.str();
    }
    return;
}

---

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

• src/profiling/ProfilingService.hpp
• src/profiling/ProfilingService.cpp