src/profiling/ProfilingUtils.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include "ProfilingUtils.hpp"
   7
   8 #include "common/include/ProfilingException.hpp"
   9
  10 #include <armnn/Version.hpp>
  11
  12 #include <WallClockTimer.hpp>
  13
  14 #include <armnn/utility/Assert.hpp>
  15
  16 #include <fstream>
  17 #include <iostream>
  18 #include <limits>
  19
  20 namespace armnn
  21 {
  22
  23 namespace profiling
  24 {
  25
  26 namespace
  27 {
  28
  29 void ThrowIfCantGenerateNextUid(uint16_t uid, uint16_t cores = 0)
  30 {
  31     // Check that it is possible to generate the next UID without causing an overflow
  32     switch (cores)
  33     {
  34     case 0:
  35     case 1:
  36         // Number of cores not specified or set to 1 (a value of zero indicates the device is not capable of
  37         // running multiple parallel workloads and will not provide multiple streams of data for each event)
  38         if (uid == std::numeric_limits<uint16_t>::max())
  39         {
  40             throw RuntimeException("Generating the next UID for profiling would result in an overflow");
  41         }
  42         break;
  43     default: // cores > 1
  44         // Multiple cores available, as max_counter_uid has to be set to: counter_uid + cores - 1, the maximum
  45         // allowed value for a counter UID is consequently: uint16_t_max - cores + 1
  46         if (uid >= std::numeric_limits<uint16_t>::max() - cores + 1)
  47         {
  48             throw RuntimeException("Generating the next UID for profiling would result in an overflow");
  49         }
  50         break;
  51     }
  52 }
  53
  54 } // Anonymous namespace
  55
  56 uint16_t GetNextUid(bool peekOnly)
  57 {
  58     // The UID used for profiling objects and events. The first valid UID is 1, as 0 is a reserved value
  59     static uint16_t uid = 1;
  60
  61     // Check that it is possible to generate the next UID without causing an overflow (throws in case of error)
  62     ThrowIfCantGenerateNextUid(uid);
  63
  64     if (peekOnly)
  65     {
  66         // Peek only
  67         return uid;
  68     }
  69     else
  70     {
  71         // Get the next UID
  72         return uid++;
  73     }
  74 }
  75
  76 std::vector<uint16_t> GetNextCounterUids(uint16_t firstUid, uint16_t cores)
  77 {
  78     // Check that it is possible to generate the next counter UID without causing an overflow (throws in case of error)
  79     ThrowIfCantGenerateNextUid(firstUid, cores);
  80
  81     // Get the next counter UIDs
  82     size_t counterUidsSize = cores == 0 ? 1 : cores;
  83     std::vector<uint16_t> counterUids(counterUidsSize, 0);
  84     for (size_t i = 0; i < counterUidsSize; i++)
  85     {
  86         counterUids[i] = firstUid++;
  87     }
  88     return counterUids;
  89 }
  90
  91 void WriteBytes(const IPacketBufferPtr& packetBuffer, unsigned int offset,  const void* value, unsigned int valueSize)
  92 {
  93     ARMNN_ASSERT(packetBuffer);
  94
  95     WriteBytes(packetBuffer->GetWritableData(), offset, value, valueSize);
  96 }
  97
  98 uint32_t ConstructHeader(uint32_t packetFamily,
  99                          uint32_t packetId)
 100 {
 101     return (( packetFamily & 0x0000003F ) << 26 )|
 102            (( packetId & 0x000003FF )     << 16 );
 103 }
 104
 105 void WriteUint64(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint64_t value)
 106 {
 107     ARMNN_ASSERT(packetBuffer);
 108
 109     WriteUint64(packetBuffer->GetWritableData(), offset, value);
 110 }
 111
 112 void WriteUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint32_t value)
 113 {
 114     ARMNN_ASSERT(packetBuffer);
 115
 116     WriteUint32(packetBuffer->GetWritableData(), offset, value);
 117 }
 118
 119 void WriteUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint16_t value)
 120 {
 121     ARMNN_ASSERT(packetBuffer);
 122
 123     WriteUint16(packetBuffer->GetWritableData(), offset, value);
 124 }
 125
 126 void WriteUint8(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint8_t value)
 127 {
 128     ARMNN_ASSERT(packetBuffer);
 129
 130     WriteUint8(packetBuffer->GetWritableData(), offset, value);
 131 }
 132
 133 void WriteBytes(unsigned char* buffer, unsigned int offset, const void* value, unsigned int valueSize)
 134 {
 135     ARMNN_ASSERT(buffer);
 136     ARMNN_ASSERT(value);
 137
 138     for (unsigned int i = 0; i < valueSize; i++, offset++)
 139     {
 140         buffer[offset] = *(reinterpret_cast<const unsigned char*>(value) + i);
 141     }
 142 }
 143
 144 void WriteUint64(unsigned char* buffer, unsigned int offset, uint64_t value)
 145 {
 146     ARMNN_ASSERT(buffer);
 147
 148     buffer[offset]     = static_cast<unsigned char>(value & 0xFF);
 149     buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
 150     buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
 151     buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
 152     buffer[offset + 4] = static_cast<unsigned char>((value >> 32) & 0xFF);
 153     buffer[offset + 5] = static_cast<unsigned char>((value >> 40) & 0xFF);
 154     buffer[offset + 6] = static_cast<unsigned char>((value >> 48) & 0xFF);
 155     buffer[offset + 7] = static_cast<unsigned char>((value >> 56) & 0xFF);
 156 }
 157
 158 void WriteUint32(unsigned char* buffer, unsigned int offset, uint32_t value)
 159 {
 160     ARMNN_ASSERT(buffer);
 161
 162     buffer[offset]     = static_cast<unsigned char>(value & 0xFF);
 163     buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
 164     buffer[offset + 2] = static_cast<unsigned char>((value >> 16) & 0xFF);
 165     buffer[offset + 3] = static_cast<unsigned char>((value >> 24) & 0xFF);
 166 }
 167
 168 void WriteUint16(unsigned char* buffer, unsigned int offset, uint16_t value)
 169 {
 170     ARMNN_ASSERT(buffer);
 171
 172     buffer[offset]     = static_cast<unsigned char>(value & 0xFF);
 173     buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
 174 }
 175
 176 void WriteUint8(unsigned char* buffer, unsigned int offset, uint8_t value)
 177 {
 178     ARMNN_ASSERT(buffer);
 179
 180     buffer[offset] = static_cast<unsigned char>(value);
 181 }
 182
 183 void ReadBytes(const IPacketBufferPtr& packetBuffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
 184 {
 185     ARMNN_ASSERT(packetBuffer);
 186
 187     ReadBytes(packetBuffer->GetReadableData(), offset, valueSize, outValue);
 188 }
 189
 190 uint64_t ReadUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset)
 191 {
 192     ARMNN_ASSERT(packetBuffer);
 193
 194     return ReadUint64(packetBuffer->GetReadableData(), offset);
 195 }
 196
 197 uint32_t ReadUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset)
 198 {
 199     ARMNN_ASSERT(packetBuffer);
 200
 201     return ReadUint32(packetBuffer->GetReadableData(), offset);
 202 }
 203
 204 uint16_t ReadUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset)
 205 {
 206     ARMNN_ASSERT(packetBuffer);
 207
 208     return ReadUint16(packetBuffer->GetReadableData(), offset);
 209 }
 210
 211 uint8_t ReadUint8(const IPacketBufferPtr& packetBuffer, unsigned int offset)
 212 {
 213     ARMNN_ASSERT(packetBuffer);
 214
 215     return ReadUint8(packetBuffer->GetReadableData(), offset);
 216 }
 217
 218 void ReadBytes(const unsigned char* buffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
 219 {
 220     ARMNN_ASSERT(buffer);
 221     ARMNN_ASSERT(outValue);
 222
 223     for (unsigned int i = 0; i < valueSize; i++, offset++)
 224     {
 225         outValue[i] = static_cast<uint8_t>(buffer[offset]);
 226     }
 227 }
 228
 229 uint64_t ReadUint64(const unsigned char* buffer, unsigned int offset)
 230 {
 231     ARMNN_ASSERT(buffer);
 232
 233     uint64_t value = 0;
 234     value  = static_cast<uint64_t>(buffer[offset]);
 235     value |= static_cast<uint64_t>(buffer[offset + 1]) << 8;
 236     value |= static_cast<uint64_t>(buffer[offset + 2]) << 16;
 237     value |= static_cast<uint64_t>(buffer[offset + 3]) << 24;
 238     value |= static_cast<uint64_t>(buffer[offset + 4]) << 32;
 239     value |= static_cast<uint64_t>(buffer[offset + 5]) << 40;
 240     value |= static_cast<uint64_t>(buffer[offset + 6]) << 48;
 241     value |= static_cast<uint64_t>(buffer[offset + 7]) << 56;
 242
 243     return value;
 244 }
 245
 246 uint32_t ReadUint32(const unsigned char* buffer, unsigned int offset)
 247 {
 248     ARMNN_ASSERT(buffer);
 249
 250     uint32_t value = 0;
 251     value  = static_cast<uint32_t>(buffer[offset]);
 252     value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
 253     value |= static_cast<uint32_t>(buffer[offset + 2]) << 16;
 254     value |= static_cast<uint32_t>(buffer[offset + 3]) << 24;
 255     return value;
 256 }
 257
 258 uint16_t ReadUint16(const unsigned char* buffer, unsigned int offset)
 259 {
 260     ARMNN_ASSERT(buffer);
 261
 262     uint32_t value = 0;
 263     value  = static_cast<uint32_t>(buffer[offset]);
 264     value |= static_cast<uint32_t>(buffer[offset + 1]) << 8;
 265     return static_cast<uint16_t>(value);
 266 }
 267
 268 uint8_t ReadUint8(const unsigned char* buffer, unsigned int offset)
 269 {
 270     ARMNN_ASSERT(buffer);
 271
 272     return buffer[offset];
 273 }
 274
 275 std::string GetSoftwareInfo()
 276 {
 277     return std::string("ArmNN");
 278 }
 279
 280 std::string GetHardwareVersion()
 281 {
 282     return std::string();
 283 }
 284
 285 std::string GetSoftwareVersion()
 286 {
 287     std::string result = "Armnn " + std::to_string(ARMNN_MAJOR_VERSION) + "." + std::to_string(ARMNN_MINOR_VERSION);
 288     return result;
 289 }
 290
 291 std::string GetProcessName()
 292 {
 293     std::ifstream comm("/proc/self/comm");
 294     std::string name;
 295     getline(comm, name);
 296     return name;
 297 }
 298
 299 // Calculate the actual length an SwString will be including the terminating null character
 300 // padding to bring it to the next uint32_t boundary but minus the leading uint32_t encoding
 301 // the size to allow the offset to be correctly updated when decoding a binary packet.
 302 uint32_t CalculateSizeOfPaddedSwString(const std::string& str)
 303 {
 304     std::vector<uint32_t> swTraceString;
 305     StringToSwTraceString<SwTraceCharPolicy>(str, swTraceString);
 306     unsigned int uint32_t_size = sizeof(uint32_t);
 307     uint32_t size = (boost::numeric_cast<uint32_t>(swTraceString.size()) - 1) * uint32_t_size;
 308     return size;
 309 }
 310
 311 // Read TimelineMessageDirectoryPacket from given IPacketBuffer and offset
 312 SwTraceMessage ReadSwTraceMessage(const unsigned char* packetBuffer, unsigned int& offset)
 313 {
 314     ARMNN_ASSERT(packetBuffer);
 315
 316     unsigned int uint32_t_size = sizeof(uint32_t);
 317
 318     SwTraceMessage swTraceMessage;
 319
 320     // Read the decl_id
 321     uint32_t readDeclId = ReadUint32(packetBuffer, offset);
 322     swTraceMessage.m_Id = readDeclId;
 323
 324     // SWTrace "namestring" format
 325     // length of the string (first 4 bytes) + string + null terminator
 326
 327     // Check the decl_name
 328     offset += uint32_t_size;
 329     uint32_t swTraceDeclNameLength = ReadUint32(packetBuffer, offset);
 330
 331     offset += uint32_t_size;
 332     std::vector<unsigned char> swTraceStringBuffer(swTraceDeclNameLength - 1);
 333     std::memcpy(swTraceStringBuffer.data(),
 334                 packetBuffer + offset, swTraceStringBuffer.size());
 335
 336     swTraceMessage.m_Name.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // name
 337
 338     // Check the ui_name
 339     offset += CalculateSizeOfPaddedSwString(swTraceMessage.m_Name);
 340     uint32_t swTraceUINameLength = ReadUint32(packetBuffer, offset);
 341
 342     offset += uint32_t_size;
 343     swTraceStringBuffer.resize(swTraceUINameLength - 1);
 344     std::memcpy(swTraceStringBuffer.data(),
 345                 packetBuffer  + offset, swTraceStringBuffer.size());
 346
 347     swTraceMessage.m_UiName.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // ui_name
 348
 349     // Check arg_types
 350     offset += CalculateSizeOfPaddedSwString(swTraceMessage.m_UiName);
 351     uint32_t swTraceArgTypesLength = ReadUint32(packetBuffer, offset);
 352
 353     offset += uint32_t_size;
 354     swTraceStringBuffer.resize(swTraceArgTypesLength - 1);
 355     std::memcpy(swTraceStringBuffer.data(),
 356                 packetBuffer  + offset, swTraceStringBuffer.size());
 357
 358     swTraceMessage.m_ArgTypes.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end()); // arg_types
 359
 360     std::string swTraceString(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
 361
 362     // Check arg_names
 363     offset += CalculateSizeOfPaddedSwString(swTraceString);
 364     uint32_t swTraceArgNamesLength = ReadUint32(packetBuffer, offset);
 365
 366     offset += uint32_t_size;
 367     swTraceStringBuffer.resize(swTraceArgNamesLength - 1);
 368     std::memcpy(swTraceStringBuffer.data(),
 369                 packetBuffer  + offset, swTraceStringBuffer.size());
 370
 371     swTraceString.assign(swTraceStringBuffer.begin(), swTraceStringBuffer.end());
 372     std::stringstream stringStream(swTraceString);
 373     std::string argName;
 374     while (std::getline(stringStream, argName, ','))
 375     {
 376         swTraceMessage.m_ArgNames.push_back(argName);
 377     }
 378
 379     offset += CalculateSizeOfPaddedSwString(swTraceString);
 380
 381     return swTraceMessage;
 382 }
 383
 384 /// Creates a timeline packet header
 385 ///
 386 /// \params
 387 ///   packetFamiliy     Timeline Packet Family
 388 ///   packetClass       Timeline Packet Class
 389 ///   packetType        Timeline Packet Type
 390 ///   streamId          Stream identifier
 391 ///   seqeunceNumbered  When non-zero the 4 bytes following the header is a u32 sequence number
 392 ///   dataLength        Unsigned 24-bit integer. Length of data, in bytes. Zero is permitted
 393 ///
 394 /// \returns
 395 ///   Pair of uint32_t containing word0 and word1 of the header
 396 std::pair<uint32_t, uint32_t> CreateTimelinePacketHeader(uint32_t packetFamily,
 397                                                          uint32_t packetClass,
 398                                                          uint32_t packetType,
 399                                                          uint32_t streamId,
 400                                                          uint32_t sequenceNumbered,
 401                                                          uint32_t dataLength)
 402 {
 403     // Packet header word 0:
 404     // 26:31 [6] packet_family: timeline Packet Family, value 0b000001
 405     // 19:25 [7] packet_class: packet class
 406     // 16:18 [3] packet_type: packet type
 407     // 8:15  [8] reserved: all zeros
 408     // 0:7   [8] stream_id: stream identifier
 409     uint32_t packetHeaderWord0 = ((packetFamily & 0x0000003F) << 26) |
 410                                  ((packetClass  & 0x0000007F) << 19) |
 411                                  ((packetType   & 0x00000007) << 16) |
 412                                  ((streamId     & 0x00000007) <<  0);
 413
 414     // Packet header word 1:
 415     // 25:31 [7]  reserved: all zeros
 416     // 24    [1]  sequence_numbered: when non-zero the 4 bytes following the header is a u32 sequence number
 417     // 0:23  [24] data_length: unsigned 24-bit integer. Length of data, in bytes. Zero is permitted
 418     uint32_t packetHeaderWord1 = ((sequenceNumbered & 0x00000001) << 24) |
 419                                  ((dataLength       & 0x00FFFFFF) <<  0);
 420
 421     return std::make_pair(packetHeaderWord0, packetHeaderWord1);
 422 }
 423
 424 /// Creates a packet header for the timeline messages:
 425 /// * declareLabel
 426 /// * declareEntity
 427 /// * declareEventClass
 428 /// * declareRelationship
 429 /// * declareEvent
 430 ///
 431 /// \param
 432 ///   dataLength The length of the message body in bytes
 433 ///
 434 /// \returns
 435 ///   Pair of uint32_t containing word0 and word1 of the header
 436 std::pair<uint32_t, uint32_t> CreateTimelineMessagePacketHeader(unsigned int dataLength)
 437 {
 438     return CreateTimelinePacketHeader(1,           // Packet family
 439                                       0,           // Packet class
 440                                       1,           // Packet type
 441                                       0,           // Stream id
 442                                       0,           // Sequence number
 443                                       dataLength); // Data length
 444 }
 445
 446 TimelinePacketStatus WriteTimelineLabelBinaryPacket(uint64_t profilingGuid,
 447                                                     const std::string& label,
 448                                                     unsigned char* buffer,
 449                                                     unsigned int remainingBufferSize,
 450                                                     unsigned int& numberOfBytesWritten)
 451 {
 452     // Initialize the output value
 453     numberOfBytesWritten = 0;
 454
 455     // Check that the given buffer is valid
 456     if (buffer == nullptr || remainingBufferSize == 0)
 457     {
 458         return TimelinePacketStatus::BufferExhaustion;
 459     }
 460
 461     // Utils
 462     unsigned int uint32_t_size = sizeof(uint32_t);
 463     unsigned int uint64_t_size = sizeof(uint64_t);
 464
 465     // Convert the label into a SWTrace string
 466     std::vector<uint32_t> swTraceLabel;
 467     bool result = StringToSwTraceString<SwTraceCharPolicy>(label, swTraceLabel);
 468     if (!result)
 469     {
 470         return TimelinePacketStatus::Error;
 471     }
 472
 473     // Calculate the size of the SWTrace string label (in bytes)
 474     unsigned int swTraceLabelSize = boost::numeric_cast<unsigned int>(swTraceLabel.size()) * uint32_t_size;
 475
 476     // Calculate the length of the data (in bytes)
 477     unsigned int timelineLabelPacketDataLength = uint32_t_size +   // decl_Id
 478                                                  uint64_t_size +   // Profiling GUID
 479                                                  swTraceLabelSize; // Label
 480
 481     // Check whether the timeline binary packet fits in the given buffer
 482     if (timelineLabelPacketDataLength > remainingBufferSize)
 483     {
 484         return TimelinePacketStatus::BufferExhaustion;
 485     }
 486
 487     // Initialize the offset for writing in the buffer
 488     unsigned int offset = 0;
 489
 490     // Write decl_Id to the buffer
 491     WriteUint32(buffer, offset, 0u);
 492     offset += uint32_t_size;
 493
 494     // Write the timeline binary packet payload to the buffer
 495     WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
 496     offset += uint64_t_size;
 497     for (uint32_t swTraceLabelWord : swTraceLabel)
 498     {
 499         WriteUint32(buffer, offset, swTraceLabelWord); // Label
 500         offset += uint32_t_size;
 501     }
 502
 503     // Update the number of bytes written
 504     numberOfBytesWritten = timelineLabelPacketDataLength;
 505
 506     return TimelinePacketStatus::Ok;
 507 }
 508
 509 TimelinePacketStatus WriteTimelineEntityBinary(uint64_t profilingGuid,
 510                                                unsigned char* buffer,
 511                                                unsigned int remainingBufferSize,
 512                                                unsigned int& numberOfBytesWritten)
 513 {
 514     // Initialize the output value
 515     numberOfBytesWritten = 0;
 516
 517     // Check that the given buffer is valid
 518     if (buffer == nullptr || remainingBufferSize == 0)
 519     {
 520         return TimelinePacketStatus::BufferExhaustion;
 521     }
 522
 523     // Utils
 524     unsigned int uint32_t_size = sizeof(uint32_t);
 525     unsigned int uint64_t_size = sizeof(uint64_t);
 526
 527     // Calculate the length of the data (in bytes)
 528     unsigned int timelineEntityDataLength = uint32_t_size + uint64_t_size;  // decl_id + Profiling GUID
 529
 530     // Check whether the timeline binary packet fits in the given buffer
 531     if (timelineEntityDataLength > remainingBufferSize)
 532     {
 533         return TimelinePacketStatus::BufferExhaustion;
 534     }
 535
 536     // Initialize the offset for writing in the buffer
 537     unsigned int offset = 0;
 538
 539     // Write the decl_Id to the buffer
 540     WriteUint32(buffer, offset, 1u);
 541     offset += uint32_t_size;
 542
 543     // Write the timeline binary packet payload to the buffer
 544     WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
 545
 546     // Update the number of bytes written
 547     numberOfBytesWritten = timelineEntityDataLength;
 548
 549     return TimelinePacketStatus::Ok;
 550 }
 551
 552 TimelinePacketStatus WriteTimelineRelationshipBinary(ProfilingRelationshipType relationshipType,
 553                                                      uint64_t relationshipGuid,
 554                                                      uint64_t headGuid,
 555                                                      uint64_t tailGuid,
 556                                                      uint64_t attributeGuid,
 557                                                      unsigned char* buffer,
 558                                                      unsigned int remainingBufferSize,
 559                                                      unsigned int& numberOfBytesWritten)
 560 {
 561     // Initialize the output value
 562     numberOfBytesWritten = 0;
 563
 564     // Check that the given buffer is valid
 565     if (buffer == nullptr || remainingBufferSize == 0)
 566     {
 567         return TimelinePacketStatus::BufferExhaustion;
 568     }
 569
 570     // Utils
 571     unsigned int uint32_t_size = sizeof(uint32_t);
 572     unsigned int uint64_t_size = sizeof(uint64_t);
 573
 574     // Calculate the length of the data (in bytes)
 575     unsigned int timelineRelationshipDataLength = uint32_t_size * 2 + // decl_id + Relationship Type
 576                                                   uint64_t_size * 4;  // Relationship GUID + Head GUID +
 577                                                                       // tail GUID + attributeGuid
 578
 579     // Check whether the timeline binary fits in the given buffer
 580     if (timelineRelationshipDataLength > remainingBufferSize)
 581     {
 582         return TimelinePacketStatus::BufferExhaustion;
 583     }
 584
 585     // Initialize the offset for writing in the buffer
 586     unsigned int offset = 0;
 587
 588     uint32_t relationshipTypeUint = 0;
 589
 590     switch (relationshipType)
 591     {
 592         case ProfilingRelationshipType::RetentionLink:
 593             relationshipTypeUint = 0;
 594             break;
 595         case ProfilingRelationshipType::ExecutionLink:
 596             relationshipTypeUint = 1;
 597             break;
 598         case ProfilingRelationshipType::DataLink:
 599             relationshipTypeUint = 2;
 600             break;
 601         case ProfilingRelationshipType::LabelLink:
 602             relationshipTypeUint = 3;
 603             break;
 604         default:
 605             throw InvalidArgumentException("Unknown relationship type given.");
 606     }
 607
 608     // Write the timeline binary payload to the buffer
 609     // decl_id of the timeline message
 610     uint32_t declId = 3;
 611     WriteUint32(buffer, offset, declId); // decl_id
 612     offset += uint32_t_size;
 613     WriteUint32(buffer, offset, relationshipTypeUint); // Relationship Type
 614     offset += uint32_t_size;
 615     WriteUint64(buffer, offset, relationshipGuid); // GUID of this relationship
 616     offset += uint64_t_size;
 617     WriteUint64(buffer, offset, headGuid); // head of relationship GUID
 618     offset += uint64_t_size;
 619     WriteUint64(buffer, offset, tailGuid); // tail of relationship GUID
 620     offset += uint64_t_size;
 621     WriteUint64(buffer, offset, attributeGuid); // attribute of relationship GUID
 622
 623
 624     // Update the number of bytes written
 625     numberOfBytesWritten = timelineRelationshipDataLength;
 626
 627     return TimelinePacketStatus::Ok;
 628 }
 629
 630 TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char* buffer,
 631                                                           unsigned int remainingBufferSize,
 632                                                           unsigned int& numberOfBytesWritten)
 633 {
 634     // Initialize the output value
 635     numberOfBytesWritten = 0;
 636
 637     // Check that the given buffer is valid
 638     if (buffer == nullptr || remainingBufferSize == 0)
 639     {
 640         return TimelinePacketStatus::BufferExhaustion;
 641     }
 642
 643     // Utils
 644     unsigned int uint8_t_size  = sizeof(uint8_t);
 645     unsigned int uint32_t_size = sizeof(uint32_t);
 646     unsigned int uint64_t_size = sizeof(uint64_t);
 647
 648     // The payload/data of the packet consists of swtrace event definitions encoded according
 649     // to the swtrace directory specification. The messages being the five defined below:
 650     //
 651     // |  decl_id  |     decl_name       |      ui_name          |  arg_types  |            arg_names                |
 652     // |-----------|---------------------|-----------------------|-------------|-------------------------------------|
 653     // |    0      |   declareLabel      |   declare label       |    ps       |  guid,value                         |
 654     // |    1      |   declareEntity     |   declare entity      |    p        |  guid                               |
 655     // |    2      | declareEventClass   |  declare event class  |    p        |  guid                               |
 656     // |    3      | declareRelationship | declare relationship  |    Ippp     |  relationshipType,relationshipGuid, |
 657     // |           |                     |                       |             |  headGuid,tailGuid                  |
 658     // |    4      |   declareEvent      |   declare event       |    @tp      |  timestamp,threadId,eventGuid       |
 659     std::vector<std::vector<std::string>> timelineDirectoryMessages
 660     {
 661         { "0", "declareLabel", "declare label", "ps", "guid,value" },
 662         { "1", "declareEntity", "declare entity", "p", "guid" },
 663         { "2", "declareEventClass", "declare event class", "p", "guid" },
 664         { "3", "declareRelationship", "declare relationship", "Ippp",
 665           "relationshipType,relationshipGuid,headGuid,tailGuid" },
 666         { "4", "declareEvent", "declare event", "@tp", "timestamp,threadId,eventGuid" }
 667     };
 668
 669     // Build the message declarations
 670     std::vector<uint32_t> swTraceBuffer;
 671     for (const auto& directoryComponent : timelineDirectoryMessages)
 672     {
 673         // decl_id
 674         uint32_t declId = 0;
 675         try
 676         {
 677             declId = boost::numeric_cast<uint32_t>(std::stoul(directoryComponent[0]));
 678         }
 679         catch (const std::exception&)
 680         {
 681             return TimelinePacketStatus::Error;
 682         }
 683         swTraceBuffer.push_back(declId);
 684
 685         bool result = true;
 686         result &= ConvertDirectoryComponent<SwTraceNameCharPolicy>(directoryComponent[1], swTraceBuffer); // decl_name
 687         result &= ConvertDirectoryComponent<SwTraceCharPolicy>    (directoryComponent[2], swTraceBuffer); // ui_name
 688         result &= ConvertDirectoryComponent<SwTraceTypeCharPolicy>(directoryComponent[3], swTraceBuffer); // arg_types
 689         result &= ConvertDirectoryComponent<SwTraceCharPolicy>    (directoryComponent[4], swTraceBuffer); // arg_names
 690         if (!result)
 691         {
 692             return TimelinePacketStatus::Error;
 693         }
 694     }
 695
 696     unsigned int dataLength = 3 * uint8_t_size +  // Stream header (3 bytes)
 697                               boost::numeric_cast<unsigned int>(swTraceBuffer.size()) *
 698                                   uint32_t_size; // Trace directory (5 messages)
 699
 700     // Calculate the timeline directory binary packet size (in bytes)
 701     unsigned int timelineDirectoryPacketSize = 2 * uint32_t_size + // Header (2 words)
 702                                                dataLength;         // Payload
 703
 704     // Check whether the timeline directory binary packet fits in the given buffer
 705     if (timelineDirectoryPacketSize > remainingBufferSize)
 706     {
 707         return TimelinePacketStatus::BufferExhaustion;
 708     }
 709
 710     // Create packet header
 711     auto packetHeader = CreateTimelinePacketHeader(1, 0, 0, 0, 0, boost::numeric_cast<uint32_t>(dataLength));
 712
 713     // Initialize the offset for writing in the buffer
 714     unsigned int offset = 0;
 715
 716     // Write the timeline binary packet header to the buffer
 717     WriteUint32(buffer, offset, packetHeader.first);
 718     offset += uint32_t_size;
 719     WriteUint32(buffer, offset, packetHeader.second);
 720     offset += uint32_t_size;
 721
 722     // Write the stream header
 723     uint8_t streamVersion = 4;
 724     uint8_t pointerBytes  = boost::numeric_cast<uint8_t>(uint64_t_size); // All GUIDs are uint64_t
 725     uint8_t threadIdBytes = boost::numeric_cast<uint8_t>(ThreadIdSize);
 726     switch (threadIdBytes)
 727     {
 728     case 4: // Typically Windows and Android
 729     case 8: // Typically Linux
 730         break; // Valid values
 731     default:
 732         return TimelinePacketStatus::Error; // Invalid value
 733     }
 734     WriteUint8(buffer, offset, streamVersion);
 735     offset += uint8_t_size;
 736     WriteUint8(buffer, offset, pointerBytes);
 737     offset += uint8_t_size;
 738     WriteUint8(buffer, offset, threadIdBytes);
 739     offset += uint8_t_size;
 740
 741     // Write the SWTrace directory
 742     uint32_t numberOfDeclarations = boost::numeric_cast<uint32_t>(timelineDirectoryMessages.size());
 743     WriteUint32(buffer, offset, numberOfDeclarations); // Number of declarations
 744     offset += uint32_t_size;
 745     for (uint32_t i : swTraceBuffer)
 746     {
 747         WriteUint32(buffer, offset, i); // Message declarations
 748         offset += uint32_t_size;
 749     }
 750
 751     // Update the number of bytes written
 752     numberOfBytesWritten = timelineDirectoryPacketSize;
 753
 754     return TimelinePacketStatus::Ok;
 755 }
 756
 757 TimelinePacketStatus WriteTimelineEventClassBinary(uint64_t profilingGuid,
 758                                                    uint64_t nameGuid,
 759                                                    unsigned char* buffer,
 760                                                    unsigned int remainingBufferSize,
 761                                                    unsigned int& numberOfBytesWritten)
 762 {
 763     // Initialize the output value
 764     numberOfBytesWritten = 0;
 765
 766     // Check that the given buffer is valid
 767     if (buffer == nullptr || remainingBufferSize == 0)
 768     {
 769         return TimelinePacketStatus::BufferExhaustion;
 770     }
 771
 772     // Utils
 773     unsigned int uint32_t_size = sizeof(uint32_t);
 774     unsigned int uint64_t_size = sizeof(uint64_t);
 775
 776     // decl_id of the timeline message
 777     uint32_t declId = 2;
 778
 779     // Calculate the length of the data (in bytes)
 780     unsigned int dataSize = uint32_t_size + (uint64_t_size * 2); // decl_id + Profiling GUID + Name GUID
 781
 782     // Check whether the timeline binary fits in the given buffer
 783     if (dataSize > remainingBufferSize)
 784     {
 785         return TimelinePacketStatus::BufferExhaustion;
 786     }
 787
 788     // Initialize the offset for writing in the buffer
 789     unsigned int offset = 0;
 790
 791     // Write the timeline binary payload to the buffer
 792     WriteUint32(buffer, offset, declId);        // decl_id
 793     offset += uint32_t_size;
 794     WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
 795     offset += uint64_t_size;
 796     WriteUint64(buffer, offset, nameGuid); // Name GUID
 797
 798     // Update the number of bytes written
 799     numberOfBytesWritten = dataSize;
 800
 801     return TimelinePacketStatus::Ok;
 802 }
 803
 804 TimelinePacketStatus WriteTimelineEventBinary(uint64_t timestamp,
 805                                               std::thread::id threadId,
 806                                               uint64_t profilingGuid,
 807                                               unsigned char* buffer,
 808                                               unsigned int remainingBufferSize,
 809                                               unsigned int& numberOfBytesWritten)
 810 {
 811     // Initialize the output value
 812     numberOfBytesWritten = 0;
 813     // Check that the given buffer is valid
 814     if (buffer == nullptr || remainingBufferSize == 0)
 815     {
 816         return TimelinePacketStatus::BufferExhaustion;
 817     }
 818
 819     // Utils
 820     unsigned int uint32_t_size = sizeof(uint32_t);
 821     unsigned int uint64_t_size = sizeof(uint64_t);
 822
 823     // decl_id of the timeline message
 824     uint32_t declId = 4;
 825
 826     // Calculate the length of the data (in bytes)
 827     unsigned int timelineEventDataLength = uint32_t_size + // decl_id
 828                                            uint64_t_size + // Timestamp
 829                                            ThreadIdSize +  // Thread id
 830                                            uint64_t_size;  // Profiling GUID
 831
 832     // Check whether the timeline binary packet fits in the given buffer
 833     if (timelineEventDataLength > remainingBufferSize)
 834     {
 835         return TimelinePacketStatus::BufferExhaustion;
 836     }
 837
 838     // Initialize the offset for writing in the buffer
 839     unsigned int offset = 0;
 840
 841     // Write the timeline binary payload to the buffer
 842     WriteUint32(buffer, offset, declId); // decl_id
 843     offset += uint32_t_size;
 844     WriteUint64(buffer, offset, timestamp); // Timestamp
 845     offset += uint64_t_size;
 846     WriteBytes(buffer, offset, &threadId, ThreadIdSize); // Thread id
 847     offset += ThreadIdSize;
 848     WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
 849     offset += uint64_t_size;
 850     // Update the number of bytes written
 851     numberOfBytesWritten = timelineEventDataLength;
 852
 853     return TimelinePacketStatus::Ok;
 854 }
 855
 856 std::string CentreAlignFormatting(const std::string& stringToPass, const int spacingWidth)
 857 {
 858     std::stringstream outputStream, centrePadding;
 859     int padding = spacingWidth - static_cast<int>(stringToPass.size());
 860
 861     for (int i = 0; i < padding / 2; ++i)
 862     {
 863         centrePadding << " ";
 864     }
 865
 866     outputStream << centrePadding.str() << stringToPass << centrePadding.str();
 867
 868     if (padding > 0 && padding %2 != 0)
 869     {
 870         outputStream << " ";
 871     }
 872
 873     return outputStream.str();
 874 }
 875
 876 void PrintDeviceDetails(const std::pair<const unsigned short, std::unique_ptr<Device>>& devicePair)
 877 {
 878     std::string body;
 879
 880     body.append(CentreAlignFormatting(devicePair.second->m_Name, 20));
 881     body.append(" | ");
 882     body.append(CentreAlignFormatting(std::to_string(devicePair.first), 13));
 883     body.append(" | ");
 884     body.append(CentreAlignFormatting(std::to_string(devicePair.second->m_Cores), 10));
 885     body.append("\n");
 886
 887     std::cout << std::string(body.size(), '-') << "\n";
 888     std::cout<< body;
 889 }
 890
 891 void PrintCounterSetDetails(const std::pair<const unsigned short, std::unique_ptr<CounterSet>>& counterSetPair)
 892 {
 893     std::string body;
 894
 895     body.append(CentreAlignFormatting(counterSetPair.second->m_Name, 20));
 896     body.append(" | ");
 897     body.append(CentreAlignFormatting(std::to_string(counterSetPair.first), 13));
 898     body.append(" | ");
 899     body.append(CentreAlignFormatting(std::to_string(counterSetPair.second->m_Count), 10));
 900     body.append("\n");
 901
 902     std::cout << std::string(body.size(), '-') << "\n";
 903
 904     std::cout<< body;
 905 }
 906
 907 void PrintCounterDetails(std::shared_ptr<Counter>& counter)
 908 {
 909     std::string body;
 910
 911     body.append(CentreAlignFormatting(counter->m_Name, 20));
 912     body.append(" | ");
 913     body.append(CentreAlignFormatting(counter->m_Description, 50));
 914     body.append(" | ");
 915     body.append(CentreAlignFormatting(counter->m_Units, 14));
 916     body.append(" | ");
 917     body.append(CentreAlignFormatting(std::to_string(counter->m_Uid), 6));
 918     body.append(" | ");
 919     body.append(CentreAlignFormatting(std::to_string(counter->m_MaxCounterUid), 10));
 920     body.append(" | ");
 921     body.append(CentreAlignFormatting(std::to_string(counter->m_Class), 8));
 922     body.append(" | ");
 923     body.append(CentreAlignFormatting(std::to_string(counter->m_Interpolation), 14));
 924     body.append(" | ");
 925     body.append(CentreAlignFormatting(std::to_string(counter->m_Multiplier), 20));
 926     body.append(" | ");
 927     body.append(CentreAlignFormatting(std::to_string(counter->m_CounterSetUid), 16));
 928     body.append(" | ");
 929     body.append(CentreAlignFormatting(std::to_string(counter->m_DeviceUid), 14));
 930
 931     body.append("\n");
 932
 933     std::cout << std::string(body.size(), '-') << "\n";
 934
 935     std::cout << body;
 936 }
 937
 938 void PrintCategoryDetails(const std::unique_ptr<Category>& category,
 939                           std::unordered_map<unsigned short, std::shared_ptr<Counter>> counterMap)
 940 {
 941     std::string categoryBody;
 942     std::string categoryHeader;
 943
 944     categoryHeader.append(CentreAlignFormatting("Name", 20));
 945     categoryHeader.append(" | ");
 946     categoryHeader.append(CentreAlignFormatting("Event Count", 14));
 947     categoryHeader.append("\n");
 948
 949     categoryBody.append(CentreAlignFormatting(category->m_Name, 20));
 950     categoryBody.append(" | ");
 951     categoryBody.append(CentreAlignFormatting(std::to_string(category->m_Counters.size()), 14));
 952
 953     std::cout << "\n" << "\n";
 954     std::cout << CentreAlignFormatting("CATEGORY", static_cast<int>(categoryHeader.size()));
 955     std::cout << "\n";
 956     std::cout << std::string(categoryHeader.size(), '=') << "\n";
 957
 958     std::cout << categoryHeader;
 959
 960     std::cout << std::string(categoryBody.size(), '-') << "\n";
 961
 962     std::cout << categoryBody;
 963
 964     std::string counterHeader;
 965
 966     counterHeader.append(CentreAlignFormatting("Counter Name", 20));
 967     counterHeader.append(" | ");
 968     counterHeader.append(CentreAlignFormatting("Description", 50));
 969     counterHeader.append(" | ");
 970     counterHeader.append(CentreAlignFormatting("Units", 14));
 971     counterHeader.append(" | ");
 972     counterHeader.append(CentreAlignFormatting("UID", 6));
 973     counterHeader.append(" | ");
 974     counterHeader.append(CentreAlignFormatting("Max UID", 10));
 975     counterHeader.append(" | ");
 976     counterHeader.append(CentreAlignFormatting("Class", 8));
 977     counterHeader.append(" | ");
 978     counterHeader.append(CentreAlignFormatting("Interpolation", 14));
 979     counterHeader.append(" | ");
 980     counterHeader.append(CentreAlignFormatting("Multiplier", 20));
 981     counterHeader.append(" | ");
 982     counterHeader.append(CentreAlignFormatting("Counter set UID", 16));
 983     counterHeader.append(" | ");
 984     counterHeader.append(CentreAlignFormatting("Device UID", 14));
 985     counterHeader.append("\n");
 986
 987     std::cout << "\n" << "\n";
 988     std::cout << CentreAlignFormatting("EVENTS IN CATEGORY: " + category->m_Name,
 989                                        static_cast<int>(counterHeader.size()));
 990     std::cout << "\n";
 991     std::cout << std::string(counterHeader.size(), '=') << "\n";
 992     std::cout << counterHeader;
 993     for (auto& it: category->m_Counters) {
 994         auto search = counterMap.find(it);
 995         if(search != counterMap.end()) {
 996             PrintCounterDetails(search->second);
 997         }
 998     }
 999 }
1000
1001 void PrintCounterDirectory(ICounterDirectory& counterDirectory)
1002 {
1003     std::string devicesHeader;
1004
1005     devicesHeader.append(CentreAlignFormatting("Device name", 20));
1006     devicesHeader.append(" | ");
1007     devicesHeader.append(CentreAlignFormatting("UID", 13));
1008     devicesHeader.append(" | ");
1009     devicesHeader.append(CentreAlignFormatting("Cores", 10));
1010     devicesHeader.append("\n");
1011
1012     std::cout << "\n" << "\n";
1013     std::cout << CentreAlignFormatting("DEVICES", static_cast<int>(devicesHeader.size()));
1014     std::cout << "\n";
1015     std::cout << std::string(devicesHeader.size(), '=') << "\n";
1016     std::cout << devicesHeader;
1017     for (auto& it: counterDirectory.GetDevices()) {
1018         PrintDeviceDetails(it);
1019     }
1020
1021     std::string counterSetHeader;
1022
1023     counterSetHeader.append(CentreAlignFormatting("Counter set name", 20));
1024     counterSetHeader.append(" | ");
1025     counterSetHeader.append(CentreAlignFormatting("UID", 13));
1026     counterSetHeader.append(" | ");
1027     counterSetHeader.append(CentreAlignFormatting("Count", 10));
1028     counterSetHeader.append("\n");
1029
1030     std::cout << "\n" << "\n";
1031     std::cout << CentreAlignFormatting("COUNTER SETS", static_cast<int>(counterSetHeader.size()));
1032     std::cout << "\n";
1033     std::cout << std::string(counterSetHeader.size(), '=') << "\n";
1034
1035     std::cout << counterSetHeader;
1036
1037     for (auto& it: counterDirectory.GetCounterSets()) {
1038         PrintCounterSetDetails(it);
1039     }
1040
1041     auto counters = counterDirectory.GetCounters();
1042     for (auto& it: counterDirectory.GetCategories()) {
1043         PrintCategoryDetails(it, counters);
1044     }
1045     std::cout << "\n";
1046 }
1047
1048 uint64_t GetTimestamp()
1049 {
1050 #if USE_CLOCK_MONOTONIC_RAW
1051     using clock = MonotonicClockRaw;
1052 #else
1053     using clock = std::chrono::steady_clock;
1054 #endif
1055
1056     // Take a timestamp
1057     auto timestamp = std::chrono::duration_cast<std::chrono::nanoseconds>(clock::now().time_since_epoch());
1058
1059     return static_cast<uint64_t>(timestamp.count());
1060 }
1061
1062 Packet ReceivePacket(const unsigned char* buffer, uint32_t length)
1063 {
1064     if (buffer == nullptr)
1065     {
1066         throw armnnProfiling::ProfilingException("data buffer is nullptr");
1067     }
1068     if (length < 8)
1069     {
1070         throw armnnProfiling::ProfilingException("length of data buffer is less than 8");
1071     }
1072
1073     uint32_t metadataIdentifier = 0;
1074     std::memcpy(&metadataIdentifier, buffer, sizeof(metadataIdentifier));
1075
1076     uint32_t dataLength = 0;
1077     std::memcpy(&dataLength, buffer + 4u, sizeof(dataLength));
1078
1079     std::unique_ptr<unsigned char[]> packetData;
1080     if (dataLength > 0)
1081     {
1082         packetData = std::make_unique<unsigned char[]>(dataLength);
1083         std::memcpy(packetData.get(), buffer + 8u, dataLength);
1084     }
1085
1086     return Packet(metadataIdentifier, dataLength, packetData);
1087 }
1088
1089 } // namespace profiling
1090
1091 } // namespace armnn
1092
1093 namespace std
1094 {
1095
1096 bool operator==(const std::vector<uint8_t>& left, std::thread::id right)
1097 {
1098     return std::memcmp(left.data(), &right, left.size()) == 0;
1099 }
1100
1101 } // namespace std