PeriodicCounterSelectionCommandHandler Class Reference

#include <PeriodicCounterSelectionCommandHandler.hpp>

Inheritance diagram for PeriodicCounterSelectionCommandHandler:

Public Member Functions
	PeriodicCounterSelectionCommandHandler (uint32_t familyId, uint32_t packetId, uint32_t version, const std::unordered_map< BackendId, std::shared_ptr< armnn::profiling::IBackendProfilingContext >> &backendProfilingContexts, const ICounterMappings &counterIdMap, Holder &captureDataHolder, const uint16_t maxArmnnCounterId, IPeriodicCounterCapture &periodicCounterCapture, const IReadCounterValues &readCounterValue, ISendCounterPacket &sendCounterPacket, const ProfilingStateMachine &profilingStateMachine)
void	operator() (const arm::pipe::Packet &packet) override

Detailed Description

Definition at line 31 of file PeriodicCounterSelectionCommandHandler.hpp.

Constructor & Destructor Documentation

PeriodicCounterSelectionCommandHandler()

PeriodicCounterSelectionCommandHandler ( uint32_t  familyId, uint32_t  packetId, uint32_t  version, const std::unordered_map< BackendId, std::shared_ptr< armnn::profiling::IBackendProfilingContext >> &  backendProfilingContexts, const ICounterMappings &  counterIdMap, Holder &  captureDataHolder, const uint16_t  maxArmnnCounterId, IPeriodicCounterCapture &  periodicCounterCapture, const IReadCounterValues &  readCounterValue, ISendCounterPacket &  sendCounterPacket, const ProfilingStateMachine &  profilingStateMachine  )

inline

Definition at line 35 of file PeriodicCounterSelectionCommandHandler.hpp.

References ARMNN_LOG, OptionalBase::has_value(), PeriodicCounterSelectionCommandHandler::operator()(), OptionalReferenceSwitch< IsReference, T >::value(), and armnn::warning.

        : CommandHandlerFunctor(familyId, packetId, version)
        , m_BackendProfilingContexts(backendProfilingContexts)
        , m_CounterIdMap(counterIdMap)
        , m_CaptureDataHolder(captureDataHolder)
        , m_MaxArmCounterId(maxArmnnCounterId)
        , m_PeriodicCounterCapture(periodicCounterCapture)
        , m_PrevCapturePeriod(0)
        , m_ReadCounterValues(readCounterValue)
        , m_SendCounterPacket(sendCounterPacket)
        , m_StateMachine(profilingStateMachine)

    {

    }

Member Function Documentation

operator()()

void operator() ( const arm::pipe::Packet &  packet )

override

Definition at line 60 of file PeriodicCounterSelectionCommandHandler.cpp.

References armnn::profiling::Active, CaptureData::GetActiveBackends(), ICounterMappings::GetBackendId(), Holder::GetCaptureData(), CaptureData::GetCapturePeriod(), CaptureData::GetCounterIds(), ProfilingStateMachine::GetCurrentState(), armnn::profiling::GetProfilingStateName(), IReadCounterValues::IsCounterRegistered(), armnn::LOWEST_CAPTURE_PERIOD, armnn::profiling::NotConnected, ISendCounterPacket::SendPeriodicCounterSelectionPacket(), Holder::SetCaptureData(), IPeriodicCounterCapture::Start(), IPeriodicCounterCapture::Stop(), armnn::profiling::Uninitialised, and armnn::profiling::WaitingForAck.

Referenced by PeriodicCounterSelectionCommandHandler::PeriodicCounterSelectionCommandHandler().

{
    ProfilingState currentState = m_StateMachine.GetCurrentState();
    switch (currentState)
    {
    case ProfilingState::Uninitialised:
    case ProfilingState::NotConnected:
    case ProfilingState::WaitingForAck:
        throw RuntimeException(fmt::format("Periodic Counter Selection Command Handler invoked while in "
                                           "an wrong state: {}",
                                           GetProfilingStateName(currentState)));
    case ProfilingState::Active:
    {
        // Process the packet
        if (!(packet.GetPacketFamily() == 0u && packet.GetPacketId() == 4u))
        {
            throw armnn::InvalidArgumentException(fmt::format("Expected Packet family = 0, id = 4 but "
                                                              "received family = {}, id = {}",
                                                              packet.GetPacketFamily(),
                                                              packet.GetPacketId()));
        }

        // Parse the packet to get the capture period and counter UIDs
        CaptureData captureData;
        ParseData(packet, captureData);

        // Get the capture data
        uint32_t capturePeriod = captureData.GetCapturePeriod();
        // Validate that the capture period is within the acceptable range.
        if (capturePeriod > 0  && capturePeriod < LOWEST_CAPTURE_PERIOD)
        {
            capturePeriod = LOWEST_CAPTURE_PERIOD;
        }
        const std::vector<uint16_t>& counterIds = captureData.GetCounterIds();

        // Check whether the selected counter UIDs are valid
        std::vector<uint16_t> validCounterIds;
        for (uint16_t counterId : counterIds)
        {
            // Check whether the counter is registered
            if (!m_ReadCounterValues.IsCounterRegistered(counterId))
            {
                // Invalid counter UID, ignore it and continue
                continue;
            }
            // The counter is valid
            validCounterIds.emplace_back(counterId);
        }

        std::sort(validCounterIds.begin(), validCounterIds.end());

        auto backendIdStart = std::find_if(validCounterIds.begin(), validCounterIds.end(), [&](uint16_t& counterId)
        {
            return counterId > m_MaxArmCounterId;
        });

        std::set<armnn::BackendId> activeBackends;
        std::set<uint16_t> backendCounterIds = std::set<uint16_t>(backendIdStart, validCounterIds.end());

        if (m_BackendCounterMap.size() != 0)
        {
            std::set<uint16_t> newCounterIds;
            std::set<uint16_t> unusedCounterIds;

            // Get any backend counter ids that is in backendCounterIds but not in m_PrevBackendCounterIds
            std::set_difference(backendCounterIds.begin(), backendCounterIds.end(),
                                m_PrevBackendCounterIds.begin(), m_PrevBackendCounterIds.end(),
                                std::inserter(newCounterIds, newCounterIds.begin()));

            // Get any backend counter ids that is in m_PrevBackendCounterIds but not in backendCounterIds
            std::set_difference(m_PrevBackendCounterIds.begin(), m_PrevBackendCounterIds.end(),
                                backendCounterIds.begin(), backendCounterIds.end(),
                                std::inserter(unusedCounterIds, unusedCounterIds.begin()));

            activeBackends = ProcessBackendCounterIds(capturePeriod, newCounterIds, unusedCounterIds);
        }
        else
        {
            activeBackends = ProcessBackendCounterIds(capturePeriod, backendCounterIds, {});
        }

        // save the new backend counter ids for next time
        m_PrevBackendCounterIds = backendCounterIds;

        // Set the capture data with only the valid armnn counter UIDs
        m_CaptureDataHolder.SetCaptureData(capturePeriod, {validCounterIds.begin(), backendIdStart}, activeBackends);

        // Echo back the Periodic Counter Selection packet to the Counter Stream Buffer
        m_SendCounterPacket.SendPeriodicCounterSelectionPacket(capturePeriod, validCounterIds);

        if (capturePeriod == 0 || validCounterIds.empty())
        {
            // No data capture stop the thread
            m_PeriodicCounterCapture.Stop();
        }
        else
        {
            // Start the Period Counter Capture thread (if not running already)
            m_PeriodicCounterCapture.Start();
        }

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

---

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

• src/profiling/PeriodicCounterSelectionCommandHandler.hpp
• src/profiling/PeriodicCounterSelectionCommandHandler.cpp