2 // Copyright © 2017 Arm Ltd. All rights reserved.
3 // SPDX-License-Identifier: MIT
6 #include "ProfilingUtils.hpp"
8 #include <armnn/Version.hpp>
10 #include <WallClockTimer.hpp>
12 #include <boost/assert.hpp>
27 void ThrowIfCantGenerateNextUid(uint16_t uid, uint16_t cores = 0)
29 // Check that it is possible to generate the next UID without causing an overflow
34 // Number of cores not specified or set to 1 (a value of zero indicates the device is not capable of
35 // running multiple parallel workloads and will not provide multiple streams of data for each event)
36 if (uid == std::numeric_limits<uint16_t>::max())
38 throw RuntimeException("Generating the next UID for profiling would result in an overflow");
42 // Multiple cores available, as max_counter_uid has to be set to: counter_uid + cores - 1, the maximum
43 // allowed value for a counter UID is consequently: uint16_t_max - cores + 1
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");
52 } // Anonymous namespace
54 uint16_t GetNextUid(bool peekOnly)
56 // The UID used for profiling objects and events. The first valid UID is 1, as 0 is a reserved value
57 static uint16_t uid = 1;
59 // Check that it is possible to generate the next UID without causing an overflow (throws in case of error)
60 ThrowIfCantGenerateNextUid(uid);
74 std::vector<uint16_t> GetNextCounterUids(uint16_t firstUid, uint16_t cores)
76 // Check that it is possible to generate the next counter UID without causing an overflow (throws in case of error)
77 ThrowIfCantGenerateNextUid(firstUid, cores);
79 // Get the next counter UIDs
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++;
89 void WriteBytes(const IPacketBufferPtr& packetBuffer, unsigned int offset, const void* value, unsigned int valueSize)
91 BOOST_ASSERT(packetBuffer);
93 WriteBytes(packetBuffer->GetWritableData(), offset, value, valueSize);
96 uint32_t ConstructHeader(uint32_t packetFamily,
99 return ((packetFamily & 0x3F) << 26)|
100 ((packetId & 0x3FF) << 16);
103 uint32_t ConstructHeader(uint32_t packetFamily,
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);
119 void WriteUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint32_t value)
121 BOOST_ASSERT(packetBuffer);
123 WriteUint32(packetBuffer->GetWritableData(), offset, value);
126 void WriteUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint16_t value)
128 BOOST_ASSERT(packetBuffer);
130 WriteUint16(packetBuffer->GetWritableData(), offset, value);
133 void WriteUint8(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint8_t 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);
190 void ReadBytes(const IPacketBufferPtr& packetBuffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
192 BOOST_ASSERT(packetBuffer);
194 ReadBytes(packetBuffer->GetReadableData(), offset, valueSize, outValue);
197 uint64_t ReadUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset)
199 BOOST_ASSERT(packetBuffer);
201 return ReadUint64(packetBuffer->GetReadableData(), offset);
204 uint32_t ReadUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset)
206 BOOST_ASSERT(packetBuffer);
208 return ReadUint32(packetBuffer->GetReadableData(), offset);
211 uint16_t ReadUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset)
213 BOOST_ASSERT(packetBuffer);
215 return ReadUint16(packetBuffer->GetReadableData(), offset);
218 uint8_t ReadUint8(const IPacketBufferPtr& packetBuffer, unsigned int 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];
282 std::string GetSoftwareInfo()
284 return std::string("ArmNN");
287 std::string GetHardwareVersion()
289 return std::string();
292 std::string GetSoftwareVersion()
294 std::string armnnVersion(ARMNN_VERSION);
295 std::string result = "Armnn " + armnnVersion.substr(2,2) + "." + armnnVersion.substr(4,2);
299 std::string GetProcessName()
301 std::ifstream comm("/proc/self/comm");
307 // Calculate the actual length an SwString will be including the terminating null character
308 // padding to bring it to the next uint32_t boundary but minus the leading uint32_t encoding
309 // the size to allow the offset to be correctly updated when decoding a binary packet.
310 uint32_t CalculateSizeOfPaddedSwString(const std::string& str)
312 std::vector<uint32_t> swTraceString;
313 StringToSwTraceString<SwTraceCharPolicy>(str, swTraceString);
314 unsigned int uint32_t_size = sizeof(uint32_t);
315 uint32_t size = (boost::numeric_cast<uint32_t>(swTraceString.size()) - 1) * uint32_t_size;
319 // Read TimelineMessageDirectoryPacket from given IPacketBuffer and offset
320 SwTraceMessage ReadSwTraceMessage(const unsigned char* packetBuffer, unsigned int& offset)
322 BOOST_ASSERT(packetBuffer);
324 unsigned int uint32_t_size = sizeof(uint32_t);
326 SwTraceMessage swTraceMessage;
329 uint32_t readDeclId = ReadUint32(packetBuffer, offset);
330 swTraceMessage.m_Id = readDeclId;
332 // SWTrace "namestring" format
333 // length of the string (first 4 bytes) + string + null terminator
335 // Check the decl_name
336 offset += uint32_t_size;
337 uint32_t swTraceDeclNameLength = ReadUint32(packetBuffer, offset);
339 offset += uint32_t_size;
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()); // name
347 offset += CalculateSizeOfPaddedSwString(swTraceMessage.m_Name);
348 uint32_t swTraceUINameLength = ReadUint32(packetBuffer, offset);
350 offset += uint32_t_size;
351 swTraceStringBuffer.resize(swTraceUINameLength - 1);
352 std::memcpy(swTraceStringBuffer.data(),
353 packetBuffer + offset, swTraceStringBuffer.size());
355 swTraceMessage.m_UiName.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // ui_name
358 offset += CalculateSizeOfPaddedSwString(swTraceMessage.m_UiName);
359 uint32_t swTraceArgTypesLength = ReadUint32(packetBuffer, offset);
361 offset += uint32_t_size;
362 swTraceStringBuffer.resize(swTraceArgTypesLength - 1);
363 std::memcpy(swTraceStringBuffer.data(),
364 packetBuffer + offset, swTraceStringBuffer.size());
366 swTraceMessage.m_ArgTypes.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // arg_types
368 std::string swTraceString(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
371 offset += CalculateSizeOfPaddedSwString(swTraceString);
372 uint32_t swTraceArgNamesLength = ReadUint32(packetBuffer, offset);
374 offset += uint32_t_size;
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, ','))
384 swTraceMessage.m_ArgNames.push_back(argName);
387 offset += CalculateSizeOfPaddedSwString(swTraceString);
389 return swTraceMessage;
392 /// Creates a timeline packet header
395 /// packetFamiliy Timeline Packet Family
396 /// packetClass Timeline Packet Class
397 /// packetType Timeline Packet Type
398 /// streamId Stream identifier
399 /// seqeunceNumbered When non-zero the 4 bytes following the header is a u32 sequence number
400 /// dataLength Unsigned 24-bit integer. Length of data, in bytes. Zero is permitted
403 /// Pair of uint32_t containing word0 and word1 of the header
404 std::pair<uint32_t, uint32_t> CreateTimelinePacketHeader(uint32_t packetFamily,
405 uint32_t packetClass,
408 uint32_t sequenceNumbered,
411 // Packet header word 0:
412 // 26:31 [6] packet_family: timeline Packet Family, value 0b000001
413 // 19:25 [7] packet_class: packet class
414 // 16:18 [3] packet_type: packet type
415 // 8:15 [8] reserved: all zeros
416 // 0:7 [8] stream_id: stream identifier
417 uint32_t packetHeaderWord0 = ((packetFamily & 0x0000003F) << 26) |
418 ((packetClass & 0x0000007F) << 19) |
419 ((packetType & 0x00000007) << 16) |
420 ((streamId & 0x00000007) << 0);
422 // Packet header word 1:
423 // 25:31 [7] reserved: all zeros
424 // 24 [1] sequence_numbered: when non-zero the 4 bytes following the header is a u32 sequence number
425 // 0:23 [24] data_length: unsigned 24-bit integer. Length of data, in bytes. Zero is permitted
426 uint32_t packetHeaderWord1 = ((sequenceNumbered & 0x00000001) << 24) |
427 ((dataLength & 0x00FFFFFF) << 0);
429 return std::make_pair(packetHeaderWord0, packetHeaderWord1);
432 /// Creates a packet header for the timeline messages:
435 /// * declareEventClass
436 /// * declareRelationship
440 /// dataLength The length of the message body in bytes
443 /// Pair of uint32_t containing word0 and word1 of the header
444 std::pair<uint32_t, uint32_t> CreateTimelineMessagePacketHeader(unsigned int dataLength)
446 return CreateTimelinePacketHeader(1, // Packet family
450 0, // Sequence number
451 dataLength); // Data length
454 TimelinePacketStatus WriteTimelineLabelBinaryPacket(uint64_t profilingGuid,
455 const std::string& label,
456 unsigned char* buffer,
457 unsigned int bufferSize,
458 unsigned int& numberOfBytesWritten)
460 // Initialize the output value
461 numberOfBytesWritten = 0;
463 // Check that the given buffer is valid
464 if (buffer == nullptr || bufferSize == 0)
466 return TimelinePacketStatus::BufferExhaustion;
470 unsigned int uint32_t_size = sizeof(uint32_t);
471 unsigned int uint64_t_size = sizeof(uint64_t);
473 // Convert the label into a SWTrace string
474 std::vector<uint32_t> swTraceLabel;
475 bool result = StringToSwTraceString<SwTraceCharPolicy>(label, swTraceLabel);
478 return TimelinePacketStatus::Error;
481 // Calculate the size of the SWTrace string label (in bytes)
482 unsigned int swTraceLabelSize = boost::numeric_cast<unsigned int>(swTraceLabel.size()) * uint32_t_size;
484 // Calculate the length of the data (in bytes)
485 unsigned int timelineLabelPacketDataLength = uint32_t_size + // decl_Id
486 uint64_t_size + // Profiling GUID
487 swTraceLabelSize; // Label
489 // Calculate the timeline binary packet size (in bytes)
490 unsigned int timelineLabelPacketSize = 2 * uint32_t_size + // Header (2 words)
491 timelineLabelPacketDataLength; // decl_Id + Profiling GUID + label
493 // Check whether the timeline binary packet fits in the given buffer
494 if (timelineLabelPacketSize > bufferSize)
496 return TimelinePacketStatus::BufferExhaustion;
499 // Create packet header
500 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(timelineLabelPacketDataLength);
502 // Initialize the offset for writing in the buffer
503 unsigned int offset = 0;
505 // Write the timeline binary packet header to the buffer
506 WriteUint32(buffer, offset, packetHeader.first);
507 offset += uint32_t_size;
508 WriteUint32(buffer, offset, packetHeader.second);
509 offset += uint32_t_size;
511 // Write decl_Id to the buffer
512 WriteUint32(buffer, offset, 0u);
513 offset += uint32_t_size;
515 // Write the timeline binary packet payload to the buffer
516 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
517 offset += uint64_t_size;
518 for (uint32_t swTraceLabelWord : swTraceLabel)
520 WriteUint32(buffer, offset, swTraceLabelWord); // Label
521 offset += uint32_t_size;
524 // Update the number of bytes written
525 numberOfBytesWritten = timelineLabelPacketSize;
527 return TimelinePacketStatus::Ok;
530 TimelinePacketStatus WriteTimelineEntityBinaryPacket(uint64_t profilingGuid,
531 unsigned char* buffer,
532 unsigned int bufferSize,
533 unsigned int& numberOfBytesWritten)
535 // Initialize the output value
536 numberOfBytesWritten = 0;
538 // Check that the given buffer is valid
539 if (buffer == nullptr || bufferSize == 0)
541 return TimelinePacketStatus::BufferExhaustion;
545 unsigned int uint32_t_size = sizeof(uint32_t);
546 unsigned int uint64_t_size = sizeof(uint64_t);
548 // Calculate the length of the data (in bytes)
549 unsigned int timelineEntityPacketDataLength = uint32_t_size + uint64_t_size; // decl_id + Profiling GUID
552 // Calculate the timeline binary packet size (in bytes)
553 unsigned int timelineEntityPacketSize = 2 * uint32_t_size + // Header (2 words)
554 timelineEntityPacketDataLength; // Profiling GUID
556 // Check whether the timeline binary packet fits in the given buffer
557 if (timelineEntityPacketSize > bufferSize)
559 return TimelinePacketStatus::BufferExhaustion;
562 // Create packet header
563 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(timelineEntityPacketDataLength);
565 // Initialize the offset for writing in the buffer
566 unsigned int offset = 0;
568 // Write the timeline binary packet header to the buffer
569 WriteUint32(buffer, offset, packetHeader.first);
570 offset += uint32_t_size;
571 WriteUint32(buffer, offset, packetHeader.second);
572 offset += uint32_t_size;
574 // Write the decl_Id to the buffer
575 WriteUint32(buffer, offset, 1u);
576 offset += uint32_t_size;
578 // Write the timeline binary packet payload to the buffer
579 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
581 // Update the number of bytes written
582 numberOfBytesWritten = timelineEntityPacketSize;
584 return TimelinePacketStatus::Ok;
587 TimelinePacketStatus WriteTimelineRelationshipBinaryPacket(ProfilingRelationshipType relationshipType,
588 uint64_t relationshipGuid,
591 unsigned char* buffer,
592 unsigned int bufferSize,
593 unsigned int& numberOfBytesWritten)
595 // Initialize the output value
596 numberOfBytesWritten = 0;
598 // Check that the given buffer is valid
599 if (buffer == nullptr || bufferSize == 0)
601 return TimelinePacketStatus::BufferExhaustion;
605 unsigned int uint32_t_size = sizeof(uint32_t);
606 unsigned int uint64_t_size = sizeof(uint64_t);
608 // Calculate the length of the data (in bytes)
609 unsigned int timelineRelationshipPacketDataLength = uint32_t_size * 2 + // decl_id + Relationship Type
610 uint64_t_size * 3; // Relationship GUID + Head GUID + tail GUID
612 // Calculate the timeline binary packet size (in bytes)
613 unsigned int timelineRelationshipPacketSize = 2 * uint32_t_size + // Header (2 words)
614 timelineRelationshipPacketDataLength;
616 // Check whether the timeline binary packet fits in the given buffer
617 if (timelineRelationshipPacketSize > bufferSize)
619 return TimelinePacketStatus::BufferExhaustion;
622 // Create packet header
623 uint32_t dataLength = boost::numeric_cast<uint32_t>(timelineRelationshipPacketDataLength);
624 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(dataLength);
626 // Initialize the offset for writing in the buffer
627 unsigned int offset = 0;
629 // Write the timeline binary packet header to the buffer
630 WriteUint32(buffer, offset, packetHeader.first);
631 offset += uint32_t_size;
632 WriteUint32(buffer, offset, packetHeader.second);
633 offset += uint32_t_size;
635 uint32_t relationshipTypeUint = 0;
637 switch (relationshipType)
639 case ProfilingRelationshipType::RetentionLink:
640 relationshipTypeUint = 0;
642 case ProfilingRelationshipType::ExecutionLink:
643 relationshipTypeUint = 1;
645 case ProfilingRelationshipType::DataLink:
646 relationshipTypeUint = 2;
648 case ProfilingRelationshipType::LabelLink:
649 relationshipTypeUint = 3;
652 throw InvalidArgumentException("Unknown relationship type given.");
655 // Write the timeline binary packet payload to the buffer
656 // decl_id of the timeline message
658 WriteUint32(buffer, offset, declId); // decl_id
659 offset += uint32_t_size;
660 WriteUint32(buffer, offset, relationshipTypeUint); // Relationship Type
661 offset += uint32_t_size;
662 WriteUint64(buffer, offset, relationshipGuid); // GUID of this relationship
663 offset += uint64_t_size;
664 WriteUint64(buffer, offset, headGuid); // head of relationship GUID
665 offset += uint64_t_size;
666 WriteUint64(buffer, offset, tailGuid); // tail of relationship GUID
668 // Update the number of bytes written
669 numberOfBytesWritten = timelineRelationshipPacketSize;
671 return TimelinePacketStatus::Ok;
674 TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char* buffer,
675 unsigned int bufferSize,
676 unsigned int& numberOfBytesWritten)
678 // Initialize the output value
679 numberOfBytesWritten = 0;
681 // Check that the given buffer is valid
682 if (buffer == nullptr || bufferSize == 0)
684 return TimelinePacketStatus::BufferExhaustion;
688 unsigned int uint8_t_size = sizeof(uint8_t);
689 unsigned int uint32_t_size = sizeof(uint32_t);
690 unsigned int uint64_t_size = sizeof(uint64_t);
691 unsigned int threadId_size = sizeof(std::thread::id);
693 // The payload/data of the packet consists of swtrace event definitions encoded according
694 // to the swtrace directory specification. The messages being the five defined below:
696 // | decl_id | decl_name | ui_name | arg_types | arg_names |
697 // |-----------|---------------------|-----------------------|-------------|-------------------------------------|
698 // | 0 | declareLabel | declare label | ps | guid,value |
699 // | 1 | declareEntity | declare entity | p | guid |
700 // | 2 | declareEventClass | declare event class | p | guid |
701 // | 3 | declareRelationship | declare relationship | Ippp | relationshipType,relationshipGuid, |
702 // | | | | | headGuid,tailGuid |
703 // | 4 | declareEvent | declare event | @tp | timestamp,threadId,eventGuid |
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" }
714 // Build the message declarations
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&)
726 return TimelinePacketStatus::Error;
728 swTraceBuffer.push_back(declId);
731 result &= ConvertDirectoryComponent<SwTraceNameCharPolicy>(directoryComponent[1], swTraceBuffer); // decl_name
732 result &= ConvertDirectoryComponent<SwTraceCharPolicy> (directoryComponent[2], swTraceBuffer); // ui_name
733 result &= ConvertDirectoryComponent<SwTraceTypeCharPolicy>(directoryComponent[3], swTraceBuffer); // arg_types
734 result &= ConvertDirectoryComponent<SwTraceCharPolicy> (directoryComponent[4], swTraceBuffer); // arg_names
737 return TimelinePacketStatus::Error;
741 unsigned int dataLength = 3 * uint8_t_size + // Stream header (3 bytes)
742 boost::numeric_cast<unsigned int>(swTraceBuffer.size()) *
743 uint32_t_size; // Trace directory (5 messages)
745 // Calculate the timeline directory binary packet size (in bytes)
746 unsigned int timelineDirectoryPacketSize = 2 * uint32_t_size + // Header (2 words)
747 dataLength; // Payload
749 // Check whether the timeline directory binary packet fits in the given buffer
750 if (timelineDirectoryPacketSize > bufferSize)
752 return TimelinePacketStatus::BufferExhaustion;
755 // Create packet header
756 auto packetHeader = CreateTimelinePacketHeader(1, 0, 0, 0, 0, boost::numeric_cast<uint32_t>(dataLength));
758 // Initialize the offset for writing in the buffer
759 unsigned int offset = 0;
761 // Write the timeline binary packet header to the buffer
762 WriteUint32(buffer, offset, packetHeader.first);
763 offset += uint32_t_size;
764 WriteUint32(buffer, offset, packetHeader.second);
765 offset += uint32_t_size;
767 // Write the stream header
768 uint8_t streamVersion = 4;
769 uint8_t pointerBytes = boost::numeric_cast<uint8_t>(uint64_t_size); // All GUIDs are uint64_t
770 uint8_t threadIdBytes = boost::numeric_cast<uint8_t>(threadId_size);
771 switch (threadIdBytes)
773 case 4: // Typically Windows and Android
774 case 8: // Typically Linux
775 break; // Valid values
777 return TimelinePacketStatus::Error; // Invalid value
779 WriteUint8(buffer, offset, streamVersion);
780 offset += uint8_t_size;
781 WriteUint8(buffer, offset, pointerBytes);
782 offset += uint8_t_size;
783 WriteUint8(buffer, offset, threadIdBytes);
784 offset += uint8_t_size;
786 // Write the SWTrace directory
787 uint32_t numberOfDeclarations = boost::numeric_cast<uint32_t>(timelineDirectoryMessages.size());
788 WriteUint32(buffer, offset, numberOfDeclarations); // Number of declarations
789 offset += uint32_t_size;
790 for (uint32_t i : swTraceBuffer)
792 WriteUint32(buffer, offset, i); // Message declarations
793 offset += uint32_t_size;
796 // Update the number of bytes written
797 numberOfBytesWritten = timelineDirectoryPacketSize;
799 return TimelinePacketStatus::Ok;
802 TimelinePacketStatus WriteTimelineEventClassBinaryPacket(uint64_t profilingGuid,
803 unsigned char* buffer,
804 unsigned int bufferSize,
805 unsigned int& numberOfBytesWritten)
807 // Initialize the output value
808 numberOfBytesWritten = 0;
810 // Check that the given buffer is valid
811 if (buffer == nullptr || bufferSize == 0)
813 return TimelinePacketStatus::BufferExhaustion;
817 unsigned int uint32_t_size = sizeof(uint32_t);
818 unsigned int uint64_t_size = sizeof(uint64_t);
820 // decl_id of the timeline message
823 // Calculate the length of the data (in bytes)
824 unsigned int packetBodySize = uint32_t_size + uint64_t_size; // decl_id + Profiling GUID
826 // Calculate the timeline binary packet size (in bytes)
827 unsigned int packetSize = 2 * uint32_t_size + // Header (2 words)
828 packetBodySize; // Body
830 // Check whether the timeline binary packet fits in the given buffer
831 if (packetSize > bufferSize)
833 return TimelinePacketStatus::BufferExhaustion;
836 // Create packet header
837 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(packetBodySize);
839 // Initialize the offset for writing in the buffer
840 unsigned int offset = 0;
842 // Write the timeline binary packet header to the buffer
843 WriteUint32(buffer, offset, packetHeader.first);
844 offset += uint32_t_size;
845 WriteUint32(buffer, offset, packetHeader.second);
846 offset += uint32_t_size;
848 // Write the timeline binary packet payload to the buffer
849 WriteUint32(buffer, offset, declId); // decl_id
850 offset += uint32_t_size;
851 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
853 // Update the number of bytes written
854 numberOfBytesWritten = packetSize;
856 return TimelinePacketStatus::Ok;
859 TimelinePacketStatus WriteTimelineEventBinaryPacket(uint64_t timestamp,
860 std::thread::id threadId,
861 uint64_t profilingGuid,
862 unsigned char* buffer,
863 unsigned int bufferSize,
864 unsigned int& numberOfBytesWritten)
866 // Initialize the output value
867 numberOfBytesWritten = 0;
869 // Check that the given buffer is valid
870 if (buffer == nullptr || bufferSize == 0)
872 return TimelinePacketStatus::BufferExhaustion;
876 unsigned int uint32_t_size = sizeof(uint32_t);
877 unsigned int uint64_t_size = sizeof(uint64_t);
878 unsigned int threadId_size = sizeof(std::thread::id);
880 // decl_id of the timeline message
883 // Calculate the length of the data (in bytes)
884 unsigned int timelineEventPacketDataLength = uint32_t_size + // decl_id
885 uint64_t_size + // Timestamp
886 threadId_size + // Thread id
887 uint64_t_size; // Profiling GUID
889 // Calculate the timeline binary packet size (in bytes)
890 unsigned int timelineEventPacketSize = 2 * uint32_t_size + // Header (2 words)
891 timelineEventPacketDataLength; // Timestamp + thread id + profiling GUID
893 // Check whether the timeline binary packet fits in the given buffer
894 if (timelineEventPacketSize > bufferSize)
896 return TimelinePacketStatus::BufferExhaustion;
899 // Create packet header
900 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(timelineEventPacketDataLength);
902 // Initialize the offset for writing in the buffer
903 unsigned int offset = 0;
905 // Write the timeline binary packet header to the buffer
906 WriteUint32(buffer, offset, packetHeader.first);
907 offset += uint32_t_size;
908 WriteUint32(buffer, offset, packetHeader.second);
909 offset += uint32_t_size;
911 // Write the timeline binary packet payload to the buffer
912 WriteUint32(buffer, offset, declId); // decl_id
913 offset += uint32_t_size;
914 WriteUint64(buffer, offset, timestamp); // Timestamp
915 offset += uint64_t_size;
916 WriteBytes(buffer, offset, &threadId, threadId_size); // Thread id
917 offset += threadId_size;
918 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
919 offset += uint64_t_size;
921 // Update the number of bytes written
922 numberOfBytesWritten = timelineEventPacketSize;
924 return TimelinePacketStatus::Ok;
927 std::string CentreAlignFormatting(const std::string& stringToPass, const int spacingWidth)
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();
947 void PrintDeviceDetails(const std::pair<const unsigned short, std::unique_ptr<Device>>& devicePair)
951 body.append(CentreAlignFormatting(devicePair.second->m_Name, 20));
953 body.append(CentreAlignFormatting(std::to_string(devicePair.first), 13));
955 body.append(CentreAlignFormatting(std::to_string(devicePair.second->m_Cores), 10));
958 std::cout << std::string(body.size(), '-') << "\n";
962 void PrintCounterSetDetails(const std::pair<const unsigned short, std::unique_ptr<CounterSet>>& counterSetPair)
966 body.append(CentreAlignFormatting(counterSetPair.second->m_Name, 20));
968 body.append(CentreAlignFormatting(std::to_string(counterSetPair.first), 13));
970 body.append(CentreAlignFormatting(std::to_string(counterSetPair.second->m_Count), 10));
973 std::cout << std::string(body.size(), '-') << "\n";
978 void PrintCounterDetails(std::shared_ptr<Counter>& counter)
982 body.append(CentreAlignFormatting(counter->m_Name, 20));
984 body.append(CentreAlignFormatting(counter->m_Description, 50));
986 body.append(CentreAlignFormatting(counter->m_Units, 14));
988 body.append(CentreAlignFormatting(std::to_string(counter->m_Uid), 6));
990 body.append(CentreAlignFormatting(std::to_string(counter->m_MaxCounterUid), 10));
992 body.append(CentreAlignFormatting(std::to_string(counter->m_Class), 8));
994 body.append(CentreAlignFormatting(std::to_string(counter->m_Interpolation), 14));
996 body.append(CentreAlignFormatting(std::to_string(counter->m_Multiplier), 20));
998 body.append(CentreAlignFormatting(std::to_string(counter->m_CounterSetUid), 16));
1000 body.append(CentreAlignFormatting(std::to_string(counter->m_DeviceUid), 14));
1004 std::cout << std::string(body.size(), '-') << "\n";
1009 void PrintCategoryDetails(const std::unique_ptr<Category>& category,
1010 std::unordered_map<unsigned short, std::shared_ptr<Counter>> counterMap)
1012 std::string categoryBody;
1013 std::string categoryHeader;
1015 categoryHeader.append(CentreAlignFormatting("Name", 20));
1016 categoryHeader.append(" | ");
1017 categoryHeader.append(CentreAlignFormatting("Device", 12));
1018 categoryHeader.append(" | ");
1019 categoryHeader.append(CentreAlignFormatting("Counter set UID:", 16));
1020 categoryHeader.append(" | ");
1021 categoryHeader.append(CentreAlignFormatting("Event Count", 14));
1022 categoryHeader.append("\n");
1024 categoryBody.append(CentreAlignFormatting(category->m_Name, 20));
1025 categoryBody.append(" | ");
1026 categoryBody.append(CentreAlignFormatting(std::to_string(category->m_DeviceUid), 12));
1027 categoryBody.append(" | ");
1028 categoryBody.append(CentreAlignFormatting(std::to_string(category->m_CounterSetUid), 16));
1029 categoryBody.append(" | ");
1030 categoryBody.append(CentreAlignFormatting(std::to_string(category->m_Counters.size()), 14));
1032 std::cout << "\n" << "\n";
1033 std::cout << CentreAlignFormatting("CATEGORY", static_cast<int>(categoryHeader.size()));
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;
1045 counterHeader.append(CentreAlignFormatting("Counter Name", 20));
1046 counterHeader.append(" | ");
1047 counterHeader.append(CentreAlignFormatting("Description", 50));
1048 counterHeader.append(" | ");
1049 counterHeader.append(CentreAlignFormatting("Units", 14));
1050 counterHeader.append(" | ");
1051 counterHeader.append(CentreAlignFormatting("UID", 6));
1052 counterHeader.append(" | ");
1053 counterHeader.append(CentreAlignFormatting("Max UID", 10));
1054 counterHeader.append(" | ");
1055 counterHeader.append(CentreAlignFormatting("Class", 8));
1056 counterHeader.append(" | ");
1057 counterHeader.append(CentreAlignFormatting("Interpolation", 14));
1058 counterHeader.append(" | ");
1059 counterHeader.append(CentreAlignFormatting("Multiplier", 20));
1060 counterHeader.append(" | ");
1061 counterHeader.append(CentreAlignFormatting("Counter set UID", 16));
1062 counterHeader.append(" | ");
1063 counterHeader.append(CentreAlignFormatting("Device UID", 14));
1064 counterHeader.append("\n");
1066 std::cout << "\n" << "\n";
1067 std::cout << CentreAlignFormatting("EVENTS IN CATEGORY: " + category->m_Name,
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()) {
1075 PrintCounterDetails(search->second);
1080 void PrintCounterDirectory(ICounterDirectory& counterDirectory)
1082 std::string devicesHeader;
1084 devicesHeader.append(CentreAlignFormatting("Device name", 20));
1085 devicesHeader.append(" | ");
1086 devicesHeader.append(CentreAlignFormatting("UID", 13));
1087 devicesHeader.append(" | ");
1088 devicesHeader.append(CentreAlignFormatting("Cores", 10));
1089 devicesHeader.append("\n");
1091 std::cout << "\n" << "\n";
1092 std::cout << CentreAlignFormatting("DEVICES", static_cast<int>(devicesHeader.size()));
1094 std::cout << std::string(devicesHeader.size(), '=') << "\n";
1095 std::cout << devicesHeader;
1096 for (auto& it: counterDirectory.GetDevices()) {
1097 PrintDeviceDetails(it);
1100 std::string counterSetHeader;
1102 counterSetHeader.append(CentreAlignFormatting("Counter set name", 20));
1103 counterSetHeader.append(" | ");
1104 counterSetHeader.append(CentreAlignFormatting("UID", 13));
1105 counterSetHeader.append(" | ");
1106 counterSetHeader.append(CentreAlignFormatting("Count", 10));
1107 counterSetHeader.append("\n");
1109 std::cout << "\n" << "\n";
1110 std::cout << CentreAlignFormatting("COUNTER SETS", static_cast<int>(counterSetHeader.size()));
1112 std::cout << std::string(counterSetHeader.size(), '=') << "\n";
1114 std::cout << counterSetHeader;
1116 for (auto& it: counterDirectory.GetCounterSets()) {
1117 PrintCounterSetDetails(it);
1120 auto counters = counterDirectory.GetCounters();
1121 for (auto& it: counterDirectory.GetCategories()) {
1122 PrintCategoryDetails(it, counters);
1127 uint64_t GetTimestamp()
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());
1141 } // namespace profiling
1143 } // namespace armnn
1148 bool operator==(const std::vector<uint8_t>& left, std::thread::id right)
1150 return std::memcmp(left.data(), &right, left.size()) == 0;