12 #include <boost/assert.hpp> 27 void ThrowIfCantGenerateNextUid(uint16_t uid, uint16_t cores = 0)
36 if (uid == std::numeric_limits<uint16_t>::max())
38 throw RuntimeException(
"Generating the next UID for profiling would result in an overflow");
44 if (uid >= std::numeric_limits<uint16_t>::max() - cores + 1)
46 throw RuntimeException(
"Generating the next UID for profiling would result in an overflow");
57 static uint16_t uid = 1;
60 ThrowIfCantGenerateNextUid(uid);
77 ThrowIfCantGenerateNextUid(firstUid, cores);
80 size_t counterUidsSize = cores == 0 ? 1 : cores;
81 std::vector<uint16_t> counterUids(counterUidsSize, 0);
82 for (
size_t i = 0; i < counterUidsSize; i++)
84 counterUids[i] = firstUid++;
91 BOOST_ASSERT(packetBuffer);
93 WriteBytes(packetBuffer->GetWritableData(), offset, value, valueSize);
99 return ((packetFamily & 0x3F) << 26)|
100 ((packetId & 0x3FF) << 16);
104 uint32_t packetClass,
107 return ((packetFamily & 0x3F) << 26)|
108 ((packetClass & 0x3FF) << 19)|
109 ((packetType & 0x3FFF) << 16);
112 void WriteUint64(
const std::unique_ptr<IPacketBuffer>& packetBuffer,
unsigned int offset, uint64_t value)
114 BOOST_ASSERT(packetBuffer);
116 WriteUint64(packetBuffer->GetWritableData(), offset, value);
121 BOOST_ASSERT(packetBuffer);
123 WriteUint32(packetBuffer->GetWritableData(), offset, value);
128 BOOST_ASSERT(packetBuffer);
130 WriteUint16(packetBuffer->GetWritableData(), offset, value);
135 BOOST_ASSERT(packetBuffer);
137 WriteUint8(packetBuffer->GetWritableData(), offset, value);
140 void WriteBytes(
unsigned char* buffer,
unsigned int offset,
const void* value,
unsigned int valueSize)
142 BOOST_ASSERT(buffer);
145 for (
unsigned int i = 0; i < valueSize; i++, offset++)
147 buffer[offset] = *(
reinterpret_cast<const unsigned char*
>(value) + i);
151 void WriteUint64(
unsigned char* buffer,
unsigned int offset, uint64_t value)
153 BOOST_ASSERT(buffer);
155 buffer[offset] =
static_cast<unsigned char>(value & 0xFF);
156 buffer[offset + 1] =
static_cast<unsigned char>((value >> 8) & 0xFF);
157 buffer[offset + 2] =
static_cast<unsigned char>((value >> 16) & 0xFF);
158 buffer[offset + 3] =
static_cast<unsigned char>((value >> 24) & 0xFF);
159 buffer[offset + 4] =
static_cast<unsigned char>((value >> 32) & 0xFF);
160 buffer[offset + 5] =
static_cast<unsigned char>((value >> 40) & 0xFF);
161 buffer[offset + 6] =
static_cast<unsigned char>((value >> 48) & 0xFF);
162 buffer[offset + 7] =
static_cast<unsigned char>((value >> 56) & 0xFF);
165 void WriteUint32(
unsigned char* buffer,
unsigned int offset, uint32_t value)
167 BOOST_ASSERT(buffer);
169 buffer[offset] =
static_cast<unsigned char>(value & 0xFF);
170 buffer[offset + 1] =
static_cast<unsigned char>((value >> 8) & 0xFF);
171 buffer[offset + 2] =
static_cast<unsigned char>((value >> 16) & 0xFF);
172 buffer[offset + 3] =
static_cast<unsigned char>((value >> 24) & 0xFF);
175 void WriteUint16(
unsigned char* buffer,
unsigned int offset, uint16_t value)
177 BOOST_ASSERT(buffer);
179 buffer[offset] =
static_cast<unsigned char>(value & 0xFF);
180 buffer[offset + 1] =
static_cast<unsigned char>((value >> 8) & 0xFF);
183 void WriteUint8(
unsigned char* buffer,
unsigned int offset, uint8_t value)
185 BOOST_ASSERT(buffer);
187 buffer[offset] =
static_cast<unsigned char>(value);
192 BOOST_ASSERT(packetBuffer);
194 ReadBytes(packetBuffer->GetReadableData(), offset, valueSize, outValue);
199 BOOST_ASSERT(packetBuffer);
201 return ReadUint64(packetBuffer->GetReadableData(), offset);
206 BOOST_ASSERT(packetBuffer);
208 return ReadUint32(packetBuffer->GetReadableData(), offset);
213 BOOST_ASSERT(packetBuffer);
215 return ReadUint16(packetBuffer->GetReadableData(), offset);
220 BOOST_ASSERT(packetBuffer);
222 return ReadUint8(packetBuffer->GetReadableData(), offset);
225 void ReadBytes(
const unsigned char* buffer,
unsigned int offset,
unsigned int valueSize, uint8_t outValue[])
227 BOOST_ASSERT(buffer);
228 BOOST_ASSERT(outValue);
230 for (
unsigned int i = 0; i < valueSize; i++, offset++)
232 outValue[i] =
static_cast<uint8_t
>(buffer[offset]);
236 uint64_t
ReadUint64(
const unsigned char* buffer,
unsigned int offset)
238 BOOST_ASSERT(buffer);
241 value =
static_cast<uint64_t
>(buffer[offset]);
242 value |=
static_cast<uint64_t
>(buffer[offset + 1]) << 8;
243 value |=
static_cast<uint64_t
>(buffer[offset + 2]) << 16;
244 value |=
static_cast<uint64_t
>(buffer[offset + 3]) << 24;
245 value |=
static_cast<uint64_t
>(buffer[offset + 4]) << 32;
246 value |=
static_cast<uint64_t
>(buffer[offset + 5]) << 40;
247 value |=
static_cast<uint64_t
>(buffer[offset + 6]) << 48;
248 value |=
static_cast<uint64_t
>(buffer[offset + 7]) << 56;
253 uint32_t
ReadUint32(
const unsigned char* buffer,
unsigned int offset)
255 BOOST_ASSERT(buffer);
258 value =
static_cast<uint32_t
>(buffer[offset]);
259 value |=
static_cast<uint32_t
>(buffer[offset + 1]) << 8;
260 value |=
static_cast<uint32_t
>(buffer[offset + 2]) << 16;
261 value |=
static_cast<uint32_t
>(buffer[offset + 3]) << 24;
265 uint16_t
ReadUint16(
const unsigned char* buffer,
unsigned int offset)
267 BOOST_ASSERT(buffer);
270 value =
static_cast<uint32_t
>(buffer[offset]);
271 value |=
static_cast<uint32_t
>(buffer[offset + 1]) << 8;
272 return static_cast<uint16_t
>(value);
275 uint8_t
ReadUint8(
const unsigned char* buffer,
unsigned int offset)
277 BOOST_ASSERT(buffer);
279 return buffer[offset];
284 return std::string(
"ArmNN");
289 return std::string();
295 std::string result =
"Armnn " + armnnVersion.substr(2,2) +
"." + armnnVersion.substr(4,2);
301 std::ifstream comm(
"/proc/self/comm");
312 std::vector<uint32_t> swTraceString;
313 StringToSwTraceString<SwTraceCharPolicy>(str, swTraceString);
315 uint32_t size = (boost::numeric_cast<uint32_t>(swTraceString.size()) - 1) *
uint32_t_size;
322 BOOST_ASSERT(packetBuffer);
329 uint32_t readDeclId =
ReadUint32(packetBuffer, offset);
330 swTraceMessage.
m_Id = readDeclId;
337 uint32_t swTraceDeclNameLength =
ReadUint32(packetBuffer, offset);
340 std::vector<unsigned char> swTraceStringBuffer(swTraceDeclNameLength - 1);
341 std::memcpy(swTraceStringBuffer.data(),
342 packetBuffer + offset, swTraceStringBuffer.size());
344 swTraceMessage.
m_Name.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
348 uint32_t swTraceUINameLength =
ReadUint32(packetBuffer, offset);
351 swTraceStringBuffer.resize(swTraceUINameLength - 1);
352 std::memcpy(swTraceStringBuffer.data(),
353 packetBuffer + offset, swTraceStringBuffer.size());
355 swTraceMessage.
m_UiName.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
359 uint32_t swTraceArgTypesLength =
ReadUint32(packetBuffer, offset);
362 swTraceStringBuffer.resize(swTraceArgTypesLength - 1);
363 std::memcpy(swTraceStringBuffer.data(),
364 packetBuffer + offset, swTraceStringBuffer.size());
366 swTraceMessage.
m_ArgTypes.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
368 std::string swTraceString(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
372 uint32_t swTraceArgNamesLength =
ReadUint32(packetBuffer, offset);
375 swTraceStringBuffer.resize(swTraceArgNamesLength - 1);
376 std::memcpy(swTraceStringBuffer.data(),
377 packetBuffer + offset, swTraceStringBuffer.size());
379 swTraceString.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
380 std::stringstream stringStream(swTraceString);
382 while (std::getline(stringStream, argName,
','))
389 return swTraceMessage;
405 uint32_t packetClass,
408 uint32_t sequenceNumbered,
417 uint32_t packetHeaderWord0 = ((packetFamily & 0x0000003F) << 26) |
418 ((packetClass & 0x0000007F) << 19) |
419 ((packetType & 0x00000007) << 16) |
420 ((streamId & 0x00000007) << 0);
426 uint32_t packetHeaderWord1 = ((sequenceNumbered & 0x00000001) << 24) |
427 ((dataLength & 0x00FFFFFF) << 0);
429 return std::make_pair(packetHeaderWord0, packetHeaderWord1);
455 const std::string& label,
456 unsigned char* buffer,
457 unsigned int bufferSize,
458 unsigned int& numberOfBytesWritten)
461 numberOfBytesWritten = 0;
464 if (buffer ==
nullptr || bufferSize == 0)
471 unsigned int uint64_t_size =
sizeof(uint64_t);
474 std::vector<uint32_t> swTraceLabel;
475 bool result = StringToSwTraceString<SwTraceCharPolicy>(label, swTraceLabel);
482 unsigned int swTraceLabelSize = boost::numeric_cast<
unsigned int>(swTraceLabel.size()) * uint32_t_size;
485 unsigned int timelineLabelPacketDataLength = uint32_t_size +
490 unsigned int timelineLabelPacketSize = 2 * uint32_t_size +
491 timelineLabelPacketDataLength;
494 if (timelineLabelPacketSize > bufferSize)
503 unsigned int offset = 0;
517 offset += uint64_t_size;
518 for (uint32_t swTraceLabelWord : swTraceLabel)
525 numberOfBytesWritten = timelineLabelPacketSize;
531 unsigned char* buffer,
532 unsigned int bufferSize,
533 unsigned int& numberOfBytesWritten)
536 numberOfBytesWritten = 0;
539 if (buffer ==
nullptr || bufferSize == 0)
546 unsigned int uint64_t_size =
sizeof(uint64_t);
549 unsigned int timelineEntityPacketDataLength = uint32_t_size + uint64_t_size;
553 unsigned int timelineEntityPacketSize = 2 * uint32_t_size +
554 timelineEntityPacketDataLength;
557 if (timelineEntityPacketSize > bufferSize)
566 unsigned int offset = 0;
582 numberOfBytesWritten = timelineEntityPacketSize;
588 uint64_t relationshipGuid,
591 unsigned char* buffer,
592 unsigned int bufferSize,
593 unsigned int& numberOfBytesWritten)
596 numberOfBytesWritten = 0;
599 if (buffer ==
nullptr || bufferSize == 0)
606 unsigned int uint64_t_size =
sizeof(uint64_t);
609 unsigned int timelineRelationshipPacketDataLength = uint32_t_size * 2 +
613 unsigned int timelineRelationshipPacketSize = 2 * uint32_t_size +
614 timelineRelationshipPacketDataLength;
617 if (timelineRelationshipPacketSize > bufferSize)
623 uint32_t dataLength = boost::numeric_cast<uint32_t>(timelineRelationshipPacketDataLength);
627 unsigned int offset = 0;
635 uint32_t relationshipTypeUint = 0;
637 switch (relationshipType)
640 relationshipTypeUint = 0;
643 relationshipTypeUint = 1;
646 relationshipTypeUint = 2;
649 relationshipTypeUint = 3;
663 offset += uint64_t_size;
665 offset += uint64_t_size;
669 numberOfBytesWritten = timelineRelationshipPacketSize;
675 unsigned int bufferSize,
676 unsigned int& numberOfBytesWritten)
679 numberOfBytesWritten = 0;
682 if (buffer ==
nullptr || bufferSize == 0)
688 unsigned int uint8_t_size =
sizeof(uint8_t);
690 unsigned int uint64_t_size =
sizeof(uint64_t);
691 unsigned int threadId_size =
sizeof(std::thread::id);
704 std::vector<std::vector<std::string>> timelineDirectoryMessages
706 {
"0",
"declareLabel",
"declare label",
"ps",
"guid,value" },
707 {
"1",
"declareEntity",
"declare entity",
"p",
"guid" },
708 {
"2",
"declareEventClass",
"declare event class",
"p",
"guid" },
709 {
"3",
"declareRelationship",
"declare relationship",
"Ippp",
710 "relationshipType,relationshipGuid,headGuid,tailGuid" },
711 {
"4",
"declareEvent",
"declare event",
"@tp",
"timestamp,threadId,eventGuid" }
715 std::vector<uint32_t> swTraceBuffer;
716 for (
const auto& directoryComponent : timelineDirectoryMessages)
722 declId = boost::numeric_cast<uint32_t>(std::stoul(directoryComponent[0]));
724 catch (
const std::exception&)
728 swTraceBuffer.push_back(declId);
731 result &= ConvertDirectoryComponent<SwTraceNameCharPolicy>(directoryComponent[1], swTraceBuffer);
732 result &= ConvertDirectoryComponent<SwTraceCharPolicy> (directoryComponent[2], swTraceBuffer);
733 result &= ConvertDirectoryComponent<SwTraceTypeCharPolicy>(directoryComponent[3], swTraceBuffer);
734 result &= ConvertDirectoryComponent<SwTraceCharPolicy> (directoryComponent[4], swTraceBuffer);
741 unsigned int dataLength = 3 * uint8_t_size +
742 boost::numeric_cast<
unsigned int>(swTraceBuffer.size()) *
746 unsigned int timelineDirectoryPacketSize = 2 * uint32_t_size +
750 if (timelineDirectoryPacketSize > bufferSize)
759 unsigned int offset = 0;
768 uint8_t streamVersion = 4;
769 uint8_t pointerBytes = boost::numeric_cast<uint8_t>(uint64_t_size);
770 uint8_t threadIdBytes = boost::numeric_cast<uint8_t>(threadId_size);
771 switch (threadIdBytes)
780 offset += uint8_t_size;
782 offset += uint8_t_size;
784 offset += uint8_t_size;
787 uint32_t numberOfDeclarations = boost::numeric_cast<uint32_t>(timelineDirectoryMessages.size());
790 for (uint32_t i : swTraceBuffer)
797 numberOfBytesWritten = timelineDirectoryPacketSize;
803 unsigned char* buffer,
804 unsigned int bufferSize,
805 unsigned int& numberOfBytesWritten)
808 numberOfBytesWritten = 0;
811 if (buffer ==
nullptr || bufferSize == 0)
818 unsigned int uint64_t_size =
sizeof(uint64_t);
824 unsigned int packetBodySize = uint32_t_size + uint64_t_size;
827 unsigned int packetSize = 2 * uint32_t_size +
831 if (packetSize > bufferSize)
840 unsigned int offset = 0;
854 numberOfBytesWritten = packetSize;
860 std::thread::id threadId,
861 uint64_t profilingGuid,
862 unsigned char* buffer,
863 unsigned int bufferSize,
864 unsigned int& numberOfBytesWritten)
867 numberOfBytesWritten = 0;
870 if (buffer ==
nullptr || bufferSize == 0)
877 unsigned int uint64_t_size =
sizeof(uint64_t);
878 unsigned int threadId_size =
sizeof(std::thread::id);
884 unsigned int timelineEventPacketDataLength = uint32_t_size +
890 unsigned int timelineEventPacketSize = 2 * uint32_t_size +
891 timelineEventPacketDataLength;
894 if (timelineEventPacketSize > bufferSize)
903 unsigned int offset = 0;
915 offset += uint64_t_size;
916 WriteBytes(buffer, offset, &threadId, threadId_size);
917 offset += threadId_size;
919 offset += uint64_t_size;
922 numberOfBytesWritten = timelineEventPacketSize;
929 std::stringstream outputStream, centrePadding;
930 int padding = spacingWidth -
static_cast<int>(stringToPass.size());
932 for (
int i = 0; i < padding / 2; ++i)
934 centrePadding <<
" ";
937 outputStream << centrePadding.str() << stringToPass << centrePadding.str();
939 if (padding > 0 && padding %2 != 0)
944 return outputStream.str();
958 std::cout << std::string(body.size(),
'-') <<
"\n";
973 std::cout << std::string(body.size(),
'-') <<
"\n";
1004 std::cout << std::string(body.size(),
'-') <<
"\n";
1010 std::unordered_map<
unsigned short, std::shared_ptr<Counter>> counterMap)
1012 std::string categoryBody;
1013 std::string categoryHeader;
1016 categoryHeader.append(
" | ");
1018 categoryHeader.append(
" | ");
1020 categoryHeader.append(
" | ");
1022 categoryHeader.append(
"\n");
1025 categoryBody.append(
" | ");
1027 categoryBody.append(
" | ");
1029 categoryBody.append(
" | ");
1032 std::cout <<
"\n" <<
"\n";
1035 std::cout << std::string(categoryHeader.size(),
'=') <<
"\n";
1037 std::cout << categoryHeader;
1039 std::cout << std::string(categoryBody.size(),
'-') <<
"\n";
1041 std::cout << categoryBody;
1043 std::string counterHeader;
1046 counterHeader.append(
" | ");
1048 counterHeader.append(
" | ");
1050 counterHeader.append(
" | ");
1052 counterHeader.append(
" | ");
1054 counterHeader.append(
" | ");
1056 counterHeader.append(
" | ");
1058 counterHeader.append(
" | ");
1060 counterHeader.append(
" | ");
1062 counterHeader.append(
" | ");
1064 counterHeader.append(
"\n");
1066 std::cout <<
"\n" <<
"\n";
1068 static_cast<int>(counterHeader.size()));
1070 std::cout << std::string(counterHeader.size(),
'=') <<
"\n";
1071 std::cout << counterHeader;
1072 for (
auto& it: category->m_Counters) {
1073 auto search = counterMap.find(it);
1074 if(search != counterMap.end()) {
1082 std::string devicesHeader;
1085 devicesHeader.append(
" | ");
1087 devicesHeader.append(
" | ");
1089 devicesHeader.append(
"\n");
1091 std::cout <<
"\n" <<
"\n";
1094 std::cout << std::string(devicesHeader.size(),
'=') <<
"\n";
1095 std::cout << devicesHeader;
1096 for (
auto& it: counterDirectory.
GetDevices()) {
1100 std::string counterSetHeader;
1103 counterSetHeader.append(
" | ");
1105 counterSetHeader.append(
" | ");
1107 counterSetHeader.append(
"\n");
1109 std::cout <<
"\n" <<
"\n";
1112 std::cout << std::string(counterSetHeader.size(),
'=') <<
"\n";
1114 std::cout << counterSetHeader;
1129 #if USE_CLOCK_MONOTONIC_RAW 1130 using clock = MonotonicClockRaw;
1132 using clock = std::chrono::steady_clock;
1136 auto timestamp = clock::now();
1138 return static_cast<uint64_t
>(timestamp.time_since_epoch().count());
1148 bool operator==(
const std::vector<uint8_t>& left, std::thread::id right)
1150 return std::memcmp(left.data(), &right, left.size()) == 0;
virtual const Devices & GetDevices() const =0
std::vector< char > m_ArgTypes
std::string CentreAlignFormatting(const std::string &stringToPass, const int spacingWidth)
void PrintCounterDirectory(ICounterDirectory &counterDirectory)
uint64_t ReadUint64(const IPacketBufferPtr &packetBuffer, unsigned int offset)
std::string GetSoftwareVersion()
ProfilingRelationshipType
TimelinePacketStatus WriteTimelineEventClassBinaryPacket(uint64_t profilingGuid, unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
void WriteUint64(const std::unique_ptr< IPacketBuffer > &packetBuffer, unsigned int offset, uint64_t value)
uint16_t GetNextUid(bool peekOnly)
void WriteUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint16_t value)
uint16_t ReadUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset)
std::vector< std::string > m_ArgNames
virtual const Categories & GetCategories() const =0
std::unique_ptr< IPacketBuffer > IPacketBufferPtr
std::string GetSoftwareInfo()
TimelinePacketStatus WriteTimelineEntityBinaryPacket(uint64_t profilingGuid, unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
void PrintDeviceDetails(const std::pair< const unsigned short, std::unique_ptr< Device >> &devicePair)
std::string GetProcessName()
virtual const CounterSets & GetCounterSets() const =0
std::string GetHardwareVersion()
std::vector< uint16_t > GetNextCounterUids(uint16_t firstUid, uint16_t cores)
void PrintCounterSetDetails(const std::pair< const unsigned short, std::unique_ptr< CounterSet >> &counterSetPair)
void WriteUint8(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint8_t value)
Head retains(parents) Tail.
bool operator==(const std::vector< uint8_t > &left, std::thread::id right)
TimelinePacketStatus WriteTimelineLabelBinaryPacket(uint64_t profilingGuid, const std::string &label, unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
void WriteBytes(const IPacketBufferPtr &packetBuffer, unsigned int offset, const void *value, unsigned int valueSize)
void PrintCounterDetails(std::shared_ptr< Counter > &counter)
TimelinePacketStatus WriteTimelineRelationshipBinaryPacket(ProfilingRelationshipType relationshipType, uint64_t relationshipGuid, uint64_t headGuid, uint64_t tailGuid, unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
virtual const Counters & GetCounters() const =0
Head execution start depends on Tail execution completion.
uint32_t ReadUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset)
TimelinePacketStatus WriteTimelineEventBinaryPacket(uint64_t timestamp, std::thread::id threadId, uint64_t profilingGuid, unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
void ReadBytes(const IPacketBufferPtr &packetBuffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
void PrintCategoryDetails(const std::unique_ptr< Category > &category, std::unordered_map< unsigned short, std::shared_ptr< Counter >> counterMap)
uint32_t ConstructHeader(uint32_t packetFamily, uint32_t packetId)
std::pair< uint32_t, uint32_t > CreateTimelineMessagePacketHeader(unsigned int dataLength)
uint8_t ReadUint8(const IPacketBufferPtr &packetBuffer, unsigned int offset)
TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char *buffer, unsigned int bufferSize, unsigned int &numberOfBytesWritten)
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)
void WriteUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint32_t value)
uint32_t CalculateSizeOfPaddedSwString(const std::string &str)