2 // Copyright © 2017 Arm Ltd. All rights reserved.
3 // SPDX-License-Identifier: MIT
6 #include "ProfilingUtils.hpp"
8 #include <armnn/Version.hpp>
9 #include <armnn/Conversion.hpp>
11 #include <boost/assert.hpp>
25 void ThrowIfCantGenerateNextUid(uint16_t uid, uint16_t cores = 0)
27 // Check that it is possible to generate the next UID without causing an overflow
32 // Number of cores not specified or set to 1 (a value of zero indicates the device is not capable of
33 // running multiple parallel workloads and will not provide multiple streams of data for each event)
34 if (uid == std::numeric_limits<uint16_t>::max())
36 throw RuntimeException("Generating the next UID for profiling would result in an overflow");
40 // Multiple cores available, as max_counter_uid has to be set to: counter_uid + cores - 1, the maximum
41 // allowed value for a counter UID is consequently: uint16_t_max - cores + 1
42 if (uid >= std::numeric_limits<uint16_t>::max() - cores + 1)
44 throw RuntimeException("Generating the next UID for profiling would result in an overflow");
50 } // Anonymous namespace
52 uint16_t GetNextUid(bool peekOnly)
54 // The UID used for profiling objects and events. The first valid UID is 1, as 0 is a reserved value
55 static uint16_t uid = 1;
57 // Check that it is possible to generate the next UID without causing an overflow (throws in case of error)
58 ThrowIfCantGenerateNextUid(uid);
72 std::vector<uint16_t> GetNextCounterUids(uint16_t cores)
74 // The UID used for counters only. The first valid UID is 0
75 static uint16_t counterUid = 0;
77 // Check that it is possible to generate the next counter UID without causing an overflow (throws in case of error)
78 ThrowIfCantGenerateNextUid(counterUid, cores);
80 // Get the next counter UIDs
81 size_t counterUidsSize = cores == 0 ? 1 : cores;
82 std::vector<uint16_t> counterUids(counterUidsSize, 0);
83 for (size_t i = 0; i < counterUidsSize; i++)
85 counterUids[i] = counterUid++;
90 void WriteUint64(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint64_t value)
92 BOOST_ASSERT(packetBuffer);
94 WriteUint64(packetBuffer->GetWritableData(), offset, value);
97 void WriteUint32(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint32_t value)
99 BOOST_ASSERT(packetBuffer);
101 WriteUint32(packetBuffer->GetWritableData(), offset, value);
104 void WriteUint16(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint16_t value)
106 BOOST_ASSERT(packetBuffer);
108 WriteUint16(packetBuffer->GetWritableData(), offset, value);
111 void WriteUint64(unsigned char* buffer, unsigned int offset, uint64_t value)
113 BOOST_ASSERT(buffer);
115 buffer[offset] = static_cast<unsigned char>(value & 0xFF);
116 buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
117 buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
118 buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
119 buffer[offset + 4] = static_cast<unsigned char>((value >> 32) & 0xFF);
120 buffer[offset + 5] = static_cast<unsigned char>((value >> 40) & 0xFF);
121 buffer[offset + 6] = static_cast<unsigned char>((value >> 48) & 0xFF);
122 buffer[offset + 7] = static_cast<unsigned char>((value >> 56) & 0xFF);
125 void WriteUint32(unsigned char* buffer, unsigned int offset, uint32_t value)
127 BOOST_ASSERT(buffer);
129 buffer[offset] = static_cast<unsigned char>(value & 0xFF);
130 buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
131 buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
132 buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
135 void WriteUint16(unsigned char* buffer, unsigned int offset, uint16_t value)
137 BOOST_ASSERT(buffer);
139 buffer[offset] = static_cast<unsigned char>(value & 0xFF);
140 buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
143 uint64_t ReadUint64(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset)
145 BOOST_ASSERT(packetBuffer);
147 return ReadUint64(packetBuffer->GetReadableData(), offset);
150 uint32_t ReadUint32(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset)
152 BOOST_ASSERT(packetBuffer);
154 return ReadUint32(packetBuffer->GetReadableData(), offset);
157 uint16_t ReadUint16(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset)
159 BOOST_ASSERT(packetBuffer);
161 return ReadUint16(packetBuffer->GetReadableData(), offset);
164 uint8_t ReadUint8(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset)
166 BOOST_ASSERT(packetBuffer);
168 return ReadUint8(packetBuffer->GetReadableData(), offset);
171 uint64_t ReadUint64(const unsigned char* buffer, unsigned int offset)
173 BOOST_ASSERT(buffer);
176 value = static_cast<uint64_t>(buffer[offset]);
177 value |= static_cast<uint64_t>(buffer[offset + 1]) << 8;
178 value |= static_cast<uint64_t>(buffer[offset + 2]) << 16;
179 value |= static_cast<uint64_t>(buffer[offset + 3]) << 24;
180 value |= static_cast<uint64_t>(buffer[offset + 4]) << 32;
181 value |= static_cast<uint64_t>(buffer[offset + 5]) << 40;
182 value |= static_cast<uint64_t>(buffer[offset + 6]) << 48;
183 value |= static_cast<uint64_t>(buffer[offset + 7]) << 56;
188 uint32_t ReadUint32(const unsigned char* buffer, unsigned int offset)
190 BOOST_ASSERT(buffer);
193 value = static_cast<uint32_t>(buffer[offset]);
194 value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
195 value |= static_cast<uint32_t>(buffer[offset + 2]) << 16;
196 value |= static_cast<uint32_t>(buffer[offset + 3]) << 24;
200 uint16_t ReadUint16(const unsigned char* buffer, unsigned int offset)
202 BOOST_ASSERT(buffer);
205 value = static_cast<uint32_t>(buffer[offset]);
206 value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
207 return static_cast<uint16_t>(value);
210 uint8_t ReadUint8(const unsigned char* buffer, unsigned int offset)
212 BOOST_ASSERT(buffer);
214 return buffer[offset];
217 std::string GetSoftwareInfo()
219 return std::string("ArmNN");
222 std::string GetHardwareVersion()
224 return std::string();
227 std::string GetSoftwareVersion()
229 std::string armnnVersion(ARMNN_VERSION);
230 std::string result = "Armnn " + armnnVersion.substr(2,2) + "." + armnnVersion.substr(4,2);
234 std::string GetProcessName()
236 std::ifstream comm("/proc/self/comm");
242 /// Creates a timeline packet header
245 /// packetFamiliy Timeline Packet Family
246 /// packetClass Timeline Packet Class
247 /// packetType Timeline Packet Type
248 /// streamId Stream identifier
249 /// seqeunceNumbered When non-zero the 4 bytes following the header is a u32 sequence number
250 /// dataLength Unsigned 24-bit integer. Length of data, in bytes. Zero is permitted
253 /// Pair of uint32_t containing word0 and word1 of the header
254 std::pair<uint32_t, uint32_t> CreateTimelinePacketHeader(uint32_t packetFamily,
255 uint32_t packetClass,
258 uint32_t sequenceNumbered,
261 // Packet header word 0:
262 // 26:31 [6] packet_family: timeline Packet Family, value 0b000001
263 // 19:25 [7] packet_class: packet class
264 // 16:18 [3] packet_type: packet type
265 // 8:15 [8] reserved: all zeros
266 // 0:7 [8] stream_id: stream identifier
267 uint32_t packetHeaderWord0 = ((packetFamily & 0x0000003F) << 26) |
268 ((packetClass & 0x0000007F) << 19) |
269 ((packetType & 0x00000007) << 16) |
270 ((streamId & 0x00000007) << 0);
272 // Packet header word 1:
273 // 25:31 [7] reserved: all zeros
274 // 24 [1] sequence_numbered: when non-zero the 4 bytes following the header is a u32 sequence number
275 // 0:23 [24] data_length: unsigned 24-bit integer. Length of data, in bytes. Zero is permitted
276 uint32_t packetHeaderWord1 = ((sequenceNumbered & 0x00000001) << 24) |
277 ((dataLength & 0x00FFFFFF) << 0);
279 return std::make_pair(packetHeaderWord0, packetHeaderWord1);
282 // Calculate the actual length an SwString will be including the terminating null character
283 // padding to bring it to the next uint32_t boundary but minus the leading uint32_t encoding
284 // the size to allow the offset to be correctly updated when decoding a binary packet.
285 uint32_t CalculateSizeOfPaddedSwString(const std::string& str)
287 std::vector<uint32_t> swTraceString;
288 StringToSwTraceString<SwTraceCharPolicy>(str, swTraceString);
289 unsigned int uint32_t_size = sizeof(uint32_t);
290 uint32_t size = (boost::numeric_cast<uint32_t>(swTraceString.size()) - 1) * uint32_t_size;
294 // Read TimelineMessageDirectoryPacket from given IPacketBuffer and offset
295 SwTraceMessage ReadSwTraceMessage(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int& offset)
297 BOOST_ASSERT(packetBuffer);
299 unsigned int uint32_t_size = sizeof(uint32_t);
301 SwTraceMessage swTraceMessage;
304 uint32_t readDeclId = ReadUint32(packetBuffer, offset);
305 swTraceMessage.id = readDeclId;
307 // SWTrace "namestring" format
308 // length of the string (first 4 bytes) + string + null terminator
310 // Check the decl_name
311 offset += uint32_t_size;
312 uint32_t swTraceDeclNameLength = ReadUint32(packetBuffer, offset);
314 offset += uint32_t_size;
315 std::vector<unsigned char> swTraceStringBuffer(swTraceDeclNameLength - 1);
316 std::memcpy(swTraceStringBuffer.data(),
317 packetBuffer->GetReadableData() + offset, swTraceStringBuffer.size());
319 swTraceMessage.name.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // name
322 offset += CalculateSizeOfPaddedSwString(swTraceMessage.name);
323 uint32_t swTraceUINameLength = ReadUint32(packetBuffer, offset);
325 offset += uint32_t_size;
326 swTraceStringBuffer.resize(swTraceUINameLength - 1);
327 std::memcpy(swTraceStringBuffer.data(),
328 packetBuffer->GetReadableData() + offset, swTraceStringBuffer.size());
330 swTraceMessage.uiName.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // ui_name
333 offset += CalculateSizeOfPaddedSwString(swTraceMessage.uiName);
334 uint32_t swTraceArgTypesLength = ReadUint32(packetBuffer, offset);
336 offset += uint32_t_size;
337 swTraceStringBuffer.resize(swTraceArgTypesLength - 1);
338 std::memcpy(swTraceStringBuffer.data(),
339 packetBuffer->GetReadableData() + offset, swTraceStringBuffer.size());
341 swTraceMessage.argTypes.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // arg_types
343 std::string swTraceString(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
346 offset += CalculateSizeOfPaddedSwString(swTraceString);
347 uint32_t swTraceArgNamesLength = ReadUint32(packetBuffer, offset);
349 offset += uint32_t_size;
350 swTraceStringBuffer.resize(swTraceArgNamesLength - 1);
351 std::memcpy(swTraceStringBuffer.data(),
352 packetBuffer->GetReadableData() + offset, swTraceStringBuffer.size());
354 swTraceString.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
355 std::stringstream stringStream(swTraceString);
357 while (std::getline(stringStream, argName, ','))
359 swTraceMessage.argNames.push_back(argName);
362 offset += CalculateSizeOfPaddedSwString(swTraceString);
364 return swTraceMessage;
367 /// Creates a packet header for the timeline messages:
370 /// * declareEventClass
371 /// * declareRelationship
375 /// dataLength The length of the message body in bytes
378 /// Pair of uint32_t containing word0 and word1 of the header
379 std::pair<uint32_t, uint32_t> CreateTimelineMessagePacketHeader(unsigned int dataLength)
381 return CreateTimelinePacketHeader(1, // Packet family
385 0, // Sequence number
386 dataLength); // Data length
389 TimelinePacketStatus WriteTimelineLabelBinaryPacket(uint64_t profilingGuid,
390 const std::string& label,
391 unsigned char* buffer,
392 unsigned int bufferSize,
393 unsigned int& numberOfBytesWritten)
395 // Initialize the output value
396 numberOfBytesWritten = 0;
398 // Check that the given buffer is valid
399 if (buffer == nullptr || bufferSize == 0)
401 return TimelinePacketStatus::BufferExhaustion;
405 unsigned int uint32_t_size = sizeof(uint32_t);
406 unsigned int uint64_t_size = sizeof(uint64_t);
408 // Convert the label into a SWTrace string
409 std::vector<uint32_t> swTraceLabel;
410 bool result = StringToSwTraceString<SwTraceCharPolicy>(label, swTraceLabel);
413 return TimelinePacketStatus::Error;
416 // Calculate the size of the SWTrace string label (in bytes)
417 unsigned int swTraceLabelSize = boost::numeric_cast<unsigned int>(swTraceLabel.size()) * uint32_t_size;
419 // Calculate the length of the data (in bytes)
420 unsigned int timelineLabelPacketDataLength = uint32_t_size + // decl_Id
421 uint64_t_size + // Profiling GUID
422 swTraceLabelSize; // Label
424 // Calculate the timeline binary packet size (in bytes)
425 unsigned int timelineLabelPacketSize = 2 * uint32_t_size + // Header (2 words)
426 timelineLabelPacketDataLength; // decl_Id + Profiling GUID + label
428 // Check whether the timeline binary packet fits in the given buffer
429 if (timelineLabelPacketSize > bufferSize)
431 return TimelinePacketStatus::BufferExhaustion;
434 // Create packet header
435 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(timelineLabelPacketDataLength);
437 // Initialize the offset for writing in the buffer
438 unsigned int offset = 0;
440 // Write the timeline binary packet header to the buffer
441 WriteUint32(buffer, offset, packetHeader.first);
442 offset += uint32_t_size;
443 WriteUint32(buffer, offset, packetHeader.second);
444 offset += uint32_t_size;
446 // Write decl_Id to the buffer
447 WriteUint32(buffer, offset, 0u);
448 offset += uint32_t_size;
450 // Write the timeline binary packet payload to the buffer
451 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
452 offset += uint64_t_size;
453 for (uint32_t swTraceLabelWord : swTraceLabel)
455 WriteUint32(buffer, offset, swTraceLabelWord); // Label
456 offset += uint32_t_size;
459 // Update the number of bytes written
460 numberOfBytesWritten = timelineLabelPacketSize;
462 return TimelinePacketStatus::Ok;
465 TimelinePacketStatus WriteTimelineEntityBinaryPacket(uint64_t profilingGuid,
466 unsigned char* buffer,
467 unsigned int bufferSize,
468 unsigned int& numberOfBytesWritten)
470 // Initialize the output value
471 numberOfBytesWritten = 0;
473 // Check that the given buffer is valid
474 if (buffer == nullptr || bufferSize == 0)
476 return TimelinePacketStatus::BufferExhaustion;
480 unsigned int uint32_t_size = sizeof(uint32_t);
481 unsigned int uint64_t_size = sizeof(uint64_t);
483 // Calculate the length of the data (in bytes)
484 unsigned int timelineEntityPacketDataLength = uint64_t_size; // Profiling GUID
487 // Calculate the timeline binary packet size (in bytes)
488 unsigned int timelineEntityPacketSize = 2 * uint32_t_size + // Header (2 words)
489 uint32_t_size + // decl_Id
490 timelineEntityPacketDataLength; // Profiling GUID
492 // Check whether the timeline binary packet fits in the given buffer
493 if (timelineEntityPacketSize > bufferSize)
495 return TimelinePacketStatus::BufferExhaustion;
498 // Create packet header
499 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(timelineEntityPacketDataLength);
501 // Initialize the offset for writing in the buffer
502 unsigned int offset = 0;
504 // Write the timeline binary packet header to the buffer
505 WriteUint32(buffer, offset, packetHeader.first);
506 offset += uint32_t_size;
507 WriteUint32(buffer, offset, packetHeader.second);
508 offset += uint32_t_size;
510 // Write the decl_Id to the buffer
511 WriteUint32(buffer, offset, 1u);
512 offset += uint32_t_size;
514 // Write the timeline binary packet payload to the buffer
515 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
517 // Update the number of bytes written
518 numberOfBytesWritten = timelineEntityPacketSize;
520 return TimelinePacketStatus::Ok;
523 TimelinePacketStatus WriteTimelineRelationshipBinaryPacket(ProfilingRelationshipType relationshipType,
524 uint64_t relationshipGuid,
527 unsigned char* buffer,
528 unsigned int bufferSize,
529 unsigned int& numberOfBytesWritten)
531 // Initialize the output value
532 numberOfBytesWritten = 0;
534 // Check that the given buffer is valid
535 if (buffer == nullptr || bufferSize == 0)
537 return TimelinePacketStatus::BufferExhaustion;
541 unsigned int uint32_t_size = sizeof(uint32_t);
542 unsigned int uint64_t_size = sizeof(uint64_t);
544 // Calculate the length of the data (in bytes)
545 unsigned int timelineRelationshipPacketDataLength = uint32_t_size * 2 + // decl_id + Relationship Type
546 uint64_t_size * 3; // Relationship GUID + Head GUID + tail GUID
548 // Calculate the timeline binary packet size (in bytes)
549 unsigned int timelineRelationshipPacketSize = 2 * uint32_t_size + // Header (2 words)
550 timelineRelationshipPacketDataLength;
552 // Check whether the timeline binary packet fits in the given buffer
553 if (timelineRelationshipPacketSize > bufferSize)
555 return TimelinePacketStatus::BufferExhaustion;
558 // Create packet header
559 uint32_t dataLength = boost::numeric_cast<uint32_t>(timelineRelationshipPacketDataLength);
560 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(dataLength);
562 // Initialize the offset for writing in the buffer
563 unsigned int offset = 0;
565 // Write the timeline binary packet header to the buffer
566 WriteUint32(buffer, offset, packetHeader.first);
567 offset += uint32_t_size;
568 WriteUint32(buffer, offset, packetHeader.second);
569 offset += uint32_t_size;
571 uint32_t relationshipTypeUint = 0;
573 switch (relationshipType)
575 case ProfilingRelationshipType::RetentionLink:
576 relationshipTypeUint = 0;
578 case ProfilingRelationshipType::ExecutionLink:
579 relationshipTypeUint = 1;
581 case ProfilingRelationshipType::DataLink:
582 relationshipTypeUint = 2;
584 case ProfilingRelationshipType::LabelLink:
585 relationshipTypeUint = 3;
588 throw InvalidArgumentException("Unknown relationship type given.");
591 // Write the timeline binary packet payload to the buffer
592 // decl_id of the timeline message
594 WriteUint32(buffer, offset, declId); // decl_id
595 offset += uint32_t_size;
596 WriteUint32(buffer, offset, relationshipTypeUint); // Relationship Type
597 offset += uint32_t_size;
598 WriteUint64(buffer, offset, relationshipGuid); // GUID of this relationship
599 offset += uint64_t_size;
600 WriteUint64(buffer, offset, headGuid); // head of relationship GUID
601 offset += uint64_t_size;
602 WriteUint64(buffer, offset, tailGuid); // tail of relationship GUID
604 // Update the number of bytes written
605 numberOfBytesWritten = timelineRelationshipPacketSize;
607 return TimelinePacketStatus::Ok;
610 TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char* buffer,
611 unsigned int bufferSize,
612 unsigned int& numberOfBytesWritten)
614 // Initialize the output value
615 numberOfBytesWritten = 0;
617 // Check that the given buffer is valid
618 if (buffer == nullptr || bufferSize == 0)
620 return TimelinePacketStatus::BufferExhaustion;
624 unsigned int uint32_t_size = sizeof(uint32_t);
626 // The payload/data of the packet consists of swtrace event definitions encoded according
627 // to the swtrace directory specification. The messages being the five defined below:
628 // | decl_id | decl_name | ui_name | arg_types | arg_names |
629 // |-----------|---------------------|-----------------------|-------------|-------------------------------------|
630 // | 0 | declareLabel | declare label | ps | guid,value |
631 // | 1 | declareEntity | declare entity | p | guid |
632 // | 2 | declareEventClass | declare event class | p | guid |
633 // | 3 | declareRelationship | declare relationship | Ippp | relationshipType,relationshipGuid, |
634 // | | | | | headGuid,tailGuid |
635 // | 4 | declareEvent | declare event | @tp | timestamp,threadId,eventGuid |
637 std::vector<std::vector<std::string>> timelineDirectoryMessages
639 {"declareLabel", "declare label", "ps", "guid,value"},
640 {"declareEntity", "declare entity", "p", "guid"},
641 {"declareEventClass", "declare event class", "p", "guid"},
642 {"declareRelationship", "declare relationship", "Ippp", "relationshipType,relationshipGuid,headGuid,tailGuid"},
643 {"declareEvent", "declare event", "@tp", "timestamp,threadId,eventGuid"}
646 unsigned int messagesDataLength = 0u;
647 std::vector<std::vector<std::vector<uint32_t>>> swTraceTimelineDirectoryMessages;
649 for (const auto& timelineDirectoryMessage : timelineDirectoryMessages)
651 messagesDataLength += uint32_t_size; // decl_id
653 std::vector<std::vector<uint32_t>> swTraceStringsVector;
654 for (const auto& label : timelineDirectoryMessage)
656 std::vector<uint32_t> swTraceString;
657 bool result = StringToSwTraceString<SwTraceCharPolicy>(label, swTraceString);
660 return TimelinePacketStatus::Error;
663 messagesDataLength += boost::numeric_cast<unsigned int>(swTraceString.size()) * uint32_t_size;
664 swTraceStringsVector.push_back(swTraceString);
666 swTraceTimelineDirectoryMessages.push_back(swTraceStringsVector);
669 // Calculate the timeline directory binary packet size (in bytes)
670 unsigned int timelineDirectoryPacketSize = 2 * uint32_t_size + // Header (2 words)
671 messagesDataLength; // 5 messages length
673 // Check whether the timeline directory binary packet fits in the given buffer
674 if (timelineDirectoryPacketSize > bufferSize)
676 return TimelinePacketStatus::BufferExhaustion;
679 // Create packet header
680 uint32_t dataLength = boost::numeric_cast<uint32_t>(messagesDataLength);
681 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelinePacketHeader(1, 0, 0, 0, 0, dataLength);
683 // Initialize the offset for writing in the buffer
684 unsigned int offset = 0;
686 // Write the timeline binary packet header to the buffer
687 WriteUint32(buffer, offset, packetHeader.first);
688 offset += uint32_t_size;
689 WriteUint32(buffer, offset, packetHeader.second);
690 offset += uint32_t_size;
692 for (unsigned int i = 0u; i < swTraceTimelineDirectoryMessages.size(); ++i)
694 // Write the timeline binary packet payload to the buffer
695 WriteUint32(buffer, offset, i); // decl_id
696 offset += uint32_t_size;
698 for (std::vector<uint32_t> swTraceString : swTraceTimelineDirectoryMessages[i])
700 for (uint32_t swTraceDeclStringWord : swTraceString)
702 WriteUint32(buffer, offset, swTraceDeclStringWord);
703 offset += uint32_t_size;
708 // Update the number of bytes written
709 numberOfBytesWritten = timelineDirectoryPacketSize;
711 return TimelinePacketStatus::Ok;
714 TimelinePacketStatus WriteTimelineEventClassBinaryPacket(uint64_t profilingGuid,
715 unsigned char* buffer,
716 unsigned int bufferSize,
717 unsigned int& numberOfBytesWritten)
719 // Initialize the output value
720 numberOfBytesWritten = 0;
722 // Check that the given buffer is valid
723 if (buffer == nullptr || bufferSize == 0)
725 return TimelinePacketStatus::BufferExhaustion;
729 unsigned int uint32_t_size = sizeof(uint32_t);
730 unsigned int uint64_t_size = sizeof(uint64_t);
732 // decl_id of the timeline message
735 // Calculate the length of the data (in bytes)
736 unsigned int packetBodySize = uint32_t_size + uint64_t_size; // decl_id + Profiling GUID
738 // Calculate the timeline binary packet size (in bytes)
739 unsigned int packetSize = 2 * uint32_t_size + // Header (2 words)
740 packetBodySize; // Body
742 // Check whether the timeline binary packet fits in the given buffer
743 if (packetSize > bufferSize)
745 return TimelinePacketStatus::BufferExhaustion;
748 // Create packet header
749 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(packetBodySize);
751 // Initialize the offset for writing in the buffer
752 unsigned int offset = 0;
754 // Write the timeline binary packet header to the buffer
755 WriteUint32(buffer, offset, packetHeader.first);
756 offset += uint32_t_size;
757 WriteUint32(buffer, offset, packetHeader.second);
758 offset += uint32_t_size;
760 // Write the timeline binary packet payload to the buffer
761 WriteUint32(buffer, offset, declId); // decl_id
762 offset += uint32_t_size;
763 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
765 // Update the number of bytes written
766 numberOfBytesWritten = packetSize;
768 return TimelinePacketStatus::Ok;
771 TimelinePacketStatus WriteTimelineEventBinaryPacket(uint64_t timestamp,
773 uint64_t profilingGuid,
774 unsigned char* buffer,
775 unsigned int bufferSize,
776 unsigned int& numberOfBytesWritten)
778 // Initialize the output value
779 numberOfBytesWritten = 0;
781 // Check that the given buffer is valid
782 if (buffer == nullptr || bufferSize == 0)
784 return TimelinePacketStatus::BufferExhaustion;
788 unsigned int uint32_t_size = sizeof(uint32_t);
789 unsigned int uint64_t_size = sizeof(uint64_t);
791 // decl_id of the timeline message
794 // Calculate the length of the data (in bytes)
795 unsigned int timelineEventPacketDataLength = uint32_t_size + // decl_id
796 uint64_t_size + // Timestamp
797 uint32_t_size + // Thread id
798 uint64_t_size; // Profiling GUID
800 // Calculate the timeline binary packet size (in bytes)
801 unsigned int timelineEventPacketSize = 2 * uint32_t_size + // Header (2 words)
802 timelineEventPacketDataLength; // Timestamp + thread id + profiling GUID
804 // Check whether the timeline binary packet fits in the given buffer
805 if (timelineEventPacketSize > bufferSize)
807 return TimelinePacketStatus::BufferExhaustion;
810 // Create packet header
811 std::pair<uint32_t, uint32_t> packetHeader = CreateTimelineMessagePacketHeader(timelineEventPacketDataLength);
813 // Initialize the offset for writing in the buffer
814 unsigned int offset = 0;
816 // Write the timeline binary packet header to the buffer
817 WriteUint32(buffer, offset, packetHeader.first);
818 offset += uint32_t_size;
819 WriteUint32(buffer, offset, packetHeader.second);
820 offset += uint32_t_size;
822 // Write the timeline binary packet payload to the buffer
823 WriteUint32(buffer, offset, declId); // decl_id
824 offset += uint32_t_size;
825 WriteUint64(buffer, offset, timestamp); // Timestamp
826 offset += uint64_t_size;
827 WriteUint32(buffer, offset, threadId); // Thread id
828 offset += uint32_t_size;
829 WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
830 offset += uint64_t_size;
832 // Update the number of bytes written
833 numberOfBytesWritten = timelineEventPacketSize;
835 return TimelinePacketStatus::Ok;
838 } // namespace profiling