armnn::profiling Namespace Reference

Classes
class	ActivateTimelineReportingCommandHandler
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	DeactivateTimelineReportingCommandHandler
class	Device
class	DirectoryCaptureCommandHandler
class	Entity
class	FileOnlyProfilingConnection
class	Holder
class	IBackendProfiling
class	IBackendProfilingContext
class	IBufferManager
class	IConsumer
class	ICounterDirectory
class	ICounterMappings
class	ICounterRegistry
class	ILocalPacketHandler
class	INotifyBackends
class	IPacketBuffer
class	IPeriodicCounterCapture
class	IProfilingConnection
class	IProfilingConnectionFactory
class	IProfilingGuidGenerator
class	IProfilingService
class	IReadCounterValues
class	IReadOnlyPacketBuffer
class	IReadWriteCounterValues
class	IRegisterBackendCounters
class	IRegisterCounterMapping
class	IReportStructure
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
struct	ModelRelationship
class	NullProfilingConnection
class	PacketBuffer
class	PacketKey
class	PacketVersionResolver
class	PeriodicCounterCapture
class	PeriodicCounterSelectionCommandHandler
class	PerJobCounterSelectionCommandHandler
class	PrintPacketHeaderHandler
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	TestTimelinePacketHandler
class	TimelineMessageDecoder
class	TimelineModel
class	TimelinePacketWriterFactory
class	TimelineUtilityMethods
struct	Timestamp
class	Version

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

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)
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)
	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, 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, unsigned char *buffer, unsigned int remainingBufferSize, unsigned int &numberOfBytesWritten)
TimelinePacketStatus	WriteTimelineEventBinary (uint64_t timestamp, std::thread::id 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 ()
Packet	ReceivePacket (const unsigned char *buffer, uint32_t length)
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)
constexpr unsigned int	ThreadIdSize = sizeof(std::thread::id)

Typedef Documentation

Attribute

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

Definition at line 19 of file TimelineModel.hpp.

Attributes

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

Definition at line 20 of file TimelineModel.hpp.

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.

Entities

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

Definition at line 43 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 43 of file ILocalPacketHandler.hpp.

ILocalPacketHandlerSharedPtr

using ILocalPacketHandlerSharedPtr = std::shared_ptr<ILocalPacketHandler>

Definition at line 44 of file ILocalPacketHandler.hpp.

IPacketBufferPtr

using IPacketBufferPtr = std::unique_ptr<IPacketBuffer>

Definition at line 40 of file IPacketBuffer.hpp.

LabelMap

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

Definition at line 18 of file TimelineModel.hpp.

Relationships

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

Definition at line 50 of file TimelineModel.hpp.

Enumeration Type Documentation

PackageActivity

enum PackageActivity

strong

Enumerator
StreamMetaData
CounterDirectory
Unknown

Definition at line 34 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,    /// 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 28 of file FileOnlyProfilingConnection.hpp.

{
    BeWire,
    LeWire
};

TimelinePacketStatus

enum TimelinePacketStatus

strong

Enumerator
Ok
Error
BufferExhaustion

Definition at line 206 of file ProfilingUtils.hpp.

{
    Ok,
    Error,
    BufferExhaustion
};

Function Documentation

CalculateSizeOfPaddedSwString()

uint32_t CalculateSizeOfPaddedSwString

(

const std::string &

str

)

Definition at line 302 of file ProfilingUtils.cpp.

References armnn::numeric_cast(), and 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 848 of file ProfilingUtils.cpp.

Referenced by PeriodicCounterCaptureCommandHandler::operator()(), TimelineDecoder::print(), 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()

uint32_t ConstructHeader	(	uint32_t	packetFamily,
		uint32_t	packetId
	)

Definition at line 98 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), and ConvertDirectoryComponent().

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

ConvertDirectoryComponent()

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

Definition at line 130 of file ProfilingUtils.hpp.

References ConstructHeader(), CreateTimelinePacketHeader(), 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 436 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 396 of file ProfilingUtils.cpp.

Referenced by SendTimelinePacket::Commit(), ConvertDirectoryComponent(), 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 280 of file ProfilingUtils.cpp.

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

{
    return std::string();
}

GetNextCounterUids()

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

Definition at line 76 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 56 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 291 of file ProfilingUtils.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), GetStreamMetaDataPacketSize(), 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()(), 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 275 of file ProfilingUtils.cpp.

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

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

GetSoftwareVersion()

std::string GetSoftwareVersion

(

)

Definition at line 285 of file ProfilingUtils.cpp.

References ARMNN_MAJOR_VERSION, and ARMNN_MINOR_VERSION.

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

{
    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 1040 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());
}

IsValidSwTraceString()

bool armnn::profiling::IsValidSwTraceString

(

const std::string &

s

)

Definition at line 91 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 930 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 899 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 993 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 883 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 868 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 183 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), 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 218 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

{
    ARMNN_ASSERT(buffer);
    ARMNN_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 312 of file ProfilingUtils.cpp.

References ARMNN_ASSERT, 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(), and CheckTimelineDirectory().

{
    ARMNN_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 204 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

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

{
    ARMNN_ASSERT(packetBuffer);

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

ReadUint16() [2/2]

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

Definition at line 258 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

{
    ARMNN_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 197 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by BOOST_AUTO_TEST_CASE(), CheckTimelineDirectory(), ConvertDirectoryComponent(), PeriodicCounterSelectionResponseHandler::operator()(), TimelineCaptureCommandHandler::ReadEvent(), TimelineCaptureCommandHandler::ReadLabel(), TimelineCaptureCommandHandler::ReadRelationship(), armnn::gatordmock::ReadString(), ReadSwTraceMessage(), SendTimelinePacketToCommandHandler(), 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 246 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

{
    ARMNN_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 190 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), TimelineCaptureCommandHandler::ReadEntity(), TimelineCaptureCommandHandler::ReadEvent(), TimelineCaptureCommandHandler::ReadEventClass(), TimelineCaptureCommandHandler::ReadLabel(), TimelineCaptureCommandHandler::ReadRelationship(), 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 229 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

{
    ARMNN_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 211 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

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

{
    ARMNN_ASSERT(packetBuffer);

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

ReadUint8() [2/2]

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

Definition at line 268 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

{
    ARMNN_ASSERT(buffer);

    return buffer[offset];
}

ReceivePacket()

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

Definition at line 1054 of file ProfilingUtils.cpp.

Referenced by FileOnlyProfilingConnection::WritePacket().

{
    if (buffer == nullptr)
    {
        throw armnnProfiling::ProfilingException("data buffer is nullptr");
    }
    if (length < 8)
    {
        throw armnnProfiling::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 Packet(metadataIdentifier, dataLength, packetData);
}

StringToSwTraceString()

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

Definition at line 98 of file ProfilingUtils.hpp.

References armnn::numeric_cast(), and 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);
    // Output buffer size = StringLength (32 bit) + amount of complete 32bit words that fit into the string
    //                      + an additional 32bit word if there are remaining chars to complete the string
    //                      (The rest of the 32bit word is then filled with the NULL terminator)
    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 91 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by BOOST_AUTO_TEST_CASE(), ConvertDirectoryComponent(), and WriteTimelineEventBinary().

{
    ARMNN_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 133 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

{
    ARMNN_ASSERT(buffer);
    ARMNN_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
	)

WriteTimelineEntityBinary()

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

Definition at line 509 of file ProfilingUtils.cpp.

References BufferExhaustion, 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 || 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,
		std::thread::id	threadId,
		uint64_t	profilingGuid,
		unsigned char *	buffer,
		unsigned int	remainingBufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 796 of file ProfilingUtils.cpp.

References BufferExhaustion, Ok, ThreadIdSize, 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 || 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,
		unsigned char *	buffer,
		unsigned int	remainingBufferSize,
		unsigned int &	numberOfBytesWritten
	)

Definition at line 752 of file ProfilingUtils.cpp.

References BufferExhaustion, 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 || 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; // decl_id + Profiling 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

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

References BufferExhaustion, Error, armnn::numeric_cast(), 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 || 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 = 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

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

References BufferExhaustion, CreateTimelinePacketHeader(), Error, armnn::numeric_cast(), Ok, ThreadIdSize, 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 || 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  |    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 > remainingBufferSize)
    {
        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>(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 = 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;
}

WriteTimelineRelationshipBinary()

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

Definition at line 552 of file ProfilingUtils.cpp.

References BufferExhaustion, 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 || 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 * 3;  // Relationship GUID + Head GUID + tail GUID

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

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

References ARMNN_ASSERT.

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

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

References ARMNN_ASSERT.

{
    ARMNN_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 112 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by BOOST_AUTO_TEST_CASE(), FileOnlyProfilingConnection::Close(), SendTimelinePacket::Commit(), ConvertDirectoryComponent(), PacketWriter(), SendCounterPacket::SendPeriodicCounterCapturePacket(), GatordMockService::SendPeriodicCounterSelectionList(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), SendCounterPacket::SendStreamMetaDataPacket(), 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 158 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

{
    ARMNN_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 105 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

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

{
    ARMNN_ASSERT(packetBuffer);

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

WriteUint64() [2/3]

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

Definition at line 144 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

{
    ARMNN_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);
}

WriteUint64() [3/3]

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

WriteUint8() [1/2]

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

Definition at line 126 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

Referenced by ConvertDirectoryComponent(), and 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 176 of file ProfilingUtils.cpp.

References ARMNN_ASSERT.

{
    ARMNN_ASSERT(buffer);

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

Variable Documentation

ThreadIdSize

constexpr unsigned int ThreadIdSize = sizeof(std::thread::id)

Definition at line 31 of file ProfilingUtils.hpp.

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

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(), CheckTimelineDirectory(), FileOnlyProfilingConnection::Close(), SendCounterPacket::CreateCategoryRecord(), SendCounterPacket::CreateEventRecord(), OffsetToNextWord(), armnn::gatordmock::ReadString(), ReadSwTraceMessage(), SendCounterPacket::SendCounterDirectoryPacket(), SendCounterPacket::SendPeriodicCounterCapturePacket(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), SendTimelinePacketToCommandHandler(), StringToSwTraceString(), VerifyTimelineEntityBinaryPacketData(), VerifyTimelineEventBinaryPacket(), VerifyTimelineEventClassBinaryPacketData(), VerifyTimelineHeaderBinary(), VerifyTimelineLabelBinaryPacketData(), VerifyTimelineRelationshipBinaryPacketData(), WriteTimelineEntityBinary(), WriteTimelineEventBinary(), WriteTimelineEventClassBinary(), WriteTimelineLabelBinaryPacket(), WriteTimelineMessageDirectoryPackage(), and WriteTimelineRelationshipBinary().