FileOnlyProfilingConnection Class Reference

#include <FileOnlyProfilingConnection.hpp>

Inheritance diagram for FileOnlyProfilingConnection:

Public Member Functions
	FileOnlyProfilingConnection (const Runtime::CreationOptions::ExternalProfilingOptions &options, const bool quietOp=true)
	~FileOnlyProfilingConnection ()
bool	IsOpen () const override
void	Close () override
bool	WritePacket (const unsigned char *buffer, uint32_t length) override
Packet	ReadPacket (uint32_t timeout) override
Public Member Functions inherited from IProfilingConnection
virtual	~IProfilingConnection ()

Detailed Description

Definition at line 41 of file FileOnlyProfilingConnection.hpp.

Constructor & Destructor Documentation

FileOnlyProfilingConnection()

FileOnlyProfilingConnection ( const Runtime::CreationOptions::ExternalProfilingOptions &  options, const bool  quietOp = true  )

inline

Definition at line 44 of file FileOnlyProfilingConnection.hpp.

        : m_Options(options)
        , m_QuietOp(quietOp)
        , m_Endianness(TargetEndianness::LeWire)    // Set a sensible default. WaitForStreamMeta will set a real value.
        , m_IsRunning(false)
        , m_KeepRunning(false)
        , m_Timeout(1000)
    {
        for (ILocalPacketHandlerSharedPtr localPacketHandler : options.m_LocalPacketHandlers)
        {
            AddLocalPacketHandler(localPacketHandler);
        }
        if (!options.m_LocalPacketHandlers.empty())
        {
            StartProcessingThread();
        }
        // NOTE: could add timeout to the external profiling options
    };

~FileOnlyProfilingConnection()

~FileOnlyProfilingConnection

(

)

Definition at line 23 of file FileOnlyProfilingConnection.cpp.

References FileOnlyProfilingConnection::Close().

{
    Close();
}

Member Function Documentation

Close()

void Close ( )

overridevirtual

Implements IProfilingConnection.

Definition at line 34 of file FileOnlyProfilingConnection.cpp.

References armnn::profiling::BeWire, armnn::IgnoreUnused(), armnn::profiling::LeWire, armnn::numeric_cast(), armnn::profiling::uint16_t_size, armnn::profiling::uint32_t_size, armnn::profiling::WriteUint16(), and armnn::profiling::WriteUint32().

Referenced by FileOnlyProfilingConnection::ReadPacket(), and FileOnlyProfilingConnection::~FileOnlyProfilingConnection().

{
    // Dump any unread packets out of the queue.
    size_t initialSize = m_PacketQueue.size();
    for (size_t i = 0; i < initialSize; ++i)
    {
        m_PacketQueue.pop();
    }
    // dispose of the processing thread
    m_KeepRunning.store(false);
    if (m_LocalHandlersThread.joinable())
    {
        // make sure the thread wakes up and sees it has to stop
        m_ConditionPacketReadable.notify_one();
        m_LocalHandlersThread.join();
    }
}

IsOpen()

bool IsOpen ( ) const

overridevirtual

Implements IProfilingConnection.

Definition at line 28 of file FileOnlyProfilingConnection.cpp.

{
    // This type of connection is always open.
    return true;
}

ReadPacket()

Packet ReadPacket ( uint32_t  timeout )

overridevirtual

Implements IProfilingConnection.

Definition at line 179 of file FileOnlyProfilingConnection.cpp.

References armnn::profiling::BeWire, FileOnlyProfilingConnection::Close(), armnn::profiling::CounterDirectory, armnn::profiling::StreamMetaData, and armnn::profiling::Unknown.

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

    // Here we are using m_PacketQueue.empty() as a predicate variable
    // The conditional variable will wait until packetQueue is not empty or until a timeout
    if(!m_ConditionPacketAvailable.wait_for(lck,
                                            std::chrono::milliseconds(timeout),
                                            [&]{return !m_PacketQueue.empty();}))
    {
        throw armnn::TimeoutException("Thread has timed out as per requested time limit");
    }

    Packet returnedPacket = std::move(m_PacketQueue.front());
    m_PacketQueue.pop();
    return returnedPacket;
}

WritePacket()

bool WritePacket ( const unsigned char *  buffer, uint32_t  length  )

overridevirtual

Implements IProfilingConnection.

Definition at line 123 of file FileOnlyProfilingConnection.cpp.

References ARMNN_ASSERT, armnn::profiling::CounterDirectory, ICounterDirectory::GetCategories(), Version::GetEncodedValue(), armnn::profiling::ReceivePacket(), PacketVersionResolver::ResolvePacketVersion(), and armnn::profiling::StreamMetaData.

{
    ARMNN_ASSERT(buffer);
    Packet packet = ReceivePacket(buffer, length);

    // Read Header and determine case
    uint32_t outgoingHeaderAsWords[2];
    PackageActivity packageActivity = GetPackageActivity(packet, outgoingHeaderAsWords);

    switch (packageActivity)
    {
        case PackageActivity::StreamMetaData:
        {
            if (!WaitForStreamMeta(buffer, length))
            {
                return EXIT_FAILURE;
            }

            SendConnectionAck();
            break;
        }
        case PackageActivity::CounterDirectory:
        {
            std::unique_ptr<unsigned char[]> uniqueCounterData = std::make_unique<unsigned char[]>(length - 8);

            std::memcpy(uniqueCounterData.get(), buffer + 8, length - 8);

            Packet directoryPacket(outgoingHeaderAsWords[0], length - 8, uniqueCounterData);

            armnn::profiling::PacketVersionResolver packetVersionResolver;
            DirectoryCaptureCommandHandler directoryCaptureCommandHandler(
                0, 2, packetVersionResolver.ResolvePacketVersion(0, 2).GetEncodedValue());
            directoryCaptureCommandHandler.operator()(directoryPacket);
            const ICounterDirectory& counterDirectory = directoryCaptureCommandHandler.GetCounterDirectory();
            for (auto& category : counterDirectory.GetCategories())
            {
                // Remember we need to translate the Uid's from our CounterDirectory instance to the parent one.
                std::vector<uint16_t> translatedCounters;
                for (auto const& copyUid : category->m_Counters)
                {
                    translatedCounters.emplace_back(directoryCaptureCommandHandler.TranslateUIDCopyToOriginal(copyUid));
                }
                m_IdList.insert(std::end(m_IdList), std::begin(translatedCounters), std::end(translatedCounters));
            }
            SendCounterSelectionPacket();
            break;
        }
        default:
        {
            break;
        }
    }
    ForwardPacketToHandlers(packet);
    return true;
}

---

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

• src/profiling/FileOnlyProfilingConnection.hpp
• src/profiling/FileOnlyProfilingConnection.cpp