armnn::profiling Namespace Reference

Classes
class	BackendProfiling
class	BufferExhaustion
class	BufferManager
class	CaptureData
class	Category
class	CommandHandler
class	CommandHandlerFunctor
struct	CommandHandlerHash
class	CommandHandlerKey
class	CommandHandlerRegistry
class	ConnectionAcknowledgedCommandHandler
class	Counter
class	CounterDirectory
struct	CounterDirectoryEventRecord
class	CounterIdMap
class	CounterSet
struct	CounterStatus
struct	CounterValue
class	Device
class	DirectoryCaptureCommandHandler
class	FileOnlyProfilingConnection
class	Holder
class	IBackendProfiling
class	IBackendProfilingContext
class	IBufferManager
class	IConsumer
class	ICounterDirectory
class	ICounterMappings
class	ICounterRegistry
class	IPacketBuffer
class	IPeriodicCounterCapture
class	IProfilingConnection
class	IProfilingConnectionFactory
class	IProfilingGuidGenerator
class	IProfilingService
class	IReadCounterValues
class	IReadOnlyPacketBuffer
class	IReadWriteCounterValues
class	IRegisterBackendCounters
class	IRegisterCounterMapping
class	ISendCounterPacket
class	ISendThread
class	ISendTimelinePacket
class	IWriteCounterValues
class	LabelsAndEventClasses
struct	LogLevelSwapper
class	MockBufferManager
class	MockCounterDirectory
class	MockPacketBuffer
class	MockProfilingConnection
class	MockProfilingConnectionFactory
class	MockProfilingService
class	MockSendCounterPacket
class	MockStreamCounterBuffer
class	Packet
class	PacketBuffer
class	PacketKey
class	PacketVersionResolver
class	PeriodicCounterCapture
class	PeriodicCounterSelectionCommandHandler
class	PerJobCounterSelectionCommandHandler
class	ProfilingConnectionDumpToFileDecorator
class	ProfilingConnectionFactory
struct	ProfilingDynamicGuid
	Strongly typed guids to distinguish between those generated at runtime, and those that are statically defined. More...
class	ProfilingGuid
class	ProfilingGuidGenerator
class	ProfilingService
class	ProfilingServiceRuntimeHelper
class	ProfilingStateMachine
struct	ProfilingStaticGuid
class	RegisterBackendCounters
class	RequestCounterDirectoryCommandHandler
class	SendCounterPacket
class	SendCounterPacketTest
class	SendThread
class	SendTimelinePacket
class	SocketProfilingConnection
struct	StreamRedirector
class	SwapProfilingConnectionFactoryHelper
struct	SwTraceCharPolicy
struct	SwTraceHeader
struct	SwTraceMessage
struct	SwTraceNameCharPolicy
struct	SwTraceTypeCharPolicy
class	TestFunctorA
class	TestFunctorB
class	TestFunctorC
class	TestProfilingConnectionArmnnError
class	TestProfilingConnectionBadAckPacket
class	TestProfilingConnectionBase
class	TestProfilingConnectionTimeoutError
class	TimelinePacketWriterFactory
class	TimelineUtilityMethods
struct	Timestamp
class	Version

Typedefs
using	IBackendProfilingContextUniquePtr = std::unique_ptr< IBackendProfilingContext >
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 >

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

Functions
constexpr uint32_t	EncodeVersion (uint32_t major, uint32_t minor, uint32_t patch)
std::ostream &	operator<< (std::ostream &os, const Version &version)
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 ()
uint32_t	CalculateSizeOfPaddedSwString (const std::string &str)
SwTraceMessage	ReadSwTraceMessage (const unsigned char *packetBuffer, unsigned int &offset)
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)
std::pair< uint32_t, uint32_t >	CreateTimelineMessagePacketHeader (unsigned int dataLength)
TimelinePacketStatus	WriteTimelineLabelBinaryPacket (uint64_t profilingGuid, const std::string &label, unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineEntityBinaryPacket (uint64_t profilingGuid, unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineRelationshipBinaryPacket (ProfilingRelationshipType relationshipType, uint64_t relationshipGuid, uint64_t headGuid, uint64_t tailGuid, unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineMessageDirectoryPackage (unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineEventClassBinaryPacket (uint64_t profilingGuid, unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineEventBinaryPacket (uint64_t timestamp, std::thread::id threadId, uint64_t profilingGuid, unsigned char *buffer, unsigned int bufferSize, 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 ()
template<typename SwTracePolicy >
bool	IsValidSwTraceString (const std::string &s)
template<typename SwTracePolicy >
bool	StringToSwTraceString (const std::string &s, std::vector< uint32_t > &outputBuffer)
template<typename SwTracePolicy , typename SwTraceBuffer = std::vector<uint32_t>>
bool	ConvertDirectoryComponent (const std::string &directoryComponent, SwTraceBuffer &swTraceBuffer)
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)

Variables
uint32_t	uint16_t_size = sizeof(uint16_t)
uint32_t	uint32_t_size = sizeof(uint32_t)

Typedef Documentation

Categories

using Categories = std::unordered_set<CategoryPtr>

Definition at line 37 of file ICounterDirectory.hpp.

CategoriesIt

using CategoriesIt = Categories::const_iterator

Definition at line 43 of file ICounterDirectory.hpp.

CategoryPtr

using CategoryPtr = std::unique_ptr<Category>

Definition at line 31 of file ICounterDirectory.hpp.

CounterPtr

using CounterPtr = std::shared_ptr<Counter>

Definition at line 34 of file ICounterDirectory.hpp.

Counters

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

Definition at line 40 of file ICounterDirectory.hpp.

CounterSetPtr

using CounterSetPtr = std::unique_ptr<CounterSet>

Definition at line 33 of file ICounterDirectory.hpp.

CounterSets

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

Definition at line 39 of file ICounterDirectory.hpp.

CounterSetsIt

using CounterSetsIt = CounterSets::const_iterator

Definition at line 45 of file ICounterDirectory.hpp.

CountersIt

using CountersIt = Counters::const_iterator

Definition at line 46 of file ICounterDirectory.hpp.

DevicePtr

using DevicePtr = std::unique_ptr<Device>

Definition at line 32 of file ICounterDirectory.hpp.

Devices

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

Definition at line 38 of file ICounterDirectory.hpp.

DevicesIt

using DevicesIt = Devices::const_iterator

Definition at line 44 of file ICounterDirectory.hpp.

IBackendProfilingContextUniquePtr

using IBackendProfilingContextUniquePtr = std::unique_ptr<IBackendProfilingContext>

Definition at line 27 of file IBackendProfilingContext.hpp.

IPacketBufferPtr

using IPacketBufferPtr = std::unique_ptr<IPacketBuffer>

Definition at line 40 of file IPacketBuffer.hpp.

Enumeration Type Documentation

PackageActivity

enum PackageActivity

strong

Enumerator
StreamMetaData
CounterDirectory
Unknown

Definition at line 30 of file FileOnlyProfilingConnection.hpp.

{
    StreamMetaData,
    CounterDirectory,
    Unknown
};

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 19 of file ISendTimelinePacket.hpp.

{
    RetentionLink,    
    ExecutionLink,    
    DataLink,         
    LabelLink         
};

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 24 of file FileOnlyProfilingConnection.hpp.

{
    BeWire,
    LeWire
};

TimelinePacketStatus

enum TimelinePacketStatus

strong

Enumerator
Ok
Error
BufferExhaustion

Definition at line 194 of file ProfilingUtils.hpp.

{
    Ok,
    Error,
    BufferExhaustion
};

Function Documentation

CalculateSizeOfPaddedSwString()

uint32_t CalculateSizeOfPaddedSwString

(

const std::string &

str

)

Definition at line 310 of file ProfilingUtils.cpp.

References uint32_t_size.

Referenced by ReadSwTraceMessage().

{
    std::vector<uint32_t> swTraceString;
    StringToSwTraceString<SwTraceCharPolicy>(str, swTraceString);
    unsigned int uint32_t_size = sizeof(uint32_t);
    uint32_t size = (boost::numeric_cast<uint32_t>(swTraceString.size()) - 1) * uint32_t_size;
    return size;
}

CentreAlignFormatting()

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

Definition at line 927 of file ProfilingUtils.cpp.

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

{
    std::stringstream outputStream, centrePadding;
    int padding = spacingWidth - static_cast<int>(stringToPass.size());

    for (int i = 0; i < padding / 2; ++i)
    {
        centrePadding << " ";
    }

    outputStream << centrePadding.str() << stringToPass << centrePadding.str();

    if (padding > 0 && padding %2 != 0)
    {
        outputStream << " ";
    }

    return outputStream.str();
}

ConstructHeader() [1/2]

uint32_t ConstructHeader	(	uint32_t	packetFamily,
		uint32_t	packetId
	)

Definition at line 96 of file ProfilingUtils.cpp.

Referenced by ConvertDirectoryComponent().

{
    return ((packetFamily & 0x3F) << 26)|
           ((packetId & 0x3FF) << 16);
}

ConstructHeader() [2/2]

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

Definition at line 103 of file ProfilingUtils.cpp.

{
    return ((packetFamily & 0x3F) << 26)|
           ((packetClass & 0x3FF) << 19)|
           ((packetType & 0x3FFF) << 16);
}

ConvertDirectoryComponent()

bool armnn::profiling::ConvertDirectoryComponent	(	const std::string &	directoryComponent,
		SwTraceBuffer &	swTraceBuffer
	)

Definition at line 123 of file ProfilingUtils.hpp.

References ConstructHeader(), GetHardwareVersion(), GetNextCounterUids(), GetNextUid(), GetProcessName(), GetSoftwareInfo(), GetSoftwareVersion(), ReadBytes(), ReadUint16(), ReadUint32(), ReadUint64(), ReadUint8(), WriteBytes(), WriteUint16(), WriteUint32(), WriteUint64(), and WriteUint8().

{
    // Convert the directory component using the given policy
    SwTraceBuffer tempSwTraceBuffer;
    bool result = StringToSwTraceString<SwTracePolicy>(directoryComponent, tempSwTraceBuffer);
    if (!result)
    {
        return false;
    }

    swTraceBuffer.insert(swTraceBuffer.end(), tempSwTraceBuffer.begin(), tempSwTraceBuffer.end());

    return true;
}

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 444 of file ProfilingUtils.cpp.

References CreateTimelinePacketHeader().

Referenced by WriteTimelineEntityBinaryPacket(), WriteTimelineEventBinaryPacket(), WriteTimelineEventClassBinaryPacket(), WriteTimelineLabelBinaryPacket(), and WriteTimelineRelationshipBinaryPacket().

{
    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> armnn::profiling::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 404 of file ProfilingUtils.cpp.

Referenced by 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);
}

EncodeVersion()

constexpr uint32_t armnn::profiling::EncodeVersion ( uint32_t  major, uint32_t  minor, uint32_t  patch  )

inline

Definition at line 18 of file EncodeVersion.hpp.

Referenced by BOOST_AUTO_TEST_CASE(), Version::GetEncodedValue(), and SendCounterPacket::SendStreamMetaDataPacket().

{
    return (major << 22) | (minor << 12) | patch;
}

GetHardwareVersion()

std::string GetHardwareVersion

(

)

Definition at line 287 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), and SendCounterPacket::SendStreamMetaDataPacket().

{
    return std::string();
}

GetNextCounterUids()

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

Definition at line 74 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), CounterDirectory::RegisterCounter(), and MockCounterDirectory::RegisterCounter().

{
    // 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 54 of file ProfilingUtils.cpp.

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

{
    // 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 299 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), and SendCounterPacket::SendStreamMetaDataPacket().

{
    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()(), RequestCounterDirectoryCommandHandler::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 282 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), and SendCounterPacket::SendStreamMetaDataPacket().

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

GetSoftwareVersion()

std::string GetSoftwareVersion

(

)

Definition at line 292 of file ProfilingUtils.cpp.

References ARMNN_VERSION.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), and SendCounterPacket::SendStreamMetaDataPacket().

{
    std::string armnnVersion(ARMNN_VERSION);
    std::string result = "Armnn " + armnnVersion.substr(2,2) + "." + armnnVersion.substr(4,2);
    return result;
}

GetTimestamp()

uint64_t GetTimestamp

(

)

Definition at line 1127 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 = clock::now();

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

IsValidSwTraceString()

bool armnn::profiling::IsValidSwTraceString

(

const std::string &

s

)

Definition at line 87 of file ProfilingUtils.hpp.

{
    // Check that all the characters in the given string conform to the given policy
    return std::all_of(s.begin(), s.end(), [](unsigned char c) { return SwTracePolicy::IsValidChar(c); });
}

operator<<()

std::ostream& armnn::profiling::operator<< ( std::ostream &  os, const Version &  version  )

inline

Definition at line 75 of file EncodeVersion.hpp.

References Version::ToString().

{
    os << version.ToString();
    return os;
}

PrintCategoryDetails()

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

Definition at line 1009 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("Device", 12));
    categoryHeader.append(" | ");
    categoryHeader.append(CentreAlignFormatting("Counter set UID:", 16));
    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_DeviceUid), 12));
    categoryBody.append(" | ");
    categoryBody.append(CentreAlignFormatting(std::to_string(category->m_CounterSetUid), 16));
    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 978 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 1080 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 962 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 947 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 190 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), TimelineCaptureCommandHandler::ReadEvent(), and VerifyTimelineEventBinaryPacket().

{
    BOOST_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 225 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);
    BOOST_ASSERT(outValue);

    for (unsigned int i = 0; i < valueSize; i++, offset++)
    {
        outValue[i] = static_cast<uint8_t>(buffer[offset]);
    }
}

ReadSwTraceMessage()

SwTraceMessage ReadSwTraceMessage	(	const unsigned char *	packetBuffer,
		unsigned int &	offset
	)

Definition at line 320 of file ProfilingUtils.cpp.

References CalculateSizeOfPaddedSwString(), SwTraceMessage::m_ArgNames, SwTraceMessage::m_ArgTypes, SwTraceMessage::m_Id, SwTraceMessage::m_Name, SwTraceMessage::m_UiName, ReadUint32(), and uint32_t_size.

Referenced by BOOST_AUTO_TEST_CASE().

{
    BOOST_ASSERT(packetBuffer);

    unsigned int uint32_t_size = sizeof(uint32_t);

    SwTraceMessage swTraceMessage;

    // Read the decl_id
    uint32_t readDeclId = ReadUint32(packetBuffer, offset);
    swTraceMessage.m_Id = readDeclId;

    // SWTrace "namestring" format
    // length of the string (first 4 bytes) + string + null terminator

    // Check the decl_name
    offset += uint32_t_size;
    uint32_t swTraceDeclNameLength = ReadUint32(packetBuffer, offset);

    offset += uint32_t_size;
    std::vector<unsigned char> swTraceStringBuffer(swTraceDeclNameLength - 1);
    std::memcpy(swTraceStringBuffer.data(),
                packetBuffer + offset, swTraceStringBuffer.size());

    swTraceMessage.m_Name.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // name

    // Check the ui_name
    offset += CalculateSizeOfPaddedSwString(swTraceMessage.m_Name);
    uint32_t swTraceUINameLength = ReadUint32(packetBuffer, offset);

    offset += uint32_t_size;
    swTraceStringBuffer.resize(swTraceUINameLength - 1);
    std::memcpy(swTraceStringBuffer.data(),
                packetBuffer  + offset, swTraceStringBuffer.size());

    swTraceMessage.m_UiName.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // ui_name

    // Check arg_types
    offset += CalculateSizeOfPaddedSwString(swTraceMessage.m_UiName);
    uint32_t swTraceArgTypesLength = ReadUint32(packetBuffer, offset);

    offset += uint32_t_size;
    swTraceStringBuffer.resize(swTraceArgTypesLength - 1);
    std::memcpy(swTraceStringBuffer.data(),
                packetBuffer  + offset, swTraceStringBuffer.size());

    swTraceMessage.m_ArgTypes.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // arg_types

    std::string swTraceString(swTraceStringBuffer.begin(), swTraceStringBuffer.end());

    // Check arg_names
    offset += CalculateSizeOfPaddedSwString(swTraceString);
    uint32_t swTraceArgNamesLength = ReadUint32(packetBuffer, offset);

    offset += uint32_t_size;
    swTraceStringBuffer.resize(swTraceArgNamesLength - 1);
    std::memcpy(swTraceStringBuffer.data(),
                packetBuffer  + offset, swTraceStringBuffer.size());

    swTraceString.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
    std::stringstream stringStream(swTraceString);
    std::string argName;
    while (std::getline(stringStream, argName, ','))
    {
        swTraceMessage.m_ArgNames.push_back(argName);
    }

    offset += CalculateSizeOfPaddedSwString(swTraceString);

    return swTraceMessage;
}

ReadUint16() [1/2]

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

Definition at line 211 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), and armnn::gatordmock::ReadString().

{
    BOOST_ASSERT(packetBuffer);

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

ReadUint16() [2/2]

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

Definition at line 265 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);

    uint32_t value = 0;
    value  = static_cast<uint32_t>(buffer[offset]);
    value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
    return static_cast<uint16_t>(value);
}

ReadUint32() [1/2]

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

Definition at line 204 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), PeriodicCounterSelectionResponseHandler::operator()(), TimelineCaptureCommandHandler::ReadLabel(), TimelineCaptureCommandHandler::ReadRelationship(), armnn::gatordmock::ReadString(), ReadSwTraceMessage(), SendTimelinePacketToCommandHandler(), VerifyTimelineEntityBinaryPacket(), VerifyTimelineEventBinaryPacket(), VerifyTimelineEventClassBinaryPacket(), VerifyTimelineLabelBinaryPacket(), VerifyTimelineRelationshipBinaryPacket(), and MockProfilingConnection::WritePacket().

{
    BOOST_ASSERT(packetBuffer);

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

ReadUint32() [2/2]

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

Definition at line 253 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);

    uint32_t value = 0;
    value  = static_cast<uint32_t>(buffer[offset]);
    value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
    value |= static_cast<uint32_t>(buffer[offset + 2]) << 16;
    value |= static_cast<uint32_t>(buffer[offset + 3]) << 24;
    return value;
}

ReadUint64() [1/2]

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

Definition at line 197 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), TimelineCaptureCommandHandler::ReadEntity(), TimelineCaptureCommandHandler::ReadEvent(), TimelineCaptureCommandHandler::ReadEventClass(), TimelineCaptureCommandHandler::ReadLabel(), TimelineCaptureCommandHandler::ReadRelationship(), VerifyTimelineEntityBinaryPacket(), VerifyTimelineEventBinaryPacket(), VerifyTimelineEventClassBinaryPacket(), VerifyTimelineLabelBinaryPacket(), and VerifyTimelineRelationshipBinaryPacket().

{
    BOOST_ASSERT(packetBuffer);

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

ReadUint64() [2/2]

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

Definition at line 236 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);

    uint64_t value = 0;
    value  = static_cast<uint64_t>(buffer[offset]);
    value |= static_cast<uint64_t>(buffer[offset + 1]) << 8;
    value |= static_cast<uint64_t>(buffer[offset + 2]) << 16;
    value |= static_cast<uint64_t>(buffer[offset + 3]) << 24;
    value |= static_cast<uint64_t>(buffer[offset + 4]) << 32;
    value |= static_cast<uint64_t>(buffer[offset + 5]) << 40;
    value |= static_cast<uint64_t>(buffer[offset + 6]) << 48;
    value |= static_cast<uint64_t>(buffer[offset + 7]) << 56;

    return value;
}

ReadUint8() [1/2]

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

Definition at line 218 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), DirectoryCaptureCommandHandler::GetCounterDirectory(), and TimelineCaptureCommandHandler::ReadLabel().

{
    BOOST_ASSERT(packetBuffer);

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

ReadUint8() [2/2]

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

Definition at line 275 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);

    return buffer[offset];
}

StringToSwTraceString()

bool armnn::profiling::StringToSwTraceString	(	const std::string &	s,
		std::vector< uint32_t > &	outputBuffer
	)

Definition at line 94 of file ProfilingUtils.hpp.

References uint32_t_size.

{
    // Converts the given string to an SWTrace "string" (i.e. a string of "chars"), and writes it into
    // the given buffer including the null-terminator. It also pads it to the next uint32_t if necessary

    // Clear the output buffer
    outputBuffer.clear();

    // Check that the given string is a valid SWTrace "string" (i.e. a string of "chars")
    if (!IsValidSwTraceString<SwTracePolicy>(s))
    {
        return false;
    }

    // Prepare the output buffer
    size_t s_size        = s.size() + 1;    // The size of the string (in chars) plus the null-terminator
    size_t uint32_t_size = sizeof(uint32_t);
    size_t outBufferSize = 1 + s_size / uint32_t_size + (s_size % uint32_t_size != 0 ? 1 : 0);
    outputBuffer.resize(outBufferSize, '\0');

    // Write the SWTrace string to the output buffer
    outputBuffer[0] = boost::numeric_cast<uint32_t>(s_size);
    std::memcpy(outputBuffer.data() + 1, s.data(), s_size);

    return true;
}

WriteBytes() [1/3]

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

Definition at line 89 of file ProfilingUtils.cpp.

Referenced by ConvertDirectoryComponent(), and WriteTimelineEventBinaryPacket().

{
    BOOST_ASSERT(packetBuffer);

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

WriteBytes() [2/3]

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

Definition at line 140 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);
    BOOST_ASSERT(value);

    for (unsigned int i = 0; i < valueSize; i++, offset++)
    {
        buffer[offset] = *(reinterpret_cast<const unsigned char*>(value) + i);
    }
}

WriteBytes() [3/3]

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

WriteTimelineEntityBinaryPacket()

TimelinePacketStatus WriteTimelineEntityBinaryPacket	(	uint64_t	profilingGuid,
		unsigned char *	buffer,
		unsigned int	bufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 530 of file ProfilingUtils.cpp.

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

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

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || bufferSize == 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 timelineEntityPacketDataLength = uint32_t_size + uint64_t_size;  // decl_id + Profiling GUID


    // Calculate the timeline binary packet size (in bytes)
    unsigned int timelineEntityPacketSize = 2 * uint32_t_size +             // Header (2 words)
                                            timelineEntityPacketDataLength; // Profiling GUID

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

    // Create packet header
    std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(timelineEntityPacketDataLength);

    // 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 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 = timelineEntityPacketSize;

    return TimelinePacketStatus::Ok;
}

WriteTimelineEventBinaryPacket()

TimelinePacketStatus WriteTimelineEventBinaryPacket	(	uint64_t	timestamp,
		std::thread::id	threadId,
		uint64_t	profilingGuid,
		unsigned char *	buffer,
		unsigned int	bufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 859 of file ProfilingUtils.cpp.

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

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

{
    // Initialize the output value
    numberOfBytesWritten = 0;

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

    // Utils
    unsigned int uint32_t_size = sizeof(uint32_t);
    unsigned int uint64_t_size = sizeof(uint64_t);
    unsigned int threadId_size = sizeof(std::thread::id);

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

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

    // Calculate the timeline binary packet size (in bytes)
    unsigned int timelineEventPacketSize = 2 * uint32_t_size +            // Header (2 words)
                                           timelineEventPacketDataLength; // Timestamp + thread id + profiling GUID

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

    // Create packet header
    std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(timelineEventPacketDataLength);

    // 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 timeline binary packet 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, threadId_size); // Thread id
    offset += threadId_size;
    WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
    offset += uint64_t_size;

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

    return TimelinePacketStatus::Ok;
}

WriteTimelineEventClassBinaryPacket()

TimelinePacketStatus WriteTimelineEventClassBinaryPacket	(	uint64_t	profilingGuid,
		unsigned char *	buffer,
		unsigned int	bufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 802 of file ProfilingUtils.cpp.

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

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

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || bufferSize == 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 packetBodySize = uint32_t_size + uint64_t_size; // decl_id + Profiling GUID

    // Calculate the timeline binary packet size (in bytes)
    unsigned int packetSize = 2 * uint32_t_size + // Header (2 words)
                              packetBodySize;     // Body

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

    // Create packet header
    std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(packetBodySize);

    // 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 timeline binary packet payload to the buffer
    WriteUint32(buffer, offset, declId);        // decl_id
    offset += uint32_t_size;
    WriteUint64(buffer, offset, profilingGuid); // Profiling GUID

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

    return TimelinePacketStatus::Ok;
}

WriteTimelineLabelBinaryPacket()

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

Definition at line 454 of file ProfilingUtils.cpp.

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

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

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || bufferSize == 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 = StringToSwTraceString<SwTraceCharPolicy>(label, swTraceLabel);
    if (!result)
    {
        return TimelinePacketStatus::Error;
    }

    // Calculate the size of the SWTrace string label (in bytes)
    unsigned int swTraceLabelSize = boost::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

    // Calculate the timeline binary packet size (in bytes)
    unsigned int timelineLabelPacketSize = 2 * uint32_t_size +            // Header (2 words)
                                           timelineLabelPacketDataLength; // decl_Id + Profiling GUID + label

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

    // Create packet header
    std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(timelineLabelPacketDataLength);

    // 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 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 = timelineLabelPacketSize;

    return TimelinePacketStatus::Ok;
}

WriteTimelineMessageDirectoryPackage()

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

Definition at line 674 of file ProfilingUtils.cpp.

References BufferExhaustion, CreateTimelinePacketHeader(), Error, Ok, uint32_t_size, WriteUint32(), and WriteUint8().

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

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || bufferSize == 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);
    unsigned int threadId_size = sizeof(std::thread::id);

    // 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  |    p        |  guid                               |
    // |    3      | declareRelationship | declare relationship  |    Ippp     |  relationshipType,relationshipGuid, |
    // |           |                     |                       |             |  headGuid,tailGuid                  |
    // |    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", "p", "guid" },
        { "3", "declareRelationship", "declare relationship", "Ippp",
          "relationshipType,relationshipGuid,headGuid,tailGuid" },
        { "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 = boost::numeric_cast<uint32_t>(std::stoul(directoryComponent[0]));
        }
        catch (const std::exception&)
        {
            return TimelinePacketStatus::Error;
        }
        swTraceBuffer.push_back(declId);

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

    unsigned int dataLength = 3 * uint8_t_size +  // Stream header (3 bytes)
                              boost::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 > bufferSize)
    {
        return TimelinePacketStatus::BufferExhaustion;
    }

    // Create packet header
    auto packetHeader = CreateTimelinePacketHeader(1, 0, 0, 0, 0, boost::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  = boost::numeric_cast<uint8_t>(uint64_t_size); // All GUIDs are uint64_t
    uint8_t threadIdBytes = boost::numeric_cast<uint8_t>(threadId_size);
    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 = boost::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;
}

WriteTimelineRelationshipBinaryPacket()

TimelinePacketStatus WriteTimelineRelationshipBinaryPacket	(	ProfilingRelationshipType	relationshipType,
		uint64_t	relationshipGuid,
		uint64_t	headGuid,
		uint64_t	tailGuid,
		unsigned char *	buffer,
		unsigned int	bufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 587 of file ProfilingUtils.cpp.

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

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

{
    // Initialize the output value
    numberOfBytesWritten = 0;

    // Check that the given buffer is valid
    if (buffer == nullptr || bufferSize == 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 timelineRelationshipPacketDataLength = uint32_t_size * 2 + // decl_id + Relationship Type
                                                        uint64_t_size * 3; // Relationship GUID + Head GUID + tail GUID

    // Calculate the timeline binary packet size (in bytes)
    unsigned int timelineRelationshipPacketSize = 2 * uint32_t_size + // Header (2 words)
                                                  timelineRelationshipPacketDataLength;

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

    // Create packet header
    uint32_t dataLength = boost::numeric_cast<uint32_t>(timelineRelationshipPacketDataLength);
    std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(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;

    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 packet 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

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

    return TimelinePacketStatus::Ok;
}

WriteUint16() [1/2]

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

Definition at line 126 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), FileOnlyProfilingConnection::Close(), ConvertDirectoryComponent(), PacketWriter(), SendCounterPacket::SendPeriodicCounterCapturePacket(), GatordMockService::SendPeriodicCounterSelectionList(), and SendCounterPacket::SendPeriodicCounterSelectionPacket().

{
    BOOST_ASSERT(packetBuffer);

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

WriteUint16() [2/2]

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

Definition at line 175 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);

    buffer[offset]     = static_cast<unsigned char>(value & 0xFF);
    buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
}

WriteUint32() [1/2]

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

Definition at line 119 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), FileOnlyProfilingConnection::Close(), ConvertDirectoryComponent(), PacketWriter(), SendCounterPacket::SendCounterDirectoryPacket(), SendCounterPacket::SendPeriodicCounterCapturePacket(), GatordMockService::SendPeriodicCounterSelectionList(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), SendCounterPacket::SendStreamMetaDataPacket(), WriteTimelineEntityBinaryPacket(), WriteTimelineEventBinaryPacket(), WriteTimelineEventClassBinaryPacket(), WriteTimelineLabelBinaryPacket(), WriteTimelineMessageDirectoryPackage(), and WriteTimelineRelationshipBinaryPacket().

{
    BOOST_ASSERT(packetBuffer);

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

WriteUint32() [2/2]

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

Definition at line 165 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);

    buffer[offset]     = static_cast<unsigned char>(value & 0xFF);
    buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
    buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
    buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
}

WriteUint64() [1/3]

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

Definition at line 112 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), SendCounterPacket::SendPeriodicCounterCapturePacket(), WriteTimelineEntityBinaryPacket(), WriteTimelineEventBinaryPacket(), WriteTimelineEventClassBinaryPacket(), WriteTimelineLabelBinaryPacket(), and WriteTimelineRelationshipBinaryPacket().

{
    BOOST_ASSERT(packetBuffer);

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

WriteUint64() [2/3]

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

WriteUint64() [3/3]

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

Definition at line 151 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);

    buffer[offset]     = static_cast<unsigned char>(value & 0xFF);
    buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
    buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
    buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
    buffer[offset + 4] = static_cast<unsigned char>((value >> 32) & 0xFF);
    buffer[offset + 5] = static_cast<unsigned char>((value >> 40) & 0xFF);
    buffer[offset + 6] = static_cast<unsigned char>((value >> 48) & 0xFF);
    buffer[offset + 7] = static_cast<unsigned char>((value >> 56) & 0xFF);
}

WriteUint8() [1/2]

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

Definition at line 133 of file ProfilingUtils.cpp.

Referenced by ConvertDirectoryComponent(), and WriteTimelineMessageDirectoryPackage().

{
    BOOST_ASSERT(packetBuffer);

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

WriteUint8() [2/2]

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

Definition at line 183 of file ProfilingUtils.cpp.

{
    BOOST_ASSERT(buffer);

    buffer[offset] = static_cast<unsigned char>(value);
}

Variable Documentation

uint16_t_size

uint32_t uint16_t_size = sizeof(uint16_t)

Definition at line 20 of file DirectoryCaptureCommandHandler.cpp.

Referenced by FileOnlyProfilingConnection::Close(), armnn::gatordmock::ReadString(), SendCounterPacket::SendPeriodicCounterCapturePacket(), and SendCounterPacket::SendPeriodicCounterSelectionPacket().

uint32_t_size

uint32_t uint32_t_size = sizeof(uint32_t)

Definition at line 21 of file DirectoryCaptureCommandHandler.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), CalculateSizeOfPaddedSwString(), FileOnlyProfilingConnection::Close(), SendCounterPacket::CreateCategoryRecord(), SendCounterPacket::CreateEventRecord(), OffsetToNextWord(), armnn::gatordmock::ReadString(), ReadSwTraceMessage(), SendCounterPacket::SendCounterDirectoryPacket(), SendCounterPacket::SendPeriodicCounterCapturePacket(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), SendTimelinePacketToCommandHandler(), StringToSwTraceString(), VerifyTimelineEntityBinaryPacket(), VerifyTimelineEventBinaryPacket(), VerifyTimelineEventClassBinaryPacket(), VerifyTimelineLabelBinaryPacket(), VerifyTimelineRelationshipBinaryPacket(), WriteTimelineEntityBinaryPacket(), WriteTimelineEventBinaryPacket(), WriteTimelineEventClassBinaryPacket(), WriteTimelineLabelBinaryPacket(), WriteTimelineMessageDirectoryPackage(), and WriteTimelineRelationshipBinaryPacket().