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 <armnn/utility/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 ARMNN_ASSERT(packetBuffer);
93 WriteBytes(packetBuffer->GetWritableData(), offset, value, valueSize);
96 uint32_t ConstructHeader(uint32_t packetFamily,
99 return (( packetFamily & 0x0000003F ) << 26 )|
100 (( packetId & 0x000003FF ) << 16 );
103 void WriteUint64(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint64_t value)
105 ARMNN_ASSERT(packetBuffer);
107 WriteUint64(packetBuffer->GetWritableData(), offset, value);
110 void WriteUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint32_t value)
112 ARMNN_ASSERT(packetBuffer);
114 WriteUint32(packetBuffer->GetWritableData(), offset, value);
117 void WriteUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint16_t value)
119 ARMNN_ASSERT(packetBuffer);
121 WriteUint16(packetBuffer->GetWritableData(), offset, value);
124 void WriteUint8(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint8_t value)
126 ARMNN_ASSERT(packetBuffer);
128 WriteUint8(packetBuffer->GetWritableData(), offset, value);
131 void WriteBytes(unsigned char* buffer, unsigned int offset, const void* value, unsigned int valueSize)
133 ARMNN_ASSERT(buffer);
136 for (unsigned int i = 0; i < valueSize; i++, offset++)
138 buffer[offset] = *(reinterpret_cast<const unsigned char*>(value) + i);
142 void WriteUint64(unsigned char* buffer, unsigned int offset, uint64_t value)
144 ARMNN_ASSERT(buffer);
146 buffer[offset] = static_cast<unsigned char>(value & 0xFF);
147 buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
148 buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
149 buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
150 buffer[offset + 4] = static_cast<unsigned char>((value >> 32) & 0xFF);
151 buffer[offset + 5] = static_cast<unsigned char>((value >> 40) & 0xFF);
152 buffer[offset + 6] = static_cast<unsigned char>((value >> 48) & 0xFF);
153 buffer[offset + 7] = static_cast<unsigned char>((value >> 56) & 0xFF);
156 void WriteUint32(unsigned char* buffer, unsigned int offset, uint32_t value)
158 ARMNN_ASSERT(buffer);
160 buffer[offset] = static_cast<unsigned char>(value & 0xFF);
161 buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
162 buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
163 buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
166 void WriteUint16(unsigned char* buffer, unsigned int offset, uint16_t value)
168 ARMNN_ASSERT(buffer);
170 buffer[offset] = static_cast<unsigned char>(value & 0xFF);
171 buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
174 void WriteUint8(unsigned char* buffer, unsigned int offset, uint8_t value)
176 ARMNN_ASSERT(buffer);
178 buffer[offset] = static_cast<unsigned char>(value);
181 void ReadBytes(const IPacketBufferPtr& packetBuffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
183 ARMNN_ASSERT(packetBuffer);
185 ReadBytes(packetBuffer->GetReadableData(), offset, valueSize, outValue);
188 uint64_t ReadUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset)
190 ARMNN_ASSERT(packetBuffer);
192 return ReadUint64(packetBuffer->GetReadableData(), offset);
195 uint32_t ReadUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset)
197 ARMNN_ASSERT(packetBuffer);
199 return ReadUint32(packetBuffer->GetReadableData(), offset);
202 uint16_t ReadUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset)
204 ARMNN_ASSERT(packetBuffer);
206 return ReadUint16(packetBuffer->GetReadableData(), offset);
209 uint8_t ReadUint8(const IPacketBufferPtr& packetBuffer, unsigned int offset)
211 ARMNN_ASSERT(packetBuffer);
213 return ReadUint8(packetBuffer->GetReadableData(), offset);
216 void ReadBytes(const unsigned char* buffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
218 ARMNN_ASSERT(buffer);
219 ARMNN_ASSERT(outValue);
221 for (unsigned int i = 0; i < valueSize; i++, offset++)
223 outValue[i] = static_cast<uint8_t>(buffer[offset]);
227 uint64_t ReadUint64(const unsigned char* buffer, unsigned int offset)
229 ARMNN_ASSERT(buffer);
232 value = static_cast<uint64_t>(buffer[offset]);
233 value |= static_cast<uint64_t>(buffer[offset + 1]) << 8;
234 value |= static_cast<uint64_t>(buffer[offset + 2]) << 16;
235 value |= static_cast<uint64_t>(buffer[offset + 3]) << 24;
236 value |= static_cast<uint64_t>(buffer[offset + 4]) << 32;
237 value |= static_cast<uint64_t>(buffer[offset + 5]) << 40;
238 value |= static_cast<uint64_t>(buffer[offset + 6]) << 48;
239 value |= static_cast<uint64_t>(buffer[offset + 7]) << 56;
244 uint32_t ReadUint32(const unsigned char* buffer, unsigned int offset)
246 ARMNN_ASSERT(buffer);
249 value = static_cast<uint32_t>(buffer[offset]);
250 value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
251 value |= static_cast<uint32_t>(buffer[offset + 2]) << 16;
252 value |= static_cast<uint32_t>(buffer[offset + 3]) << 24;
256 uint16_t ReadUint16(const unsigned char* buffer, unsigned int offset)
258 ARMNN_ASSERT(buffer);
261 value = static_cast<uint32_t>(buffer[offset]);
262 value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
263 return static_cast<uint16_t>(value);
266 uint8_t ReadUint8(const unsigned char* buffer, unsigned int offset)
268 ARMNN_ASSERT(buffer);
270 return buffer[offset];
273 std::string GetSoftwareInfo()
275 return std::string("ArmNN");
278 std::string GetHardwareVersion()
280 return std::string();
283 std::string GetSoftwareVersion()
285 std::string armnnVersion(ARMNN_VERSION);
286 std::string result = "Armnn " + armnnVersion.substr(2,2) + "." + armnnVersion.substr(4,2);
290 std::string GetProcessName()
292 std::ifstream comm("/proc/self/comm");
298 // Calculate the actual length an SwString will be including the terminating null character
299 // padding to bring it to the next uint32_t boundary but minus the leading uint32_t encoding
300 // the size to allow the offset to be correctly updated when decoding a binary packet.
301 uint32_t CalculateSizeOfPaddedSwString(const std::string& str)
303 std::vector<uint32_t> swTraceString;
304 StringToSwTraceString<SwTraceCharPolicy>(str, swTraceString);
305 unsigned int uint32_t_size = sizeof(uint32_t);
306 uint32_t size = (boost::numeric_cast<uint32_t>(swTraceString.size()) - 1) * uint32_t_size;
310 // Read TimelineMessageDirectoryPacket from given IPacketBuffer and offset
311 SwTraceMessage ReadSwTraceMessage(const unsigned char* packetBuffer, unsigned int& offset)
313 ARMNN_ASSERT(packetBuffer);
315 unsigned int uint32_t_size = sizeof(uint32_t);
317 SwTraceMessage swTraceMessage;
320 uint32_t readDeclId = ReadUint32(packetBuffer, offset);
321 swTraceMessage.m_Id = readDeclId;
323 // SWTrace "namestring" format
324 // length of the string (first 4 bytes) + string + null terminator
326 // Check the decl_name
327 offset += uint32_t_size;
328 uint32_t swTraceDeclNameLength = ReadUint32(packetBuffer, offset);
330 offset += uint32_t_size;
331 std::vector<unsigned char> swTraceStringBuffer(swTraceDeclNameLength - 1);
332 std::memcpy(swTraceStringBuffer.data(),
333 packetBuffer + offset, swTraceStringBuffer.size());
335 swTraceMessage.m_Name.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // name
338 offset += CalculateSizeOfPaddedSwString(swTraceMessage.m_Name);
339 uint32_t swTraceUINameLength = ReadUint32(packetBuffer, offset);
341 offset += uint32_t_size;
342 swTraceStringBuffer.resize(swTraceUINameLength - 1);
343 std::memcpy(swTraceStringBuffer.data(),
344 packetBuffer + offset, swTraceStringBuffer.size());
346 swTraceMessage.m_UiName.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // ui_name
349 offset += CalculateSizeOfPaddedSwString(swTraceMessage.m_UiName);
350 uint32_t swTraceArgTypesLength = ReadUint32(packetBuffer, offset);
352 offset += uint32_t_size;
353 swTraceStringBuffer.resize(swTraceArgTypesLength - 1);
354 std::memcpy(swTraceStringBuffer.data(),
355 packetBuffer + offset, swTraceStringBuffer.size());
357 swTraceMessage.m_ArgTypes.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // arg_types
359 std::string swTraceString(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
362 offset += CalculateSizeOfPaddedSwString(swTraceString);
363 uint32_t swTraceArgNamesLength = ReadUint32(packetBuffer, offset);
365 offset += uint32_t_size;
366 swTraceStringBuffer.resize(swTraceArgNamesLength - 1);
367 std::memcpy(swTraceStringBuffer.data(),
368 packetBuffer + offset, swTraceStringBuffer.size());
370 swTraceString.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
371 std::stringstream stringStream(swTraceString);
373 while (std::getline(stringStream, argName, ','))
375 swTraceMessage.m_ArgNames.push_back(argName);
378 offset += CalculateSizeOfPaddedSwString(swTraceString);
380 return swTraceMessage;
383 /// Creates a timeline packet header
386 /// packetFamiliy Timeline Packet Family
387 /// packetClass Timeline Packet Class
388 /// packetType Timeline Packet Type
389 /// streamId Stream identifier
390 /// seqeunceNumbered When non-zero the 4 bytes following the header is a u32 sequence number
391 /// dataLength Unsigned 24-bit integer. Length of data, in bytes. Zero is permitted
394 /// Pair of uint32_t containing word0 and word1 of the header
395 std::pair<uint32_t, uint32_t> CreateTimelinePacketHeader(uint32_t packetFamily,
396 uint32_t packetClass,
399 uint32_t sequenceNumbered,
402 // Packet header word 0:
403 // 26:31 [6] packet_family: timeline Packet Family, value 0b000001
404 // 19:25 [7] packet_class: packet class
405 // 16:18 [3] packet_type: packet type
406 // 8:15 [8] reserved: all zeros
407 // 0:7 [8] stream_id: stream identifier
408 uint32_t packetHeaderWord0 = ((packetFamily & 0x0000003F) << 26) |
409 ((packetClass & 0x0000007F) << 19) |
410 ((packetType & 0x00000007) << 16) |
411 ((streamId & 0x00000007) << 0);
413 // Packet header word 1:
414 // 25:31 [7] reserved: all zeros
415 // 24 [1] sequence_numbered: when non-zero the 4 bytes following the header is a u32 sequence number
416 // 0:23 [24] data_length: unsigned 24-bit integer. Length of data, in bytes. Zero is permitted
417 uint32_t packetHeaderWord1 = ((sequenceNumbered & 0x00000001) << 24) |
418 ((dataLength & 0x00FFFFFF) << 0);
420 return std::make_pair(packetHeaderWord0, packetHeaderWord1);
423 /// Creates a packet header for the timeline messages:
426 /// * declareEventClass
427 /// * declareRelationship
431 /// dataLength The length of the message body in bytes
434 /// Pair of uint32_t containing word0 and word1 of the header
435 std::pair<uint32_t, uint32_t> CreateTimelineMessagePacketHeader(unsigned int dataLength)
437 return CreateTimelinePacketHeader(1, // Packet family
441 0, // Sequence number
442 dataLength); // Data length
445 TimelinePacketStatus WriteTimelineLabelBinaryPacket(uint64_t profilingGuid,
446 const std::string& label,
447 unsigned char* buffer,
448 unsigned int remainingBufferSize,
449 unsigned int& numberOfBytesWritten)
451 // Initialize the output value
452 numberOfBytesWritten = 0;
454 // Check that the given buffer is valid
455 if (buffer == nullptr || remainingBufferSize == 0)
457 return TimelinePacketStatus::BufferExhaustion;
461 unsigned int uint32_t_size = sizeof(uint32_t);
462 unsigned int uint64_t_size = sizeof(uint64_t);
464 // Convert the label into a SWTrace string
465 std::vector<uint32_t> swTraceLabel;
466 bool result = StringToSwTraceString<SwTraceCharPolicy>(label, swTraceLabel);
469 return TimelinePacketStatus::Error;
472 // Calculate the size of the SWTrace string label (in bytes)
473 unsigned int swTraceLabelSize = boost::numeric_cast<unsigned int>(swTraceLabel.size()) * uint32_t_size;
475 // Calculate the length of the data (in bytes)
476 unsigned int timelineLabelPacketDataLength = uint32_t_size + // decl_Id
477 uint64_t_size + // Profiling GUID
478 swTraceLabelSize; // Label
480 // Check whether the timeline binary packet fits in the given buffer
481 if (timelineLabelPacketDataLength > remainingBufferSize)
483 return TimelinePacketStatus::BufferExhaustion;
486 // Initialize the offset for writing in the buffer
487 unsigned int offset = 0;
489 // Write decl_Id to the buffer
490 WriteUint32(buffer, offset, 0u);
491 offset += uint32_t_size;
493 // Write the timeline binary packet payload to the buffer
494 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
495 offset += uint64_t_size;
496 for (uint32_t swTraceLabelWord : swTraceLabel)
498 WriteUint32(buffer, offset, swTraceLabelWord); // Label
499 offset += uint32_t_size;
502 // Update the number of bytes written
503 numberOfBytesWritten = timelineLabelPacketDataLength;
505 return TimelinePacketStatus::Ok;
508 TimelinePacketStatus WriteTimelineEntityBinary(uint64_t profilingGuid,
509 unsigned char* buffer,
510 unsigned int remainingBufferSize,
511 unsigned int& numberOfBytesWritten)
513 // Initialize the output value
514 numberOfBytesWritten = 0;
516 // Check that the given buffer is valid
517 if (buffer == nullptr || remainingBufferSize == 0)
519 return TimelinePacketStatus::BufferExhaustion;
523 unsigned int uint32_t_size = sizeof(uint32_t);
524 unsigned int uint64_t_size = sizeof(uint64_t);
526 // Calculate the length of the data (in bytes)
527 unsigned int timelineEntityDataLength = uint32_t_size + uint64_t_size; // decl_id + Profiling GUID
529 // Check whether the timeline binary packet fits in the given buffer
530 if (timelineEntityDataLength > remainingBufferSize)
532 return TimelinePacketStatus::BufferExhaustion;
535 // Initialize the offset for writing in the buffer
536 unsigned int offset = 0;
538 // Write the decl_Id to the buffer
539 WriteUint32(buffer, offset, 1u);
540 offset += uint32_t_size;
542 // Write the timeline binary packet payload to the buffer
543 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
545 // Update the number of bytes written
546 numberOfBytesWritten = timelineEntityDataLength;
548 return TimelinePacketStatus::Ok;
551 TimelinePacketStatus WriteTimelineRelationshipBinary(ProfilingRelationshipType relationshipType,
552 uint64_t relationshipGuid,
555 unsigned char* buffer,
556 unsigned int remainingBufferSize,
557 unsigned int& numberOfBytesWritten)
559 // Initialize the output value
560 numberOfBytesWritten = 0;
562 // Check that the given buffer is valid
563 if (buffer == nullptr || remainingBufferSize == 0)
565 return TimelinePacketStatus::BufferExhaustion;
569 unsigned int uint32_t_size = sizeof(uint32_t);
570 unsigned int uint64_t_size = sizeof(uint64_t);
572 // Calculate the length of the data (in bytes)
573 unsigned int timelineRelationshipDataLength = uint32_t_size * 2 + // decl_id + Relationship Type
574 uint64_t_size * 3; // Relationship GUID + Head GUID + tail GUID
576 // Check whether the timeline binary fits in the given buffer
577 if (timelineRelationshipDataLength > remainingBufferSize)
579 return TimelinePacketStatus::BufferExhaustion;
582 // Initialize the offset for writing in the buffer
583 unsigned int offset = 0;
585 uint32_t relationshipTypeUint = 0;
587 switch (relationshipType)
589 case ProfilingRelationshipType::RetentionLink:
590 relationshipTypeUint = 0;
592 case ProfilingRelationshipType::ExecutionLink:
593 relationshipTypeUint = 1;
595 case ProfilingRelationshipType::DataLink:
596 relationshipTypeUint = 2;
598 case ProfilingRelationshipType::LabelLink:
599 relationshipTypeUint = 3;
602 throw InvalidArgumentException("Unknown relationship type given.");
605 // Write the timeline binary payload to the buffer
606 // decl_id of the timeline message
608 WriteUint32(buffer, offset, declId); // decl_id
609 offset += uint32_t_size;
610 WriteUint32(buffer, offset, relationshipTypeUint); // Relationship Type
611 offset += uint32_t_size;
612 WriteUint64(buffer, offset, relationshipGuid); // GUID of this relationship
613 offset += uint64_t_size;
614 WriteUint64(buffer, offset, headGuid); // head of relationship GUID
615 offset += uint64_t_size;
616 WriteUint64(buffer, offset, tailGuid); // tail of relationship GUID
618 // Update the number of bytes written
619 numberOfBytesWritten = timelineRelationshipDataLength;
621 return TimelinePacketStatus::Ok;
624 TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char* buffer,
625 unsigned int remainingBufferSize,
626 unsigned int& numberOfBytesWritten)
628 // Initialize the output value
629 numberOfBytesWritten = 0;
631 // Check that the given buffer is valid
632 if (buffer == nullptr || remainingBufferSize == 0)
634 return TimelinePacketStatus::BufferExhaustion;
638 unsigned int uint8_t_size = sizeof(uint8_t);
639 unsigned int uint32_t_size = sizeof(uint32_t);
640 unsigned int uint64_t_size = sizeof(uint64_t);
641 unsigned int threadId_size = sizeof(std::thread::id);
643 // The payload/data of the packet consists of swtrace event definitions encoded according
644 // to the swtrace directory specification. The messages being the five defined below:
646 // | decl_id | decl_name | ui_name | arg_types | arg_names |
647 // |-----------|---------------------|-----------------------|-------------|-------------------------------------|
648 // | 0 | declareLabel | declare label | ps | guid,value |
649 // | 1 | declareEntity | declare entity | p | guid |
650 // | 2 | declareEventClass | declare event class | p | guid |
651 // | 3 | declareRelationship | declare relationship | Ippp | relationshipType,relationshipGuid, |
652 // | | | | | headGuid,tailGuid |
653 // | 4 | declareEvent | declare event | @tp | timestamp,threadId,eventGuid |
654 std::vector<std::vector<std::string>> timelineDirectoryMessages
656 { "0", "declareLabel", "declare label", "ps", "guid,value" },
657 { "1", "declareEntity", "declare entity", "p", "guid" },
658 { "2", "declareEventClass", "declare event class", "p", "guid" },
659 { "3", "declareRelationship", "declare relationship", "Ippp",
660 "relationshipType,relationshipGuid,headGuid,tailGuid" },
661 { "4", "declareEvent", "declare event", "@tp", "timestamp,threadId,eventGuid" }
664 // Build the message declarations
665 std::vector<uint32_t> swTraceBuffer;
666 for (const auto& directoryComponent : timelineDirectoryMessages)
672 declId = boost::numeric_cast<uint32_t>(std::stoul(directoryComponent[0]));
674 catch (const std::exception&)
676 return TimelinePacketStatus::Error;
678 swTraceBuffer.push_back(declId);
681 result &= ConvertDirectoryComponent<SwTraceNameCharPolicy>(directoryComponent[1], swTraceBuffer); // decl_name
682 result &= ConvertDirectoryComponent<SwTraceCharPolicy> (directoryComponent[2], swTraceBuffer); // ui_name
683 result &= ConvertDirectoryComponent<SwTraceTypeCharPolicy>(directoryComponent[3], swTraceBuffer); // arg_types
684 result &= ConvertDirectoryComponent<SwTraceCharPolicy> (directoryComponent[4], swTraceBuffer); // arg_names
687 return TimelinePacketStatus::Error;
691 unsigned int dataLength = 3 * uint8_t_size + // Stream header (3 bytes)
692 boost::numeric_cast<unsigned int>(swTraceBuffer.size()) *
693 uint32_t_size; // Trace directory (5 messages)
695 // Calculate the timeline directory binary packet size (in bytes)
696 unsigned int timelineDirectoryPacketSize = 2 * uint32_t_size + // Header (2 words)
697 dataLength; // Payload
699 // Check whether the timeline directory binary packet fits in the given buffer
700 if (timelineDirectoryPacketSize > remainingBufferSize)
702 return TimelinePacketStatus::BufferExhaustion;
705 // Create packet header
706 auto packetHeader = CreateTimelinePacketHeader(1, 0, 0, 0, 0, boost::numeric_cast<uint32_t>(dataLength));
708 // Initialize the offset for writing in the buffer
709 unsigned int offset = 0;
711 // Write the timeline binary packet header to the buffer
712 WriteUint32(buffer, offset, packetHeader.first);
713 offset += uint32_t_size;
714 WriteUint32(buffer, offset, packetHeader.second);
715 offset += uint32_t_size;
717 // Write the stream header
718 uint8_t streamVersion = 4;
719 uint8_t pointerBytes = boost::numeric_cast<uint8_t>(uint64_t_size); // All GUIDs are uint64_t
720 uint8_t threadIdBytes = boost::numeric_cast<uint8_t>(threadId_size);
721 switch (threadIdBytes)
723 case 4: // Typically Windows and Android
724 case 8: // Typically Linux
725 break; // Valid values
727 return TimelinePacketStatus::Error; // Invalid value
729 WriteUint8(buffer, offset, streamVersion);
730 offset += uint8_t_size;
731 WriteUint8(buffer, offset, pointerBytes);
732 offset += uint8_t_size;
733 WriteUint8(buffer, offset, threadIdBytes);
734 offset += uint8_t_size;
736 // Write the SWTrace directory
737 uint32_t numberOfDeclarations = boost::numeric_cast<uint32_t>(timelineDirectoryMessages.size());
738 WriteUint32(buffer, offset, numberOfDeclarations); // Number of declarations
739 offset += uint32_t_size;
740 for (uint32_t i : swTraceBuffer)
742 WriteUint32(buffer, offset, i); // Message declarations
743 offset += uint32_t_size;
746 // Update the number of bytes written
747 numberOfBytesWritten = timelineDirectoryPacketSize;
749 return TimelinePacketStatus::Ok;
752 TimelinePacketStatus WriteTimelineEventClassBinary(uint64_t profilingGuid,
753 unsigned char* buffer,
754 unsigned int remainingBufferSize,
755 unsigned int& numberOfBytesWritten)
757 // Initialize the output value
758 numberOfBytesWritten = 0;
760 // Check that the given buffer is valid
761 if (buffer == nullptr || remainingBufferSize == 0)
763 return TimelinePacketStatus::BufferExhaustion;
767 unsigned int uint32_t_size = sizeof(uint32_t);
768 unsigned int uint64_t_size = sizeof(uint64_t);
770 // decl_id of the timeline message
773 // Calculate the length of the data (in bytes)
774 unsigned int dataSize = uint32_t_size + uint64_t_size; // decl_id + Profiling GUID
776 // Check whether the timeline binary fits in the given buffer
777 if (dataSize > remainingBufferSize)
779 return TimelinePacketStatus::BufferExhaustion;
782 // Initialize the offset for writing in the buffer
783 unsigned int offset = 0;
785 // Write the timeline binary payload to the buffer
786 WriteUint32(buffer, offset, declId); // decl_id
787 offset += uint32_t_size;
788 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
790 // Update the number of bytes written
791 numberOfBytesWritten = dataSize;
793 return TimelinePacketStatus::Ok;
796 TimelinePacketStatus WriteTimelineEventBinary(uint64_t timestamp,
797 std::thread::id threadId,
798 uint64_t profilingGuid,
799 unsigned char* buffer,
800 unsigned int remainingBufferSize,
801 unsigned int& numberOfBytesWritten)
803 // Initialize the output value
804 numberOfBytesWritten = 0;
805 // Check that the given buffer is valid
806 if (buffer == nullptr || remainingBufferSize == 0)
808 return TimelinePacketStatus::BufferExhaustion;
812 unsigned int uint32_t_size = sizeof(uint32_t);
813 unsigned int uint64_t_size = sizeof(uint64_t);
814 unsigned int threadId_size = sizeof(std::thread::id);
816 // decl_id of the timeline message
819 // Calculate the length of the data (in bytes)
820 unsigned int timelineEventDataLength = uint32_t_size + // decl_id
821 uint64_t_size + // Timestamp
822 threadId_size + // Thread id
823 uint64_t_size; // Profiling GUID
825 // Check whether the timeline binary packet fits in the given buffer
826 if (timelineEventDataLength > remainingBufferSize)
828 return TimelinePacketStatus::BufferExhaustion;
831 // Initialize the offset for writing in the buffer
832 unsigned int offset = 0;
834 // Write the timeline binary payload to the buffer
835 WriteUint32(buffer, offset, declId); // decl_id
836 offset += uint32_t_size;
837 WriteUint64(buffer, offset, timestamp); // Timestamp
838 offset += uint64_t_size;
839 WriteBytes(buffer, offset, &threadId, threadId_size); // Thread id
840 offset += threadId_size;
841 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
842 offset += uint64_t_size;
843 // Update the number of bytes written
844 numberOfBytesWritten = timelineEventDataLength;
846 return TimelinePacketStatus::Ok;
849 std::string CentreAlignFormatting(const std::string& stringToPass, const int spacingWidth)
851 std::stringstream outputStream, centrePadding;
852 int padding = spacingWidth - static_cast<int>(stringToPass.size());
854 for (int i = 0; i < padding / 2; ++i)
856 centrePadding << " ";
859 outputStream << centrePadding.str() << stringToPass << centrePadding.str();
861 if (padding > 0 && padding %2 != 0)
866 return outputStream.str();
869 void PrintDeviceDetails(const std::pair<const unsigned short, std::unique_ptr<Device>>& devicePair)
873 body.append(CentreAlignFormatting(devicePair.second->m_Name, 20));
875 body.append(CentreAlignFormatting(std::to_string(devicePair.first), 13));
877 body.append(CentreAlignFormatting(std::to_string(devicePair.second->m_Cores), 10));
880 std::cout << std::string(body.size(), '-') << "\n";
884 void PrintCounterSetDetails(const std::pair<const unsigned short, std::unique_ptr<CounterSet>>& counterSetPair)
888 body.append(CentreAlignFormatting(counterSetPair.second->m_Name, 20));
890 body.append(CentreAlignFormatting(std::to_string(counterSetPair.first), 13));
892 body.append(CentreAlignFormatting(std::to_string(counterSetPair.second->m_Count), 10));
895 std::cout << std::string(body.size(), '-') << "\n";
900 void PrintCounterDetails(std::shared_ptr<Counter>& counter)
904 body.append(CentreAlignFormatting(counter->m_Name, 20));
906 body.append(CentreAlignFormatting(counter->m_Description, 50));
908 body.append(CentreAlignFormatting(counter->m_Units, 14));
910 body.append(CentreAlignFormatting(std::to_string(counter->m_Uid), 6));
912 body.append(CentreAlignFormatting(std::to_string(counter->m_MaxCounterUid), 10));
914 body.append(CentreAlignFormatting(std::to_string(counter->m_Class), 8));
916 body.append(CentreAlignFormatting(std::to_string(counter->m_Interpolation), 14));
918 body.append(CentreAlignFormatting(std::to_string(counter->m_Multiplier), 20));
920 body.append(CentreAlignFormatting(std::to_string(counter->m_CounterSetUid), 16));
922 body.append(CentreAlignFormatting(std::to_string(counter->m_DeviceUid), 14));
926 std::cout << std::string(body.size(), '-') << "\n";
931 void PrintCategoryDetails(const std::unique_ptr<Category>& category,
932 std::unordered_map<unsigned short, std::shared_ptr<Counter>> counterMap)
934 std::string categoryBody;
935 std::string categoryHeader;
937 categoryHeader.append(CentreAlignFormatting("Name", 20));
938 categoryHeader.append(" | ");
939 categoryHeader.append(CentreAlignFormatting("Event Count", 14));
940 categoryHeader.append("\n");
942 categoryBody.append(CentreAlignFormatting(category->m_Name, 20));
943 categoryBody.append(" | ");
944 categoryBody.append(CentreAlignFormatting(std::to_string(category->m_Counters.size()), 14));
946 std::cout << "\n" << "\n";
947 std::cout << CentreAlignFormatting("CATEGORY", static_cast<int>(categoryHeader.size()));
949 std::cout << std::string(categoryHeader.size(), '=') << "\n";
951 std::cout << categoryHeader;
953 std::cout << std::string(categoryBody.size(), '-') << "\n";
955 std::cout << categoryBody;
957 std::string counterHeader;
959 counterHeader.append(CentreAlignFormatting("Counter Name", 20));
960 counterHeader.append(" | ");
961 counterHeader.append(CentreAlignFormatting("Description", 50));
962 counterHeader.append(" | ");
963 counterHeader.append(CentreAlignFormatting("Units", 14));
964 counterHeader.append(" | ");
965 counterHeader.append(CentreAlignFormatting("UID", 6));
966 counterHeader.append(" | ");
967 counterHeader.append(CentreAlignFormatting("Max UID", 10));
968 counterHeader.append(" | ");
969 counterHeader.append(CentreAlignFormatting("Class", 8));
970 counterHeader.append(" | ");
971 counterHeader.append(CentreAlignFormatting("Interpolation", 14));
972 counterHeader.append(" | ");
973 counterHeader.append(CentreAlignFormatting("Multiplier", 20));
974 counterHeader.append(" | ");
975 counterHeader.append(CentreAlignFormatting("Counter set UID", 16));
976 counterHeader.append(" | ");
977 counterHeader.append(CentreAlignFormatting("Device UID", 14));
978 counterHeader.append("\n");
980 std::cout << "\n" << "\n";
981 std::cout << CentreAlignFormatting("EVENTS IN CATEGORY: " + category->m_Name,
982 static_cast<int>(counterHeader.size()));
984 std::cout << std::string(counterHeader.size(), '=') << "\n";
985 std::cout << counterHeader;
986 for (auto& it: category->m_Counters) {
987 auto search = counterMap.find(it);
988 if(search != counterMap.end()) {
989 PrintCounterDetails(search->second);
994 void PrintCounterDirectory(ICounterDirectory& counterDirectory)
996 std::string devicesHeader;
998 devicesHeader.append(CentreAlignFormatting("Device name", 20));
999 devicesHeader.append(" | ");
1000 devicesHeader.append(CentreAlignFormatting("UID", 13));
1001 devicesHeader.append(" | ");
1002 devicesHeader.append(CentreAlignFormatting("Cores", 10));
1003 devicesHeader.append("\n");
1005 std::cout << "\n" << "\n";
1006 std::cout << CentreAlignFormatting("DEVICES", static_cast<int>(devicesHeader.size()));
1008 std::cout << std::string(devicesHeader.size(), '=') << "\n";
1009 std::cout << devicesHeader;
1010 for (auto& it: counterDirectory.GetDevices()) {
1011 PrintDeviceDetails(it);
1014 std::string counterSetHeader;
1016 counterSetHeader.append(CentreAlignFormatting("Counter set name", 20));
1017 counterSetHeader.append(" | ");
1018 counterSetHeader.append(CentreAlignFormatting("UID", 13));
1019 counterSetHeader.append(" | ");
1020 counterSetHeader.append(CentreAlignFormatting("Count", 10));
1021 counterSetHeader.append("\n");
1023 std::cout << "\n" << "\n";
1024 std::cout << CentreAlignFormatting("COUNTER SETS", static_cast<int>(counterSetHeader.size()));
1026 std::cout << std::string(counterSetHeader.size(), '=') << "\n";
1028 std::cout << counterSetHeader;
1030 for (auto& it: counterDirectory.GetCounterSets()) {
1031 PrintCounterSetDetails(it);
1034 auto counters = counterDirectory.GetCounters();
1035 for (auto& it: counterDirectory.GetCategories()) {
1036 PrintCategoryDetails(it, counters);
1041 uint64_t GetTimestamp()
1043 #if USE_CLOCK_MONOTONIC_RAW
1044 using clock = MonotonicClockRaw;
1046 using clock = std::chrono::steady_clock;
1050 auto timestamp = std::chrono::duration_cast<std::chrono::nanoseconds>(clock::now().time_since_epoch());
1052 return static_cast<uint64_t>(timestamp.count());
1055 } // namespace profiling
1057 } // namespace armnn
1062 bool operator==(const std::vector<uint8_t>& left, std::thread::id right)
1064 return std::memcmp(left.data(), &right, left.size()) == 0;