armnn::profiling Namespace Reference

Classes
class	ActivateTimelineReportingCommandHandler
class	BackendProfiling
class	BufferExhaustion
class	BufferManager
class	CaptureData
class	Category
class	CommandHandler
class	Connection
class	ConnectionAcknowledgedCommandHandler
class	Counter
class	CounterDirectory
struct	CounterDirectoryEventRecord
class	CounterIdMap
class	CounterSet
struct	CounterStatus
struct	CounterValue
class	DeactivateTimelineReportingCommandHandler
class	Device
class	DirectoryCaptureCommandHandler
class	Entity
class	EventClassObj
class	EventObj
class	FileOnlyProfilingConnection
class	Holder
class	IBackendProfiling
class	IBackendProfilingContext
class	IBufferManager
class	IConsumer
class	ICounterDirectory
class	ICounterMappings
class	ICounterRegistry
class	IInternalProfilingConnection
class	ILocalPacketHandler
class	INotifyBackends
class	IPacketBuffer
class	IPeriodicCounterCapture
class	IProfilingConnection
class	IProfilingConnectionFactory
class	IProfilingService
class	IProfilingServiceStatus
class	IReadCounterValues
class	IReadOnlyPacketBuffer
class	IReadWriteCounterValues
class	IRegisterBackendCounters
class	IRegisterCounterMapping
class	IReportStructure
class	ISendCounterPacket
class	ISendThread
class	ISendTimelinePacket
class	IWriteCounterValues
struct	LogLevelSwapper
class	MockBufferManager
class	MockCounterDirectory
class	MockPacketBuffer
class	MockProfilingConnection
class	MockProfilingConnectionFactory
class	MockProfilingService
class	MockProfilingServiceStatus
class	MockSendCounterPacket
class	MockStreamCounterBuffer
struct	ModelRelationship
class	NullProfilingConnection
class	PacketBuffer
class	PeriodicCounterCapture
class	PeriodicCounterSelectionCommandHandler
class	PerJobCounterSelectionCommandHandler
class	PrintPacketHeaderHandler
class	ProfilingConnectionDumpToFileDecorator
class	ProfilingConnectionFactory
class	ProfilingService
class	ProfilingServiceRuntimeHelper
class	ProfilingStateMachine
class	RegisterBackendCounters
class	RequestCounterDirectoryCommandHandler
class	RequestCountersPacketHandler
class	SendCounterPacket
class	SendCounterPacketTest
class	SendThread
class	SendTimelinePacket
class	SocketProfilingConnection
class	StreamMetaDataProcessor
struct	StreamRedirector
class	SwapProfilingConnectionFactoryHelper
class	TestFunctorA
class	TestFunctorB
class	TestFunctorC
class	TestProfilingConnectionArmnnError
class	TestProfilingConnectionBadAckPacket
class	TestProfilingConnectionBase
class	TestProfilingConnectionTimeoutError
class	TestTimelinePacketHandler
class	TimelineMessageDecoder
class	TimelineModel
class	TimelinePacketWriterFactory
class	TimelineUtilityMethods
struct	Timestamp

Typedefs
using	IBackendProfilingContextUniquePtr = std::unique_ptr< IBackendProfilingContext >
using	ILocalPacketHandlerPtr = std::unique_ptr< ILocalPacketHandler >
using	ILocalPacketHandlerSharedPtr = std::shared_ptr< ILocalPacketHandler >
using	CategoryPtr = std::unique_ptr< Category >
using	DevicePtr = std::unique_ptr< Device >
using	CounterSetPtr = std::unique_ptr< CounterSet >
using	CounterPtr = std::shared_ptr< Counter >
using	Categories = std::unordered_set< CategoryPtr >
using	Devices = std::unordered_map< uint16_t, DevicePtr >
using	CounterSets = std::unordered_map< uint16_t, CounterSetPtr >
using	Counters = std::unordered_map< uint16_t, CounterPtr >
using	CategoriesIt = Categories::const_iterator
using	DevicesIt = Devices::const_iterator
using	CounterSetsIt = CounterSets::const_iterator
using	CountersIt = Counters::const_iterator
using	IPacketBufferPtr = std::unique_ptr< IPacketBuffer >
using	LabelMap = std::map< uint64_t, arm::pipe::ITimelineDecoder::Label >
using	Attribute = std::pair< std::string, std::string >
using	Attributes = std::map< std::string, Attribute >
using	Entities = std::map< uint64_t, Entity >
using	Relationships = std::map< uint64_t, ModelRelationship >
using	EventClasses = std::map< uint64_t, EventClassObj >
using	Events = std::map< uint64_t, EventObj >

Enumerations
enum	TargetEndianness { BeWire, LeWire }
enum	ProfilingRelationshipType { RetentionLink, ExecutionLink, DataLink, LabelLink }
enum	ProfilingState { Uninitialised, NotConnected, WaitingForAck, Active }
enum	TimelinePacketStatus { Ok, Error, BufferExhaustion }

Functions
constexpr char const *	GetProfilingStateName (ProfilingState state)
uint16_t	GetNextUid (bool peekOnly)
std::vector< uint16_t >	GetNextCounterUids (uint16_t firstUid, uint16_t cores)
void	WriteBytes (const IPacketBufferPtr &packetBuffer, unsigned int offset, const void *value, unsigned int valueSize)
uint32_t	ConstructHeader (uint32_t packetFamily, uint32_t packetId)
uint32_t	ConstructHeader (uint32_t packetFamily, uint32_t packetClass, uint32_t packetType)
void	WriteUint64 (const std::unique_ptr< IPacketBuffer > &packetBuffer, unsigned int offset, uint64_t value)
void	WriteUint32 (const IPacketBufferPtr &packetBuffer, unsigned int offset, uint32_t value)
void	WriteUint16 (const IPacketBufferPtr &packetBuffer, unsigned int offset, uint16_t value)
void	WriteUint8 (const IPacketBufferPtr &packetBuffer, unsigned int offset, uint8_t value)
void	WriteBytes (unsigned char *buffer, unsigned int offset, const void *value, unsigned int valueSize)
void	WriteUint64 (unsigned char *buffer, unsigned int offset, uint64_t value)
void	WriteUint32 (unsigned char *buffer, unsigned int offset, uint32_t value)
void	WriteUint16 (unsigned char *buffer, unsigned int offset, uint16_t value)
void	WriteUint8 (unsigned char *buffer, unsigned int offset, uint8_t value)
void	ReadBytes (const IPacketBufferPtr &packetBuffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
uint64_t	ReadUint64 (const IPacketBufferPtr &packetBuffer, unsigned int offset)
uint32_t	ReadUint32 (const IPacketBufferPtr &packetBuffer, unsigned int offset)
uint16_t	ReadUint16 (const IPacketBufferPtr &packetBuffer, unsigned int offset)
uint8_t	ReadUint8 (const IPacketBufferPtr &packetBuffer, unsigned int offset)
void	ReadBytes (const unsigned char *buffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
uint64_t	ReadUint64 (const unsigned char *buffer, unsigned int offset)
uint32_t	ReadUint32 (const unsigned char *buffer, unsigned int offset)
uint16_t	ReadUint16 (const unsigned char *buffer, unsigned int offset)
uint8_t	ReadUint8 (const unsigned char *buffer, unsigned int offset)
std::string	GetSoftwareInfo ()
std::string	GetHardwareVersion ()
std::string	GetSoftwareVersion ()
std::string	GetProcessName ()
std::pair< uint32_t, uint32_t >	CreateTimelinePacketHeader (uint32_t packetFamily, uint32_t packetClass, uint32_t packetType, uint32_t streamId, uint32_t sequenceNumbered, uint32_t dataLength)
	Creates a timeline packet header. More...
std::pair< uint32_t, uint32_t >	CreateTimelineMessagePacketHeader (unsigned int dataLength)
	Creates a packet header for the timeline messages: More...
TimelinePacketStatus	WriteTimelineLabelBinaryPacket (uint64_t profilingGuid, const std::string &label, unsigned char *buffer, unsigned int remainingBufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineEntityBinary (uint64_t profilingGuid, unsigned char *buffer, unsigned int remainingBufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineRelationshipBinary (ProfilingRelationshipType relationshipType, uint64_t relationshipGuid, uint64_t headGuid, uint64_t tailGuid, uint64_t attributeGuid, unsigned char *buffer, unsigned int remainingBufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineMessageDirectoryPackage (unsigned char *buffer, unsigned int remainingBufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineEventClassBinary (uint64_t profilingGuid, uint64_t nameGuid, unsigned char *buffer, unsigned int remainingBufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineEventBinary (uint64_t timestamp, int threadId, uint64_t profilingGuid, unsigned char *buffer, unsigned int remainingBufferSize, unsigned int &numberOfBytesWritten)
std::string	CentreAlignFormatting (const std::string &stringToPass, const int spacingWidth)
void	PrintDeviceDetails (const std::pair< const unsigned short, std::unique_ptr< Device >> &devicePair)
void	PrintCounterSetDetails (const std::pair< const unsigned short, std::unique_ptr< CounterSet >> &counterSetPair)
void	PrintCounterDetails (std::shared_ptr< Counter > &counter)
void	PrintCategoryDetails (const std::unique_ptr< Category > &category, std::unordered_map< unsigned short, std::shared_ptr< Counter >> counterMap)
void	PrintCounterDirectory (ICounterDirectory &counterDirectory)
uint64_t	GetTimestamp ()
arm::pipe::Packet	ReceivePacket (const unsigned char *buffer, uint32_t length)
void	WriteBytes (const IPacketBuffer &packetBuffer, unsigned int offset, const void *value, unsigned int valueSize)
void	WriteUint64 (const IPacketBufferPtr &packetBuffer, unsigned int offset, uint64_t value)
std::vector< std::string >	GetModelDescription (const TimelineModel &model)
std::string	GetEntityDescription (const Entity &entity)
std::string	GetChildDescription (Entity *entity)
std::string	GetConnectionDescription (const Connection &connection)
std::string	GetExecutionDescription (Entity *execution)
std::string	GetEventDescription (EventObj *event)

Variables
uint32_t	uint16_t_size = sizeof(uint16_t)
uint32_t	uint32_t_size = sizeof(uint32_t)
constexpr unsigned int	ThreadIdSize = sizeof(int)

Typedef Documentation

Attribute

using Attribute = std::pair<std::string, std::string>

Definition at line 21 of file TimelineModel.hpp.

Attributes

using Attributes = std::map<std::string, Attribute>

Definition at line 22 of file TimelineModel.hpp.

Categories

using Categories = std::unordered_set<CategoryPtr>

Definition at line 35 of file ICounterDirectory.hpp.

CategoriesIt

using CategoriesIt = Categories::const_iterator

Definition at line 41 of file ICounterDirectory.hpp.

CategoryPtr

using CategoryPtr = std::unique_ptr<Category>

Definition at line 29 of file ICounterDirectory.hpp.

CounterPtr

using CounterPtr = std::shared_ptr<Counter>

Definition at line 32 of file ICounterDirectory.hpp.

Counters

using Counters = std::unordered_map<uint16_t, CounterPtr>

Definition at line 38 of file ICounterDirectory.hpp.

CounterSetPtr

using CounterSetPtr = std::unique_ptr<CounterSet>

Definition at line 31 of file ICounterDirectory.hpp.

CounterSets

using CounterSets = std::unordered_map<uint16_t, CounterSetPtr>

Definition at line 37 of file ICounterDirectory.hpp.

CounterSetsIt

using CounterSetsIt = CounterSets::const_iterator

Definition at line 43 of file ICounterDirectory.hpp.

CountersIt

using CountersIt = Counters::const_iterator

Definition at line 44 of file ICounterDirectory.hpp.

DevicePtr

using DevicePtr = std::unique_ptr<Device>

Definition at line 30 of file ICounterDirectory.hpp.

Devices

using Devices = std::unordered_map<uint16_t, DevicePtr>

Definition at line 36 of file ICounterDirectory.hpp.

DevicesIt

using DevicesIt = Devices::const_iterator

Definition at line 42 of file ICounterDirectory.hpp.

Entities

using Entities = std::map<uint64_t, Entity>

Definition at line 136 of file TimelineModel.hpp.

EventClasses

using EventClasses = std::map<uint64_t, EventClassObj>

Definition at line 144 of file TimelineModel.hpp.

Events

using Events = std::map<uint64_t, EventObj>

Definition at line 145 of file TimelineModel.hpp.

IBackendProfilingContextUniquePtr

using IBackendProfilingContextUniquePtr = std::unique_ptr<IBackendProfilingContext>

Definition at line 28 of file IBackendProfilingContext.hpp.

ILocalPacketHandlerPtr

using ILocalPacketHandlerPtr = std::unique_ptr<ILocalPacketHandler>

Definition at line 73 of file ILocalPacketHandler.hpp.

ILocalPacketHandlerSharedPtr

using ILocalPacketHandlerSharedPtr = std::shared_ptr<ILocalPacketHandler>

Definition at line 74 of file ILocalPacketHandler.hpp.

IPacketBufferPtr

using IPacketBufferPtr = std::unique_ptr<IPacketBuffer>

Definition at line 44 of file IPacketBuffer.hpp.

LabelMap

using LabelMap = std::map<uint64_t, arm::pipe::ITimelineDecoder::Label>

Definition at line 20 of file TimelineModel.hpp.

Relationships

using Relationships = std::map<uint64_t, ModelRelationship>

Definition at line 143 of file TimelineModel.hpp.

Enumeration Type Documentation

ProfilingRelationshipType

enum ProfilingRelationshipType

strong

Enumerator
RetentionLink
ExecutionLink	Head retains(parents) Tail.
DataLink	Head execution start depends on Tail execution completion.
LabelLink	Head uses data of Tail. Head uses label Tail (Tail MUST be a guid of a label).

Definition at line 18 of file ISendTimelinePacket.hpp.

{
    RetentionLink,    /// Head retains(parents) Tail
    ExecutionLink,    /// Head execution start depends on Tail execution completion
    DataLink,         /// Head uses data of Tail
    LabelLink         /// Head uses label Tail (Tail MUST be a guid of a label).
};

ProfilingState

enum ProfilingState

strong

Enumerator
Uninitialised
NotConnected
WaitingForAck
Active

Definition at line 18 of file ProfilingStateMachine.hpp.

{
    Uninitialised,
    NotConnected,
    WaitingForAck,
    Active
};

TargetEndianness

enum TargetEndianness

strong

Enumerator
BeWire
LeWire

Definition at line 30 of file ILocalPacketHandler.hpp.

{
    BeWire,
    LeWire
};

TimelinePacketStatus

enum TimelinePacketStatus

strong

Enumerator
Ok
Error
BufferExhaustion

Definition at line 96 of file ProfilingUtils.hpp.

{
    Ok,
    Error,
    BufferExhaustion
};

Function Documentation

CentreAlignFormatting()

std::string CentreAlignFormatting	(	const std::string &	stringToPass,
		const int	spacingWidth
	)

Definition at line 727 of file ProfilingUtils.cpp.

Referenced by PeriodicCounterCaptureCommandHandler::operator()(), CategoryRecord::print(), PrintCategoryDetails(), EventRecord::printContents(), CounterSetRecord::printContents(), DeviceRecord::printContents(), PrintCounterDetails(), PrintCounterDirectory(), PrintCounterSetDetails(), PrintDeviceDetails(), EventRecord::printHeader(), CounterSetRecord::printHeader(), and DeviceRecord::printHeader().

{
    return arm::pipe::CentreAlignFormatting(stringToPass, spacingWidth);
}

ConstructHeader() [1/2]

uint32_t ConstructHeader	(	uint32_t	packetFamily,
		uint32_t	packetId
	)

Definition at line 100 of file ProfilingUtils.cpp.

Referenced by SendCounterPacket::SendStreamMetaDataPacket(), and TEST_SUITE().

{
    return (( packetFamily & 0x0000003F ) << 26 )|
           (( packetId     & 0x000003FF ) << 16 );
}

ConstructHeader() [2/2]

uint32_t ConstructHeader	(	uint32_t	packetFamily,
		uint32_t	packetClass,
		uint32_t	packetType
	)

Definition at line 107 of file ProfilingUtils.cpp.

{
    return ((packetFamily & 0x0000003F) << 26) |
           ((packetClass  & 0x0000007F) << 19) |
           ((packetType   & 0x00000007) << 16);
}

CreateTimelineMessagePacketHeader()

std::pair<uint32_t, uint32_t> armnn::profiling::CreateTimelineMessagePacketHeader

(

unsigned int

dataLength

)

Creates a packet header for the timeline messages:

• declareLabel
• declareEntity
• declareEventClass
• declareRelationship
• declareEvent

Parameters

dataLength

The length of the message body in bytes

Returns

Pair of uint32_t containing word0 and word1 of the header

Definition at line 303 of file ProfilingUtils.cpp.

References CreateTimelinePacketHeader().

{
    return CreateTimelinePacketHeader(1,           // Packet family
                                      0,           // Packet class
                                      1,           // Packet type
                                      0,           // Stream id
                                      0,           // Sequence number
                                      dataLength); // Data length
}

CreateTimelinePacketHeader()

std::pair< uint32_t, uint32_t > CreateTimelinePacketHeader	(	uint32_t	packetFamily,
		uint32_t	packetClass,
		uint32_t	packetType,
		uint32_t	streamId,
		uint32_t	sequenceNumbered,
		uint32_t	dataLength
	)

Creates a timeline packet header.

packetFamiliy Timeline Packet Family packetClass Timeline Packet Class packetType Timeline Packet Type streamId Stream identifier seqeunceNumbered When non-zero the 4 bytes following the header is a u32 sequence number dataLength Unsigned 24-bit integer. Length of data, in bytes. Zero is permitted

Returns

Pair of uint32_t containing word0 and word1 of the header

Definition at line 263 of file ProfilingUtils.cpp.

Referenced by SendTimelinePacket::Commit(), CreateTimelineMessagePacketHeader(), and WriteTimelineMessageDirectoryPackage().

{
    // Packet header word 0:
    // 26:31 [6] packet_family: timeline Packet Family, value 0b000001
    // 19:25 [7] packet_class: packet class
    // 16:18 [3] packet_type: packet type
    // 8:15  [8] reserved: all zeros
    // 0:7   [8] stream_id: stream identifier
    uint32_t packetHeaderWord0 = ((packetFamily & 0x0000003F) << 26) |
                                 ((packetClass  & 0x0000007F) << 19) |
                                 ((packetType   & 0x00000007) << 16) |
                                 ((streamId     & 0x00000007) <<  0);

    // Packet header word 1:
    // 25:31 [7]  reserved: all zeros
    // 24    [1]  sequence_numbered: when non-zero the 4 bytes following the header is a u32 sequence number
    // 0:23  [24] data_length: unsigned 24-bit integer. Length of data, in bytes. Zero is permitted
    uint32_t packetHeaderWord1 = ((sequenceNumbered & 0x00000001) << 24) |
                                 ((dataLength       & 0x00FFFFFF) <<  0);

    return std::make_pair(packetHeaderWord0, packetHeaderWord1);
}

GetChildDescription()

std::string GetChildDescription

(

Entity *

entity

)

Definition at line 374 of file TimelineModel.cpp.

References GetEntityDescription().

Referenced by TimelineModel::GetEventClasses(), and GetModelDescription().

{
    std::stringstream ss;
    ss << "   child: " << GetEntityDescription(*entity);
    return ss.str();
}

GetConnectionDescription()

std::string GetConnectionDescription

(

const Connection &

connection

)

Definition at line 381 of file TimelineModel.cpp.

References Connection::GetGuid(), Entity::GetGuid(), Connection::GetHead(), and Connection::GetTail().

Referenced by TimelineModel::GetEventClasses(), and GetModelDescription().

{
    std::stringstream ss;
    ss << "   connection [" << connection.GetGuid() << "] from entity [";
    ss << connection.GetHead()->GetGuid() << "] to entity [" << connection.GetTail()->GetGuid() << "]";
    return ss.str();
}

GetEntityDescription()

std::string GetEntityDescription

(

const Entity &

entity

)

Definition at line 357 of file TimelineModel.cpp.

References Entity::GetAttributes(), and Entity::GetGuid().

Referenced by GetChildDescription(), TimelineModel::GetEventClasses(), GetExecutionDescription(), and GetModelDescription().

{
    std::stringstream ss;
    ss << "Entity [" << entity.GetGuid() << "]";
    for (auto& attributeEntry : entity.GetAttributes())
    {
        if (profiling::LabelsAndEventClasses::PROCESS_ID_LABEL == attributeEntry.second.first)
        {
            ss << " " << attributeEntry.second.first << " = [processId]";
        }
        else {
            ss << " " << attributeEntry.second.first << " = " << attributeEntry.second.second;
        }
    }
    return ss.str();
}

GetEventDescription()

std::string GetEventDescription

(

EventObj *

event

)

Definition at line 396 of file TimelineModel.cpp.

Referenced by TimelineModel::GetEventClasses(), and GetModelDescription().

{
    std::stringstream ss;
    ss << "   event: [" << event->GetGuid() << "] class [" << event->GetEventClass() << "]";
    return ss.str();
}

GetExecutionDescription()

std::string GetExecutionDescription

(

Entity *

execution

)

Definition at line 389 of file TimelineModel.cpp.

References GetEntityDescription().

Referenced by TimelineModel::GetEventClasses(), and GetModelDescription().

{
    std::stringstream ss;
    ss << "   execution: " << GetEntityDescription(*execution);
    return ss.str();
}

GetHardwareVersion()

std::string GetHardwareVersion

(

)

Definition at line 232 of file ProfilingUtils.cpp.

Referenced by GetStreamMetaDataPacketSize(), SendCounterPacket::SendStreamMetaDataPacket(), and TEST_SUITE().

{
    return std::string();
}

GetModelDescription()

std::vector< std::string > GetModelDescription

(

const TimelineModel &

model

)

Definition at line 330 of file TimelineModel.cpp.

References GetChildDescription(), GetConnectionDescription(), TimelineModel::GetEntities(), GetEntityDescription(), GetEventDescription(), and GetExecutionDescription().

Referenced by TimelineModel::GetEventClasses(), and TEST_SUITE().

{
    std::vector<std::string> desc;
    for (auto& entry : model.GetEntities())
    {
        auto& entity = entry.second;
        desc.push_back(GetEntityDescription(entity));
        for (auto& connection : entity.GetConnections())
        {
            desc.push_back(GetConnectionDescription(connection));
        }
        for (auto child : entity.GetChildren())
        {
            desc.push_back(GetChildDescription(child));
        }
        for (auto execution : entity.GetExecutions())
        {
            desc.push_back(GetExecutionDescription(execution));
        }
        for (auto event : entity.GetEvents())
        {
            desc.push_back(GetEventDescription(event));
        }
    }
    return desc;
}

GetNextCounterUids()

std::vector< uint16_t > GetNextCounterUids	(	uint16_t	firstUid,
		uint16_t	cores
	)

Definition at line 78 of file ProfilingUtils.cpp.

Referenced by CounterDirectory::RegisterCounter(), MockCounterDirectory::RegisterCounter(), and TEST_SUITE().

{
    // Check that it is possible to generate the next counter UID without causing an overflow (throws in case of error)
    ThrowIfCantGenerateNextUid(firstUid, cores);

    // Get the next counter UIDs
    size_t counterUidsSize = cores == 0 ? 1 : cores;
    std::vector<uint16_t> counterUids(counterUidsSize, 0);
    for (size_t i = 0; i < counterUidsSize; i++)
    {
        counterUids[i] = firstUid++;
    }
    return counterUids;
}

GetNextUid()

uint16_t GetNextUid

(

bool

peekOnly

)

Definition at line 58 of file ProfilingUtils.cpp.

Referenced by CounterDirectory::RegisterCounterSet(), MockCounterDirectory::RegisterCounterSet(), CounterDirectory::RegisterDevice(), MockCounterDirectory::RegisterDevice(), and TEST_SUITE().

{
    // The UID used for profiling objects and events. The first valid UID is 1, as 0 is a reserved value
    static uint16_t uid = 1;

    // Check that it is possible to generate the next UID without causing an overflow (throws in case of error)
    ThrowIfCantGenerateNextUid(uid);

    if (peekOnly)
    {
        // Peek only
        return uid;
    }
    else
    {
        // Get the next UID
        return uid++;
    }
}

GetProcessName()

std::string GetProcessName

(

)

Definition at line 243 of file ProfilingUtils.cpp.

Referenced by GetStreamMetaDataPacketSize(), SendCounterPacket::SendStreamMetaDataPacket(), and TEST_SUITE().

{
    std::ifstream comm("/proc/self/comm");
    std::string name;
    getline(comm, name);
    return name;
}

GetProfilingStateName()

constexpr char const* armnn::profiling::GetProfilingStateName

(

ProfilingState

state

)

Definition at line 59 of file ProfilingStateMachine.hpp.

References Active, NotConnected, Uninitialised, and WaitingForAck.

Referenced by PerJobCounterSelectionCommandHandler::operator()(), DeactivateTimelineReportingCommandHandler::operator()(), RequestCounterDirectoryCommandHandler::operator()(), ActivateTimelineReportingCommandHandler::operator()(), ConnectionAcknowledgedCommandHandler::operator()(), and PeriodicCounterSelectionCommandHandler::operator()().

{
    switch (state)
    {
        case ProfilingState::Uninitialised: return "Uninitialised";
        case ProfilingState::NotConnected:  return "NotConnected";
        case ProfilingState::WaitingForAck: return "WaitingForAck";
        case ProfilingState::Active:        return "Active";
        default:                            return "Unknown";
    }
}

GetSoftwareInfo()

std::string GetSoftwareInfo

(

)

Definition at line 227 of file ProfilingUtils.cpp.

Referenced by GetStreamMetaDataPacketSize(), SendCounterPacket::SendStreamMetaDataPacket(), and TEST_SUITE().

{
    return std::string("ArmNN");
}

GetSoftwareVersion()

std::string GetSoftwareVersion

(

)

Definition at line 237 of file ProfilingUtils.cpp.

References ARMNN_MAJOR_VERSION, and ARMNN_MINOR_VERSION.

Referenced by GetStreamMetaDataPacketSize(), SendCounterPacket::SendStreamMetaDataPacket(), and TEST_SUITE().

{
    std::string result = "Armnn " + std::to_string(ARMNN_MAJOR_VERSION) + "." + std::to_string(ARMNN_MINOR_VERSION);
    return result;
}

GetTimestamp()

uint64_t GetTimestamp

(

)

Definition at line 904 of file ProfilingUtils.cpp.

Referenced by TimelineUtilityMethods::RecordEvent(), and PeriodicCounterCapture::Stop().

{
#if USE_CLOCK_MONOTONIC_RAW
    using clock = MonotonicClockRaw;
#else
    using clock = std::chrono::steady_clock;
#endif

    // Take a timestamp
    auto timestamp = std::chrono::duration_cast<std::chrono::nanoseconds>(clock::now().time_since_epoch());

    return static_cast<uint64_t>(timestamp.count());
}

PrintCategoryDetails()

void armnn::profiling::PrintCategoryDetails	(	const std::unique_ptr< Category > &	category,
		std::unordered_map< unsigned short, std::shared_ptr< Counter >>	counterMap
	)

Definition at line 794 of file ProfilingUtils.cpp.

References CentreAlignFormatting(), and PrintCounterDetails().

Referenced by PrintCounterDirectory().

{
    std::string categoryBody;
    std::string categoryHeader;

    categoryHeader.append(CentreAlignFormatting("Name", 20));
    categoryHeader.append(" | ");
    categoryHeader.append(CentreAlignFormatting("Event Count", 14));
    categoryHeader.append("\n");

    categoryBody.append(CentreAlignFormatting(category->m_Name, 20));
    categoryBody.append(" | ");
    categoryBody.append(CentreAlignFormatting(std::to_string(category->m_Counters.size()), 14));

    std::cout << "\n" << "\n";
    std::cout << CentreAlignFormatting("CATEGORY", static_cast<int>(categoryHeader.size()));
    std::cout << "\n";
    std::cout << std::string(categoryHeader.size(), '=') << "\n";

    std::cout << categoryHeader;

    std::cout << std::string(categoryBody.size(), '-') << "\n";

    std::cout << categoryBody;

    std::string counterHeader;

    counterHeader.append(CentreAlignFormatting("Counter Name", 20));
    counterHeader.append(" | ");
    counterHeader.append(CentreAlignFormatting("Description", 50));
    counterHeader.append(" | ");
    counterHeader.append(CentreAlignFormatting("Units", 14));
    counterHeader.append(" | ");
    counterHeader.append(CentreAlignFormatting("UID", 6));
    counterHeader.append(" | ");
    counterHeader.append(CentreAlignFormatting("Max UID", 10));
    counterHeader.append(" | ");
    counterHeader.append(CentreAlignFormatting("Class", 8));
    counterHeader.append(" | ");
    counterHeader.append(CentreAlignFormatting("Interpolation", 14));
    counterHeader.append(" | ");
    counterHeader.append(CentreAlignFormatting("Multiplier", 20));
    counterHeader.append(" | ");
    counterHeader.append(CentreAlignFormatting("Counter set UID", 16));
    counterHeader.append(" | ");
    counterHeader.append(CentreAlignFormatting("Device UID", 14));
    counterHeader.append("\n");

    std::cout << "\n" << "\n";
    std::cout << CentreAlignFormatting("EVENTS IN CATEGORY: " + category->m_Name,
                                       static_cast<int>(counterHeader.size()));
    std::cout << "\n";
    std::cout << std::string(counterHeader.size(), '=') << "\n";
    std::cout << counterHeader;
    for (auto& it: category->m_Counters) {
        auto search = counterMap.find(it);
        if(search != counterMap.end()) {
            PrintCounterDetails(search->second);
        }
    }
}

PrintCounterDetails()

void armnn::profiling::PrintCounterDetails

(

std::shared_ptr< Counter > &

counter

)

Definition at line 763 of file ProfilingUtils.cpp.

References CentreAlignFormatting().

Referenced by PrintCategoryDetails().

{
    std::string body;

    body.append(CentreAlignFormatting(counter->m_Name, 20));
    body.append(" | ");
    body.append(CentreAlignFormatting(counter->m_Description, 50));
    body.append(" | ");
    body.append(CentreAlignFormatting(counter->m_Units, 14));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(counter->m_Uid), 6));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(counter->m_MaxCounterUid), 10));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(counter->m_Class), 8));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(counter->m_Interpolation), 14));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(counter->m_Multiplier), 20));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(counter->m_CounterSetUid), 16));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(counter->m_DeviceUid), 14));

    body.append("\n");

    std::cout << std::string(body.size(), '-') << "\n";

    std::cout << body;
}

PrintCounterDirectory()

void PrintCounterDirectory

(

ICounterDirectory &

counterDirectory

)

Definition at line 857 of file ProfilingUtils.cpp.

References CentreAlignFormatting(), ICounterDirectory::GetCategories(), ICounterDirectory::GetCounters(), ICounterDirectory::GetCounterSets(), ICounterDirectory::GetDevices(), PrintCategoryDetails(), PrintCounterSetDetails(), and PrintDeviceDetails().

Referenced by DirectoryCaptureCommandHandler::operator()().

{
    std::string devicesHeader;

    devicesHeader.append(CentreAlignFormatting("Device name", 20));
    devicesHeader.append(" | ");
    devicesHeader.append(CentreAlignFormatting("UID", 13));
    devicesHeader.append(" | ");
    devicesHeader.append(CentreAlignFormatting("Cores", 10));
    devicesHeader.append("\n");

    std::cout << "\n" << "\n";
    std::cout << CentreAlignFormatting("DEVICES", static_cast<int>(devicesHeader.size()));
    std::cout << "\n";
    std::cout << std::string(devicesHeader.size(), '=') << "\n";
    std::cout << devicesHeader;
    for (auto& it: counterDirectory.GetDevices()) {
        PrintDeviceDetails(it);
    }

    std::string counterSetHeader;

    counterSetHeader.append(CentreAlignFormatting("Counter set name", 20));
    counterSetHeader.append(" | ");
    counterSetHeader.append(CentreAlignFormatting("UID", 13));
    counterSetHeader.append(" | ");
    counterSetHeader.append(CentreAlignFormatting("Count", 10));
    counterSetHeader.append("\n");

    std::cout << "\n" << "\n";
    std::cout << CentreAlignFormatting("COUNTER SETS", static_cast<int>(counterSetHeader.size()));
    std::cout << "\n";
    std::cout << std::string(counterSetHeader.size(), '=') << "\n";

    std::cout << counterSetHeader;

    for (auto& it: counterDirectory.GetCounterSets()) {
        PrintCounterSetDetails(it);
    }

    auto counters = counterDirectory.GetCounters();
    for (auto& it: counterDirectory.GetCategories()) {
        PrintCategoryDetails(it, counters);
    }
    std::cout << "\n";
}

PrintCounterSetDetails()

void armnn::profiling::PrintCounterSetDetails

(

const std::pair< const unsigned short, std::unique_ptr< CounterSet >> &

counterSetPair

)

Definition at line 747 of file ProfilingUtils.cpp.

References CentreAlignFormatting().

Referenced by PrintCounterDirectory().

{
    std::string body;

    body.append(CentreAlignFormatting(counterSetPair.second->m_Name, 20));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(counterSetPair.first), 13));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(counterSetPair.second->m_Count), 10));
    body.append("\n");

    std::cout << std::string(body.size(), '-') << "\n";

    std::cout<< body;
}

PrintDeviceDetails()

void armnn::profiling::PrintDeviceDetails

(

const std::pair< const unsigned short, std::unique_ptr< Device >> &

devicePair

)

Definition at line 732 of file ProfilingUtils.cpp.

References CentreAlignFormatting().

Referenced by PrintCounterDirectory().

{
    std::string body;

    body.append(CentreAlignFormatting(devicePair.second->m_Name, 20));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(devicePair.first), 13));
    body.append(" | ");
    body.append(CentreAlignFormatting(std::to_string(devicePair.second->m_Cores), 10));
    body.append("\n");

    std::cout << std::string(body.size(), '-') << "\n";
    std::cout<< body;
}

ReadBytes() [1/2]

void ReadBytes	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset,
		unsigned int	valueSize,
		uint8_t	outValue[]
	)

Definition at line 167 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by TEST_SUITE(), and VerifyTimelineEventBinaryPacket().

{
    ARMNN_ASSERT(packetBuffer);

    ReadBytes(packetBuffer->GetReadableData(), offset, valueSize, outValue);
}

ReadBytes() [2/2]

void ReadBytes	(	const unsigned char *	buffer,
		unsigned int	offset,
		unsigned int	valueSize,
		uint8_t	outValue[]
	)

Definition at line 202 of file ProfilingUtils.cpp.

{
    arm::pipe::ReadBytes(buffer, offset, valueSize, outValue);
}

ReadUint16() [1/2]

uint16_t ReadUint16	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset
	)

Definition at line 188 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by armnn::gatordmock::ReadString(), and TEST_SUITE().

{
    ARMNN_ASSERT(packetBuffer);

    return ReadUint16(packetBuffer->GetReadableData(), offset);
}

ReadUint16() [2/2]

uint16_t ReadUint16	(	const unsigned char *	buffer,
		unsigned int	offset
	)

Definition at line 217 of file ProfilingUtils.cpp.

{
    return arm::pipe::ReadUint16(buffer, offset);
}

ReadUint32() [1/2]

uint32_t ReadUint32	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset
	)

Definition at line 181 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by PeriodicCounterSelectionResponseHandler::operator()(), armnn::gatordmock::ReadString(), TEST_SUITE(), VerifyTimelineEntityBinaryPacketData(), VerifyTimelineEventBinaryPacket(), VerifyTimelineEventClassBinaryPacketData(), VerifyTimelineHeaderBinary(), VerifyTimelineLabelBinaryPacketData(), VerifyTimelineRelationshipBinaryPacketData(), and MockProfilingConnection::WritePacket().

{
    ARMNN_ASSERT(packetBuffer);

    return ReadUint32(packetBuffer->GetReadableData(), offset);
}

ReadUint32() [2/2]

uint32_t ReadUint32	(	const unsigned char *	buffer,
		unsigned int	offset
	)

Definition at line 212 of file ProfilingUtils.cpp.

{
    return arm::pipe::ReadUint32(buffer, offset);
}

ReadUint64() [1/2]

uint64_t ReadUint64	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset
	)

Definition at line 174 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by TEST_SUITE(), VerifyTimelineEntityBinaryPacketData(), VerifyTimelineEventBinaryPacket(), VerifyTimelineEventClassBinaryPacketData(), VerifyTimelineLabelBinaryPacketData(), and VerifyTimelineRelationshipBinaryPacketData().

{
    ARMNN_ASSERT(packetBuffer);

    return ReadUint64(packetBuffer->GetReadableData(), offset);
}

ReadUint64() [2/2]

uint64_t ReadUint64	(	const unsigned char *	buffer,
		unsigned int	offset
	)

Definition at line 207 of file ProfilingUtils.cpp.

{
    return arm::pipe::ReadUint64(buffer, offset);
}

ReadUint8() [1/2]

uint8_t ReadUint8	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset
	)

Definition at line 195 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by DirectoryCaptureCommandHandler::GetCounterDirectory(), and TEST_SUITE().

{
    ARMNN_ASSERT(packetBuffer);

    return ReadUint8(packetBuffer->GetReadableData(), offset);
}

ReadUint8() [2/2]

uint8_t ReadUint8	(	const unsigned char *	buffer,
		unsigned int	offset
	)

Definition at line 222 of file ProfilingUtils.cpp.

{
    return arm::pipe::ReadUint8(buffer, offset);
}

ReceivePacket()

arm::pipe::Packet ReceivePacket	(	const unsigned char *	buffer,
		uint32_t	length
	)

Definition at line 918 of file ProfilingUtils.cpp.

Referenced by FileOnlyProfilingConnection::WritePacket().

{
    if (buffer == nullptr)
    {
        throw arm::pipe::ProfilingException("data buffer is nullptr");
    }
    if (length < 8)
    {
        throw arm::pipe::ProfilingException("length of data buffer is less than 8");
    }

    uint32_t metadataIdentifier = 0;
    std::memcpy(&metadataIdentifier, buffer, sizeof(metadataIdentifier));

    uint32_t dataLength = 0;
    std::memcpy(&dataLength, buffer + 4u, sizeof(dataLength));

    std::unique_ptr<unsigned char[]> packetData;
    if (dataLength > 0)
    {
        packetData = std::make_unique<unsigned char[]>(dataLength);
        std::memcpy(packetData.get(), buffer + 8u, dataLength);
    }

    return arm::pipe::Packet(metadataIdentifier, dataLength, packetData);
}

WriteBytes() [1/3]

void armnn::profiling::WriteBytes	(	const IPacketBuffer &	packetBuffer,
		unsigned int	offset,
		const void *	value,
		unsigned int	valueSize
	)

WriteBytes() [2/3]

void armnn::profiling::WriteBytes	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset,
		const void *	value,
		unsigned int	valueSize
	)

Definition at line 93 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by WriteTimelineEventBinary().

{
    ARMNN_ASSERT(packetBuffer);

    WriteBytes(packetBuffer->GetWritableData(), offset, value, valueSize);
}

WriteBytes() [3/3]

void WriteBytes	(	unsigned char *	buffer,
		unsigned int	offset,
		const void *	value,
		unsigned int	valueSize
	)

Definition at line 142 of file ProfilingUtils.cpp.

{
    arm::pipe::WriteBytes(buffer, offset, value, valueSize);
}

WriteTimelineEntityBinary()

TimelinePacketStatus WriteTimelineEntityBinary	(	uint64_t	profilingGuid,
		unsigned char *	buffer,
		unsigned int	remainingBufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 376 of file ProfilingUtils.cpp.

References BufferExhaustion, Ok, uint32_t_size, WriteUint32(), and WriteUint64().

Referenced by SendTimelinePacket::SendTimelineEntityBinaryPacket(), and TEST_SUITE().

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || remainingBufferSize == 0)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Utils
    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);

    // Calculate the length of the data (in bytes)
    unsigned int timelineEntityDataLength = uint32_t_size + uint64_t_size;  // decl_id + Profiling GUID

    // Check whether the timeline binary packet fits in the given buffer
    if (timelineEntityDataLength > remainingBufferSize)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Initialize the offset for writing in the buffer
    unsigned int offset = 0;

    // Write the decl_Id to the buffer
    WriteUint32(buffer, offset, 1u);
    offset += uint32_t_size;

    // Write the timeline binary packet payload to the buffer
    WriteUint64(buffer, offset, profilingGuid); // Profiling GUID

    // Update the number of bytes written
    numberOfBytesWritten = timelineEntityDataLength;

    return TimelinePacketStatus::Ok;
}

WriteTimelineEventBinary()

TimelinePacketStatus WriteTimelineEventBinary	(	uint64_t	timestamp,
		int	threadId,
		uint64_t	profilingGuid,
		unsigned char *	buffer,
		unsigned int	remainingBufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 675 of file ProfilingUtils.cpp.

References BufferExhaustion, Ok, ThreadIdSize, uint32_t_size, WriteBytes(), WriteUint32(), and WriteUint64().

Referenced by SendTimelinePacket::SendTimelineEventBinaryPacket(), and TEST_SUITE().

{
    // Initialize the output value
    numberOfBytesWritten = 0;
    // Check that the given buffer is valid
    if (buffer == nullptr || remainingBufferSize == 0)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Utils
    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);

    // decl_id of the timeline message
    uint32_t declId = 4;

    // Calculate the length of the data (in bytes)
    unsigned int timelineEventDataLength = uint32_t_size + // decl_id
                                           uint64_t_size + // Timestamp
                                           ThreadIdSize +  // Thread id
                                           uint64_t_size;  // Profiling GUID

    // Check whether the timeline binary packet fits in the given buffer
    if (timelineEventDataLength > remainingBufferSize)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Initialize the offset for writing in the buffer
    unsigned int offset = 0;

    // Write the timeline binary payload to the buffer
    WriteUint32(buffer, offset, declId); // decl_id
    offset += uint32_t_size;
    WriteUint64(buffer, offset, timestamp); // Timestamp
    offset += uint64_t_size;
    WriteBytes(buffer, offset, &threadId, ThreadIdSize); // Thread id
    offset += ThreadIdSize;
    WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
    offset += uint64_t_size;
    // Update the number of bytes written
    numberOfBytesWritten = timelineEventDataLength;

    return TimelinePacketStatus::Ok;
}

WriteTimelineEventClassBinary()

TimelinePacketStatus WriteTimelineEventClassBinary	(	uint64_t	profilingGuid,
		uint64_t	nameGuid,
		unsigned char *	buffer,
		unsigned int	remainingBufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 628 of file ProfilingUtils.cpp.

References BufferExhaustion, Ok, uint32_t_size, WriteUint32(), and WriteUint64().

Referenced by SendTimelinePacket::SendTimelineEventClassBinaryPacket(), and TEST_SUITE().

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || remainingBufferSize == 0)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Utils
    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);

    // decl_id of the timeline message
    uint32_t declId = 2;

    // Calculate the length of the data (in bytes)
    unsigned int dataSize = uint32_t_size + (uint64_t_size * 2); // decl_id + Profiling GUID + Name GUID

    // Check whether the timeline binary fits in the given buffer
    if (dataSize > remainingBufferSize)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Initialize the offset for writing in the buffer
    unsigned int offset = 0;

    // Write the timeline binary payload to the buffer
    WriteUint32(buffer, offset, declId);        // decl_id
    offset += uint32_t_size;
    WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
    offset += uint64_t_size;
    WriteUint64(buffer, offset, nameGuid); // Name GUID

    // Update the number of bytes written
    numberOfBytesWritten = dataSize;

    return TimelinePacketStatus::Ok;
}

WriteTimelineLabelBinaryPacket()

TimelinePacketStatus WriteTimelineLabelBinaryPacket	(	uint64_t	profilingGuid,
		const std::string &	label,
		unsigned char *	buffer,
		unsigned int	remainingBufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 313 of file ProfilingUtils.cpp.

References BufferExhaustion, Error, armnn::numeric_cast(), Ok, uint32_t_size, WriteUint32(), and WriteUint64().

Referenced by SendTimelinePacket::SendTimelineLabelBinaryPacket(), and TEST_SUITE().

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || remainingBufferSize == 0)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Utils
    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);

    // Convert the label into a SWTrace string
    std::vector<uint32_t> swTraceLabel;
    bool result = arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>(label, swTraceLabel);
    if (!result)
    {
        return TimelinePacketStatus::Error;
    }

    // Calculate the size of the SWTrace string label (in bytes)
    unsigned int swTraceLabelSize = armnn::numeric_cast<unsigned int>(swTraceLabel.size()) * uint32_t_size;

    // Calculate the length of the data (in bytes)
    unsigned int timelineLabelPacketDataLength = uint32_t_size +   // decl_Id
                                                 uint64_t_size +   // Profiling GUID
                                                 swTraceLabelSize; // Label

    // Check whether the timeline binary packet fits in the given buffer
    if (timelineLabelPacketDataLength > remainingBufferSize)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Initialize the offset for writing in the buffer
    unsigned int offset = 0;

    // Write decl_Id to the buffer
    WriteUint32(buffer, offset, 0u);
    offset += uint32_t_size;

    // Write the timeline binary packet payload to the buffer
    WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
    offset += uint64_t_size;
    for (uint32_t swTraceLabelWord : swTraceLabel)
    {
        WriteUint32(buffer, offset, swTraceLabelWord); // Label
        offset += uint32_t_size;
    }

    // Update the number of bytes written
    numberOfBytesWritten = timelineLabelPacketDataLength;

    return TimelinePacketStatus::Ok;
}

WriteTimelineMessageDirectoryPackage()

TimelinePacketStatus WriteTimelineMessageDirectoryPackage	(	unsigned char *	buffer,
		unsigned int	remainingBufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 497 of file ProfilingUtils.cpp.

References BufferExhaustion, CreateTimelinePacketHeader(), Error, armnn::numeric_cast(), Ok, ThreadIdSize, uint32_t_size, WriteUint32(), and WriteUint8().

Referenced by SendTimelinePacket::SendTimelineMessageDirectoryPackage(), and TEST_SUITE().

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || remainingBufferSize == 0)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Utils
    unsigned int uint8_t_size  = sizeof(uint8_t);
    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);

    // The payload/data of the packet consists of swtrace event definitions encoded according
    // to the swtrace directory specification. The messages being the five defined below:
    //
    // |  decl_id  |     decl_name       |      ui_name          |  arg_types  |            arg_names                |
    // |-----------|---------------------|-----------------------|-------------|-------------------------------------|
    // |    0      |   declareLabel      |   declare label       |    ps       |  guid,value                         |
    // |    1      |   declareEntity     |   declare entity      |    p        |  guid                               |
    // |    2      | declareEventClass   |  declare event class  |    pp       |  guid,nameGuid                      |
    // |    3      | declareRelationship | declare relationship  |    Ipppp    |  relationshipType,relationshipGuid, |
    // |           |                     |                       |             |  headGuid,tailGuid,attributeGuid    |
    // |    4      |   declareEvent      |   declare event       |    @tp      |  timestamp,threadId,eventGuid       |
    std::vector<std::vector<std::string>> timelineDirectoryMessages
    {
        { "0", "declareLabel", "declare label", "ps", "guid,value" },
        { "1", "declareEntity", "declare entity", "p", "guid" },
        { "2", "declareEventClass", "declare event class", "pp", "guid,nameGuid" },
        { "3", "declareRelationship", "declare relationship", "Ipppp",
          "relationshipType,relationshipGuid,headGuid,tailGuid,attributeGuid" },
        { "4", "declareEvent", "declare event", "@tp", "timestamp,threadId,eventGuid" }
    };

    // Build the message declarations
    std::vector<uint32_t> swTraceBuffer;
    for (const auto& directoryComponent : timelineDirectoryMessages)
    {
        // decl_id
        uint32_t declId = 0;
        try
        {
            declId = armnn::numeric_cast<uint32_t>(std::stoul(directoryComponent[0]));
        }
        catch (const std::exception&)
        {
            return TimelinePacketStatus::Error;
        }
        swTraceBuffer.push_back(declId);

        bool result = true;
        result &= arm::pipe::ConvertDirectoryComponent<arm::pipe::SwTraceNameCharPolicy>(
                      directoryComponent[1], swTraceBuffer); // decl_name
        result &= arm::pipe::ConvertDirectoryComponent<arm::pipe::SwTraceCharPolicy>    (
                      directoryComponent[2], swTraceBuffer); // ui_name
        result &= arm::pipe::ConvertDirectoryComponent<arm::pipe::SwTraceTypeCharPolicy>(
                      directoryComponent[3], swTraceBuffer); // arg_types
        result &= arm::pipe::ConvertDirectoryComponent<arm::pipe::SwTraceCharPolicy>    (
                      directoryComponent[4], swTraceBuffer); // arg_names
        if (!result)
        {
            return TimelinePacketStatus::Error;
        }
    }

    unsigned int dataLength = 3 * uint8_t_size +  // Stream header (3 bytes)
                              armnn::numeric_cast<unsigned int>(swTraceBuffer.size()) *
                                  uint32_t_size; // Trace directory (5 messages)

    // Calculate the timeline directory binary packet size (in bytes)
    unsigned int timelineDirectoryPacketSize = 2 * uint32_t_size + // Header (2 words)
                                               dataLength;         // Payload

    // Check whether the timeline directory binary packet fits in the given buffer
    if (timelineDirectoryPacketSize > remainingBufferSize)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Create packet header
    auto packetHeader = CreateTimelinePacketHeader(1, 0, 0, 0, 0, armnn::numeric_cast<uint32_t>(dataLength));

    // Initialize the offset for writing in the buffer
    unsigned int offset = 0;

    // Write the timeline binary packet header to the buffer
    WriteUint32(buffer, offset, packetHeader.first);
    offset += uint32_t_size;
    WriteUint32(buffer, offset, packetHeader.second);
    offset += uint32_t_size;

    // Write the stream header
    uint8_t streamVersion = 4;
    uint8_t pointerBytes  = armnn::numeric_cast<uint8_t>(uint64_t_size); // All GUIDs are uint64_t
    uint8_t threadIdBytes = armnn::numeric_cast<uint8_t>(ThreadIdSize);
    switch (threadIdBytes)
    {
    case 4: // Typically Windows and Android
    case 8: // Typically Linux
        break; // Valid values
    default:
        return TimelinePacketStatus::Error; // Invalid value
    }
    WriteUint8(buffer, offset, streamVersion);
    offset += uint8_t_size;
    WriteUint8(buffer, offset, pointerBytes);
    offset += uint8_t_size;
    WriteUint8(buffer, offset, threadIdBytes);
    offset += uint8_t_size;

    // Write the SWTrace directory
    uint32_t numberOfDeclarations = armnn::numeric_cast<uint32_t>(timelineDirectoryMessages.size());
    WriteUint32(buffer, offset, numberOfDeclarations); // Number of declarations
    offset += uint32_t_size;
    for (uint32_t i : swTraceBuffer)
    {
        WriteUint32(buffer, offset, i); // Message declarations
        offset += uint32_t_size;
    }

    // Update the number of bytes written
    numberOfBytesWritten = timelineDirectoryPacketSize;

    return TimelinePacketStatus::Ok;
}

WriteTimelineRelationshipBinary()

TimelinePacketStatus WriteTimelineRelationshipBinary	(	ProfilingRelationshipType	relationshipType,
		uint64_t	relationshipGuid,
		uint64_t	headGuid,
		uint64_t	tailGuid,
		uint64_t	attributeGuid,
		unsigned char *	buffer,
		unsigned int	remainingBufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 419 of file ProfilingUtils.cpp.

References BufferExhaustion, DataLink, ExecutionLink, LabelLink, Ok, RetentionLink, uint32_t_size, WriteUint32(), and WriteUint64().

Referenced by SendTimelinePacket::SendTimelineRelationshipBinaryPacket(), and TEST_SUITE().

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || remainingBufferSize == 0)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Utils
    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);

    // Calculate the length of the data (in bytes)
    unsigned int timelineRelationshipDataLength = uint32_t_size * 2 + // decl_id + Relationship Type
                                                  uint64_t_size * 4;  // Relationship GUID + Head GUID +
                                                                      // tail GUID + attributeGuid

    // Check whether the timeline binary fits in the given buffer
    if (timelineRelationshipDataLength > remainingBufferSize)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Initialize the offset for writing in the buffer
    unsigned int offset = 0;

    uint32_t relationshipTypeUint = 0;

    switch (relationshipType)
    {
        case ProfilingRelationshipType::RetentionLink:
            relationshipTypeUint = 0;
            break;
        case ProfilingRelationshipType::ExecutionLink:
            relationshipTypeUint = 1;
            break;
        case ProfilingRelationshipType::DataLink:
            relationshipTypeUint = 2;
            break;
        case ProfilingRelationshipType::LabelLink:
            relationshipTypeUint = 3;
            break;
        default:
            throw InvalidArgumentException("Unknown relationship type given.");
    }

    // Write the timeline binary payload to the buffer
    // decl_id of the timeline message
    uint32_t declId = 3;
    WriteUint32(buffer, offset, declId); // decl_id
    offset += uint32_t_size;
    WriteUint32(buffer, offset, relationshipTypeUint); // Relationship Type
    offset += uint32_t_size;
    WriteUint64(buffer, offset, relationshipGuid); // GUID of this relationship
    offset += uint64_t_size;
    WriteUint64(buffer, offset, headGuid); // head of relationship GUID
    offset += uint64_t_size;
    WriteUint64(buffer, offset, tailGuid); // tail of relationship GUID
    offset += uint64_t_size;
    WriteUint64(buffer, offset, attributeGuid); // attribute of relationship GUID


    // Update the number of bytes written
    numberOfBytesWritten = timelineRelationshipDataLength;

    return TimelinePacketStatus::Ok;
}

WriteUint16() [1/2]

void WriteUint16	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset,
		uint16_t	value
	)

Definition at line 128 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by RequestCountersPacketHandler::HandlePacket(), PacketWriter(), SendCounterPacket::SendPeriodicCounterCapturePacket(), GatordMockService::SendPeriodicCounterSelectionList(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), and TEST_SUITE().

{
    ARMNN_ASSERT(packetBuffer);

    WriteUint16(packetBuffer->GetWritableData(), offset, value);
}

WriteUint16() [2/2]

void WriteUint16	(	unsigned char *	buffer,
		unsigned int	offset,
		uint16_t	value
	)

Definition at line 157 of file ProfilingUtils.cpp.

{
    arm::pipe::WriteUint16(buffer, offset, value);
}

WriteUint32() [1/2]

void WriteUint32	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset,
		uint32_t	value
	)

Definition at line 121 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by SendTimelinePacket::Commit(), RequestCountersPacketHandler::HandlePacket(), PacketWriter(), SendCounterPacket::SendPeriodicCounterCapturePacket(), GatordMockService::SendPeriodicCounterSelectionList(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), SendCounterPacket::SendStreamMetaDataPacket(), TEST_SUITE(), WriteTimelineEntityBinary(), WriteTimelineEventBinary(), WriteTimelineEventClassBinary(), WriteTimelineLabelBinaryPacket(), WriteTimelineMessageDirectoryPackage(), and WriteTimelineRelationshipBinary().

{
    ARMNN_ASSERT(packetBuffer);

    WriteUint32(packetBuffer->GetWritableData(), offset, value);
}

WriteUint32() [2/2]

void WriteUint32	(	unsigned char *	buffer,
		unsigned int	offset,
		uint32_t	value
	)

Definition at line 152 of file ProfilingUtils.cpp.

{
    arm::pipe::WriteUint32(buffer, offset, value);
}

WriteUint64() [1/3]

void armnn::profiling::WriteUint64	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset,
		uint64_t	value
	)

WriteUint64() [2/3]

void armnn::profiling::WriteUint64	(	const std::unique_ptr< IPacketBuffer > &	packetBuffer,
		unsigned int	offset,
		uint64_t	value
	)

Definition at line 114 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by SendCounterPacket::SendPeriodicCounterCapturePacket(), TEST_SUITE(), WriteTimelineEntityBinary(), WriteTimelineEventBinary(), WriteTimelineEventClassBinary(), WriteTimelineLabelBinaryPacket(), and WriteTimelineRelationshipBinary().

{
    ARMNN_ASSERT(packetBuffer);

    WriteUint64(packetBuffer->GetWritableData(), offset, value);
}

WriteUint64() [3/3]

void WriteUint64	(	unsigned char *	buffer,
		unsigned int	offset,
		uint64_t	value
	)

Definition at line 147 of file ProfilingUtils.cpp.

{
    arm::pipe::WriteUint64(buffer, offset, value);
}

WriteUint8() [1/2]

void WriteUint8	(	const IPacketBufferPtr &	packetBuffer,
		unsigned int	offset,
		uint8_t	value
	)

Definition at line 135 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by WriteTimelineMessageDirectoryPackage().

{
    ARMNN_ASSERT(packetBuffer);

    WriteUint8(packetBuffer->GetWritableData(), offset, value);
}

WriteUint8() [2/2]

void WriteUint8	(	unsigned char *	buffer,
		unsigned int	offset,
		uint8_t	value
	)

Definition at line 162 of file ProfilingUtils.cpp.

{
    arm::pipe::WriteUint8(buffer, offset, value);
}

Variable Documentation

ThreadIdSize

constexpr unsigned int ThreadIdSize = sizeof(int)

Definition at line 31 of file ProfilingUtils.hpp.

Referenced by TEST_SUITE(), VerifyPostOptimisationStructureTestImpl(), VerifyTimelineEventBinaryPacket(), WriteTimelineEventBinary(), and WriteTimelineMessageDirectoryPackage().

uint16_t_size

uint32_t uint16_t_size = sizeof(uint16_t)

Definition at line 21 of file DirectoryCaptureCommandHandler.cpp.

Referenced by RequestCountersPacketHandler::HandlePacket(), armnn::gatordmock::ReadString(), SendCounterPacket::SendPeriodicCounterCapturePacket(), and SendCounterPacket::SendPeriodicCounterSelectionPacket().

uint32_t_size

uint32_t uint32_t_size = sizeof(uint32_t)

Definition at line 22 of file DirectoryCaptureCommandHandler.cpp.

Referenced by SendCounterPacket::CreateCategoryRecord(), SendCounterPacket::CreateEventRecord(), RequestCountersPacketHandler::HandlePacket(), OffsetToNextWord(), armnn::gatordmock::ReadString(), SendCounterPacket::SendCounterDirectoryPacket(), SendCounterPacket::SendPeriodicCounterCapturePacket(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), TEST_SUITE(), VerifyTimelineEntityBinaryPacketData(), VerifyTimelineEventBinaryPacket(), VerifyTimelineEventClassBinaryPacketData(), VerifyTimelineHeaderBinary(), VerifyTimelineLabelBinaryPacketData(), VerifyTimelineRelationshipBinaryPacketData(), WriteTimelineEntityBinary(), WriteTimelineEventBinary(), WriteTimelineEventClassBinary(), WriteTimelineLabelBinaryPacket(), WriteTimelineMessageDirectoryPackage(), and WriteTimelineRelationshipBinary().