src/profiling/SendCounterPacket.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include "SendCounterPacket.hpp"
   7 #include <common/include/EncodeVersion.hpp>
   8
   9 #include <armnn/Exceptions.hpp>
  10 #include <armnn/Conversion.hpp>
  11 #include <Processes.hpp>
  12 #include <armnn/utility/Assert.hpp>
  13 #include <armnn/utility/NumericCast.hpp>
  14 #include <common/include/Constants.hpp>
  15 #include <common/include/SwTrace.hpp>
  16
  17 #include <boost/format.hpp>
  18
  19 #include <cstring>
  20
  21 namespace armnn
  22 {
  23
  24 namespace profiling
  25 {
  26
  27 void SendCounterPacket::SendStreamMetaDataPacket()
  28 {
  29     const std::string info(GetSoftwareInfo());
  30     const std::string hardwareVersion(GetHardwareVersion());
  31     const std::string softwareVersion(GetSoftwareVersion());
  32     const std::string processName = GetProcessName().substr(0, 60);
  33
  34     const uint32_t infoSize =            armnn::numeric_cast<uint32_t>(info.size()) + 1;
  35     const uint32_t hardwareVersionSize = armnn::numeric_cast<uint32_t>(hardwareVersion.size()) + 1;
  36     const uint32_t softwareVersionSize = armnn::numeric_cast<uint32_t>(softwareVersion.size()) + 1;
  37     const uint32_t processNameSize =     armnn::numeric_cast<uint32_t>(processName.size()) + 1;
  38
  39     const uint32_t sizeUint32 = sizeof(uint32_t);
  40
  41     const uint32_t headerSize = 2 * sizeUint32;
  42     const uint32_t bodySize = 10 * sizeUint32;
  43     const uint32_t packetVersionCountSize = sizeUint32;
  44
  45     // Supported Packets
  46     // Packet Encoding version 1.0.0
  47     // Control packet family
  48     //   Stream metadata packet (packet family=0; packet id=0)
  49     //   Connection Acknowledged packet ( packet family=0, packet id=1) Version 1.0.0
  50     //   Counter Directory packet (packet family=0; packet id=2) Version 1.0.0
  51     //   Request Counter Directory packet ( packet family=0, packet id=3) Version 1.0.0
  52     //   Periodic Counter Selection packet ( packet family=0, packet id=4) Version 1.0.0
  53     //   Per Job Counter Selection packet ( packet family=0, packet id=5) Version 1.0.0
  54     //   Activate Timeline Reporting (packet family = 0, packet id = 6) Version 1.0.0
  55     //   Deactivate Timeline Reporting (packet family = 0, packet id = 7) Version 1.0.0
  56     // Counter Packet Family
  57     //   Periodic Counter Capture (packet_family = 3, packet_class = 0, packet_type = 0) Version 1.0.0
  58     //   Per-Job Counter Capture (packet_family = 3, packet_class = 1, packet_type = 0,1) Version  1.0.0
  59     // Timeline Packet Family
  60     //   Timeline Message Directory (packet_family = 1, packet_class = 0, packet_type = 0) Version 1.0.0
  61     //   Timeline Message (packet_family = 1, packet_class = 0, packet_type = 1) Version 1.0.0
  62     std::vector<std::pair<uint32_t, uint32_t>> packetVersions;
  63     packetVersions.push_back(std::make_pair(ConstructHeader(0, 0), arm::pipe::EncodeVersion(1, 0, 0)));
  64     packetVersions.push_back(std::make_pair(ConstructHeader(0, 1), arm::pipe::EncodeVersion(1, 0, 0)));
  65     packetVersions.push_back(std::make_pair(ConstructHeader(0, 2), arm::pipe::EncodeVersion(1, 0, 0)));
  66     packetVersions.push_back(std::make_pair(ConstructHeader(0, 3), arm::pipe::EncodeVersion(1, 0, 0)));
  67     packetVersions.push_back(std::make_pair(ConstructHeader(0, 4), arm::pipe::EncodeVersion(1, 0, 0)));
  68     packetVersions.push_back(std::make_pair(ConstructHeader(0, 5), arm::pipe::EncodeVersion(1, 0, 0)));
  69     packetVersions.push_back(std::make_pair(ConstructHeader(0, 6), arm::pipe::EncodeVersion(1, 0, 0)));
  70     packetVersions.push_back(std::make_pair(ConstructHeader(0, 7), arm::pipe::EncodeVersion(1, 0, 0)));
  71     packetVersions.push_back(std::make_pair(ConstructHeader(3, 0, 0), arm::pipe::EncodeVersion(1, 0, 0)));
  72     packetVersions.push_back(std::make_pair(ConstructHeader(3, 1, 0), arm::pipe::EncodeVersion(1, 0, 0)));
  73     packetVersions.push_back(std::make_pair(ConstructHeader(3, 1, 1), arm::pipe::EncodeVersion(1, 0, 0)));
  74     packetVersions.push_back(std::make_pair(ConstructHeader(1, 0, 0), arm::pipe::EncodeVersion(1, 0, 0)));
  75     packetVersions.push_back(std::make_pair(ConstructHeader(1, 0, 1), arm::pipe::EncodeVersion(1, 0, 0)));
  76     uint32_t numberOfVersions = armnn::numeric_cast<uint32_t>(packetVersions.size());
  77     uint32_t packetVersionSize = armnn::numeric_cast<uint32_t>(numberOfVersions * 2 * sizeUint32);
  78
  79     const uint32_t payloadSize = armnn::numeric_cast<uint32_t>(infoSize + hardwareVersionSize +
  80                                                                softwareVersionSize + processNameSize +
  81                                                                packetVersionCountSize + packetVersionSize);
  82
  83     const uint32_t totalSize = headerSize + bodySize + payloadSize;
  84     uint32_t offset = 0;
  85     uint32_t reserved = 0;
  86
  87     IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
  88
  89     if (writeBuffer == nullptr || reserved < totalSize)
  90     {
  91         CancelOperationAndThrow<BufferExhaustion>(
  92             writeBuffer,
  93             boost::str(boost::format("No space left in buffer. Unable to reserve (%1%) bytes.") % totalSize));
  94     }
  95
  96     try
  97     {
  98         // Create header
  99
 100         WriteUint32(writeBuffer, offset, 0);
 101         offset += sizeUint32;
 102         WriteUint32(writeBuffer, offset, totalSize - headerSize);
 103
 104         // Packet body
 105
 106         offset += sizeUint32;
 107         WriteUint32(writeBuffer, offset, arm::pipe::PIPE_MAGIC); // pipe_magic
 108         offset += sizeUint32;
 109         WriteUint32(writeBuffer, offset, arm::pipe::EncodeVersion(1, 0, 0)); // stream_metadata_version
 110         offset += sizeUint32;
 111         WriteUint32(writeBuffer, offset, MAX_METADATA_PACKET_LENGTH); // max_data_length
 112         offset += sizeUint32;
 113         int pid = armnnUtils::Processes::GetCurrentId();
 114         WriteUint32(writeBuffer, offset, armnn::numeric_cast<uint32_t>(pid)); // pid
 115         offset += sizeUint32;
 116         uint32_t poolOffset = bodySize;
 117         WriteUint32(writeBuffer, offset, poolOffset); // offset_info
 118         offset += sizeUint32;
 119         poolOffset += infoSize;
 120         WriteUint32(writeBuffer, offset, poolOffset); // offset_hw_version
 121         offset += sizeUint32;
 122         poolOffset += hardwareVersionSize;
 123         WriteUint32(writeBuffer, offset, poolOffset); // offset_sw_version
 124         offset += sizeUint32;
 125         poolOffset += softwareVersionSize;
 126         WriteUint32(writeBuffer, offset, poolOffset); // offset_process_name
 127         offset += sizeUint32;
 128         poolOffset += processNameSize;
 129         WriteUint32(writeBuffer, offset, poolOffset); // offset_packet_version_table
 130         offset += sizeUint32;
 131         WriteUint32(writeBuffer, offset, 0); // reserved
 132         offset += sizeUint32;
 133
 134         // Pool
 135
 136         if (infoSize)
 137         {
 138             memcpy(&writeBuffer->GetWritableData()[offset], info.c_str(), infoSize);
 139             offset += infoSize;
 140         }
 141
 142         memcpy(&writeBuffer->GetWritableData()[offset], hardwareVersion.c_str(), hardwareVersionSize);
 143         offset += hardwareVersionSize;
 144         memcpy(&writeBuffer->GetWritableData()[offset], softwareVersion.c_str(), softwareVersionSize);
 145         offset += softwareVersionSize;
 146         memcpy(&writeBuffer->GetWritableData()[offset], processName.c_str(), processNameSize);
 147         offset += processNameSize;
 148
 149         if (!packetVersions.empty())
 150         {
 151             // Packet Version Count
 152             WriteUint32(writeBuffer, offset, numberOfVersions << 16);
 153             offset += sizeUint32;
 154
 155             // Packet Version Entries
 156             for (std::pair<uint32_t, uint32_t>& packetVersion : packetVersions)
 157             {
 158                 WriteUint32(writeBuffer, offset, packetVersion.first);
 159                 offset += sizeUint32;
 160                 WriteUint32(writeBuffer, offset, packetVersion.second);
 161                 offset += sizeUint32;
 162             }
 163         }
 164     }
 165     catch(...)
 166     {
 167         CancelOperationAndThrow<RuntimeException>(writeBuffer, "Error processing packet.");
 168     }
 169
 170     m_BufferManager.Commit(writeBuffer, totalSize, false);
 171 }
 172
 173 bool SendCounterPacket::CreateCategoryRecord(const CategoryPtr& category,
 174                                              const Counters& counters,
 175                                              CategoryRecord& categoryRecord,
 176                                              std::string& errorMessage)
 177 {
 178     ARMNN_ASSERT(category);
 179
 180     const std::string& categoryName = category->m_Name;
 181     ARMNN_ASSERT(!categoryName.empty());
 182
 183     // Remove any duplicate counters
 184     std::vector<uint16_t> categoryCounters;
 185     for (size_t counterIndex = 0; counterIndex < category->m_Counters.size(); ++counterIndex)
 186     {
 187         uint16_t counterUid = category->m_Counters.at(counterIndex);
 188         auto it = counters.find(counterUid);
 189         if (it == counters.end())
 190         {
 191             errorMessage = boost::str(boost::format("Counter (%1%) not found in category (%2%)")
 192                                       % counterUid % category->m_Name );
 193             return false;
 194         }
 195
 196         const CounterPtr& counter = it->second;
 197
 198         if (counterUid == counter->m_MaxCounterUid)
 199         {
 200             categoryCounters.emplace_back(counterUid);
 201         }
 202     }
 203     if (categoryCounters.empty())
 204     {
 205         errorMessage = boost::str(boost::format("No valid counters found in category (%1%)")% categoryName);
 206         return false;
 207     }
 208
 209     // Utils
 210     const size_t uint32_t_size = sizeof(uint32_t);
 211
 212     // Convert the device name into a SWTrace namestring
 213     std::vector<uint32_t> categoryNameBuffer;
 214     if (!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(categoryName, categoryNameBuffer))
 215     {
 216         errorMessage = boost::str(boost::format("Cannot convert the name of category (%1%) to an SWTrace namestring")
 217                                   % categoryName);
 218         return false;
 219     }
 220
 221     // Category record word 1:
 222     // 16:31 [16] event_count: number of events belonging to this category
 223     // 0:15  [16] reserved: all zeros
 224     const uint32_t categoryRecordWord1 = static_cast<uint32_t>(categoryCounters.size()) << 16;
 225
 226     // Category record word 2:
 227     // 0:31 [32] event_pointer_table_offset: offset from the beginning of the category data pool to
 228     //                                       the event_pointer_table
 229     const uint32_t categoryRecordWord2 = static_cast<uint32_t>(3u * uint32_t_size);
 230
 231     // Process the event records
 232     const size_t counterCount = categoryCounters.size();
 233     std::vector<EventRecord> eventRecords(counterCount);
 234     std::vector<uint32_t> eventRecordOffsets(counterCount, 0);
 235     size_t eventRecordsSize = 0;
 236     uint32_t eventRecordsOffset = armnn::numeric_cast<uint32_t>(
 237                     (eventRecords.size() + categoryNameBuffer.size()) * uint32_t_size);
 238     for (size_t counterIndex = 0, eventRecordIndex = 0, eventRecordOffsetIndex = 0;
 239          counterIndex < counterCount;
 240          counterIndex++, eventRecordIndex++, eventRecordOffsetIndex++)
 241     {
 242         uint16_t counterUid = categoryCounters.at(counterIndex);
 243         auto it = counters.find(counterUid);
 244         const CounterPtr& counter = it->second;
 245
 246         EventRecord& eventRecord = eventRecords.at(eventRecordIndex);
 247         if (!CreateEventRecord(counter, eventRecord, errorMessage))
 248         {
 249             return false;
 250         }
 251
 252         // Update the total size in words of the event records
 253         eventRecordsSize += eventRecord.size();
 254
 255         // Add the event record offset to the event pointer table offset field
 256         eventRecordOffsets[eventRecordOffsetIndex] = eventRecordsOffset;
 257         eventRecordsOffset += armnn::numeric_cast<uint32_t>(eventRecord.size() * uint32_t_size);
 258     }
 259
 260     // Category record word 3:
 261     // 0:31 [32] name_offset (offset from the beginning of the category data pool to the name field)
 262     const uint32_t categoryRecordWord3 = armnn::numeric_cast<uint32_t>(
 263             (3u + eventRecordOffsets.size()) * uint32_t_size);
 264
 265     // Calculate the size in words of the category record
 266     const size_t categoryRecordSize = 3u +// The size of the fixed part (device + counter_set + event_count +
 267                                           // reserved + event_pointer_table_offset + name_offset)
 268                                       eventRecordOffsets.size() + // The size of the variable part (
 269                                       categoryNameBuffer.size() + // the event pointer table + the category name
 270                                       eventRecordsSize;           // including the null-terminator + the event records)
 271
 272     // Allocate the necessary space for the category record
 273     categoryRecord.resize(categoryRecordSize);
 274
 275     ARMNN_NO_CONVERSION_WARN_BEGIN
 276     // Create the category record
 277     categoryRecord[0] = categoryRecordWord1; // event_count + reserved
 278     categoryRecord[1] = categoryRecordWord2; // event_pointer_table_offset
 279     categoryRecord[2] = categoryRecordWord3; // name_offset
 280     auto offset = categoryRecord.begin() + 3u;
 281     std::copy(eventRecordOffsets.begin(), eventRecordOffsets.end(), offset); // event_pointer_table
 282     offset += eventRecordOffsets.size();
 283     std::copy(categoryNameBuffer.begin(), categoryNameBuffer.end(), offset); // name
 284     offset += categoryNameBuffer.size();
 285     for (const EventRecord& eventRecord : eventRecords)
 286     {
 287         std::copy(eventRecord.begin(), eventRecord.end(), offset); // event_record
 288         offset += eventRecord.size();
 289     }
 290     ARMNN_NO_CONVERSION_WARN_END
 291
 292     return true;
 293 }
 294
 295 bool SendCounterPacket::CreateDeviceRecord(const DevicePtr& device,
 296                                            DeviceRecord& deviceRecord,
 297                                            std::string& errorMessage)
 298 {
 299     ARMNN_ASSERT(device);
 300
 301     uint16_t deviceUid = device->m_Uid;
 302     const std::string& deviceName = device->m_Name;
 303     uint16_t deviceCores = device->m_Cores;
 304
 305     ARMNN_ASSERT(!deviceName.empty());
 306
 307     // Device record word 0:
 308     // 16:31 [16] uid: the unique identifier for the device
 309     // 0:15  [16] cores: the number of individual streams of counters for one or more cores of some device
 310     const uint32_t deviceRecordWord0 = (static_cast<uint32_t>(deviceUid) << 16) |
 311                                  (static_cast<uint32_t>(deviceCores));
 312
 313     // Device record word 1:
 314     // 0:31 [32] name_offset: offset from the beginning of the device record pool to the name field
 315     const uint32_t deviceRecordWord1 = 8u; // The offset is always eight here, as the name field is always
 316                                            // the first (and only) item in the pool and there are two device words
 317
 318     // Convert the device name into a SWTrace string
 319     std::vector<uint32_t> deviceNameBuffer;
 320     if (!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>(deviceName, deviceNameBuffer))
 321     {
 322         errorMessage = boost::str(boost::format("Cannot convert the name of device %1% (%2%) to an SWTrace string")
 323                                   % deviceUid
 324                                   % deviceName);
 325         return false;
 326     }
 327
 328     // Calculate the size in words of the device record
 329     const size_t deviceRecordSize = 2u + // The size of the fixed part (uid + cores + name_offset)
 330                               deviceNameBuffer.size(); // The size of the variable part (the device name including
 331                                                        // the null-terminator)
 332
 333     // Allocate the necessary space for the device record
 334     deviceRecord.resize(deviceRecordSize);
 335
 336     // Create the device record
 337     deviceRecord[0] = deviceRecordWord0; // uid + core
 338     deviceRecord[1] = deviceRecordWord1; // name_offset
 339     auto offset = deviceRecord.begin() + 2u;
 340     std::copy(deviceNameBuffer.begin(), deviceNameBuffer.end(), offset); // name
 341
 342     return true;
 343 }
 344
 345 bool SendCounterPacket::CreateCounterSetRecord(const CounterSetPtr& counterSet,
 346                                                CounterSetRecord& counterSetRecord,
 347                                                std::string& errorMessage)
 348 {
 349     ARMNN_ASSERT(counterSet);
 350
 351     uint16_t counterSetUid = counterSet->m_Uid;
 352     const std::string& counterSetName = counterSet->m_Name;
 353     uint16_t counterSetCount = counterSet->m_Count;
 354
 355     ARMNN_ASSERT(!counterSetName.empty());
 356
 357     // Counter set record word 0:
 358     // 16:31 [16] uid: the unique identifier for the counter_set
 359     // 0:15  [16] count: the number of counters which can be active in this set at any one time
 360     const uint32_t counterSetRecordWord0 = (static_cast<uint32_t>(counterSetUid) << 16) |
 361                                            (static_cast<uint32_t>(counterSetCount));
 362
 363     // Counter set record word 1:
 364     // 0:31 [32] name_offset: offset from the beginning of the counter set pool to the name field
 365     const uint32_t counterSetRecordWord1 = 8u; // The offset is always eight here, as the name field is always
 366                                                // the first (and only) item in the pool after the two counter set words
 367
 368     // Convert the device name into a SWTrace namestring
 369     std::vector<uint32_t> counterSetNameBuffer;
 370     if (!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(counterSet->m_Name, counterSetNameBuffer))
 371     {
 372         errorMessage = boost::str(boost::format("Cannot convert the name of counter set %1% (%2%) to "
 373                                                 "an SWTrace namestring")
 374                                   % counterSetUid
 375                                   % counterSetName);
 376         return false;
 377     }
 378
 379     // Calculate the size in words of the counter set record
 380     const size_t counterSetRecordSize = 2u + // The size of the fixed part (uid + cores + name_offset)
 381                                         counterSetNameBuffer.size(); // The size of the variable part (the counter set
 382                                                                      // name including the null-terminator)
 383
 384     // Allocate the space for the counter set record
 385     counterSetRecord.resize(counterSetRecordSize);
 386
 387     // Create the counter set record
 388     counterSetRecord[0] = counterSetRecordWord0; // uid + core
 389     counterSetRecord[1] = counterSetRecordWord1; // name_offset
 390     auto offset = counterSetRecord.begin() + 2u;
 391     std::copy(counterSetNameBuffer.begin(), counterSetNameBuffer.end(), offset); // name
 392
 393     return true;
 394 }
 395
 396 bool SendCounterPacket::CreateEventRecord(const CounterPtr& counter,
 397                                           EventRecord& eventRecord,
 398                                           std::string& errorMessage)
 399 {
 400     ARMNN_ASSERT(counter);
 401
 402     uint16_t           counterUid           = counter->m_Uid;
 403     uint16_t           maxCounterUid        = counter->m_MaxCounterUid;
 404     uint16_t           deviceUid            = counter->m_DeviceUid;
 405     uint16_t           counterSetUid        = counter->m_CounterSetUid;
 406     uint16_t           counterClass         = counter->m_Class;
 407     uint16_t           counterInterpolation = counter->m_Interpolation;
 408     double             counterMultiplier    = counter->m_Multiplier;
 409     const std::string& counterName          = counter->m_Name;
 410     const std::string& counterDescription   = counter->m_Description;
 411     const std::string& counterUnits         = counter->m_Units;
 412
 413     ARMNN_ASSERT(counterClass == 0 || counterClass == 1);
 414     ARMNN_ASSERT(counterInterpolation == 0 || counterInterpolation == 1);
 415     ARMNN_ASSERT(counterMultiplier);
 416
 417     // Utils
 418     const size_t uint32_t_size = sizeof(uint32_t);
 419     // eventRecordBlockSize is the size of the fixed part
 420     // (counter_uid + max_counter_uid + device +
 421     // counter_set + class + interpolation +
 422     // multiplier + name_offset + description_offset +
 423     // units_offset)
 424     const size_t eventRecordBlockSize = 8u;
 425
 426     // Event record word 0:
 427     // 16:31 [16] max_counter_uid: if the device this event is associated with has more than one core and there
 428     //                             is one of these counters per core this value will be set to
 429     //                             (counter_uid + cores (from device_record)) - 1.
 430     //                             If there is only a single core then this value will be the same as
 431     //                             the counter_uid value
 432     // 0:15  [16] count_uid: unique ID for the counter. Must be unique across all counters in all categories
 433     const uint32_t eventRecordWord0 = (static_cast<uint32_t>(maxCounterUid) << 16) |
 434                                       (static_cast<uint32_t>(counterUid));
 435
 436     // Event record word 1:
 437     // 16:31 [16] device: UID of the device this event is associated with. Set to zero if the event is NOT
 438     //                    associated with a device
 439     // 0:15  [16] counter_set: UID of the counter_set this event is associated with. Set to zero if the event
 440     //                         is NOT associated with a counter_set
 441     const uint32_t eventRecordWord1 = (static_cast<uint32_t>(deviceUid) << 16) |
 442                                       (static_cast<uint32_t>(counterSetUid));
 443
 444     // Event record word 2:
 445     // 16:31 [16] class: type describing how to treat each data point in a stream of data points
 446     // 0:15  [16] interpolation: type describing how to interpolate each data point in a stream of data points
 447     const uint32_t eventRecordWord2 = (static_cast<uint32_t>(counterClass) << 16) |
 448                                       (static_cast<uint32_t>(counterInterpolation));
 449
 450     // Event record word 3-4:
 451     // 0:63 [64] multiplier: internal data stream is represented as integer values, this allows scaling of
 452     //                       those values as if they are fixed point numbers. Zero is not a valid value
 453     uint32_t multiplier[2] = { 0u, 0u };
 454     ARMNN_ASSERT(sizeof(counterMultiplier) == sizeof(multiplier));
 455     std::memcpy(multiplier, &counterMultiplier, sizeof(multiplier));
 456     const uint32_t eventRecordWord3 = multiplier[0];
 457     const uint32_t eventRecordWord4 = multiplier[1];
 458
 459     // Event record word 5:
 460     // 0:31 [32] name_offset: offset from the beginning of the event record pool to the name field
 461     const uint32_t eventRecordWord5 = static_cast<uint32_t>(eventRecordBlockSize * uint32_t_size);
 462
 463     // Convert the counter name into a SWTrace string
 464     std::vector<uint32_t> counterNameBuffer;
 465     if (!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>(counterName, counterNameBuffer))
 466     {
 467         errorMessage = boost::str(boost::format("Cannot convert the name of counter %1% (name: %2%) "
 468                                                 "to an SWTrace string")
 469                                   % counterUid
 470                                   % counterName);
 471         return false;
 472     }
 473
 474     // Event record word 6:
 475     // 0:31 [32] description_offset: offset from the beginning of the event record pool to the description field
 476     // The size of the name buffer in bytes
 477     uint32_t eventRecordWord6 =
 478             static_cast<uint32_t>((counterNameBuffer.size() + eventRecordBlockSize) * uint32_t_size);
 479
 480     // Convert the counter description into a SWTrace string
 481     std::vector<uint32_t> counterDescriptionBuffer;
 482     if (!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>(counterDescription, counterDescriptionBuffer))
 483     {
 484         errorMessage = boost::str(boost::format("Cannot convert the description of counter %1% (description: %2%) "
 485                                                 "to an SWTrace string")
 486                                   % counterUid
 487                                   % counterName);
 488         return false;
 489     }
 490
 491     // Event record word 7:
 492     // 0:31 [32] units_offset: (optional) offset from the beginning of the event record pool to the units field.
 493     //                         An offset value of zero indicates this field is not provided
 494     bool includeUnits = !counterUnits.empty();
 495     // The size of the description buffer in bytes
 496     const uint32_t eventRecordWord7 = includeUnits ?
 497                                 eventRecordWord6 +
 498                                 armnn::numeric_cast<uint32_t>(counterDescriptionBuffer.size()
 499                                 * uint32_t_size) :
 500                                 0;
 501
 502     // Convert the counter units into a SWTrace namestring (optional)
 503     std::vector<uint32_t> counterUnitsBuffer;
 504     if (includeUnits)
 505     {
 506         // Convert the counter units into a SWTrace namestring
 507         if (!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(counterUnits, counterUnitsBuffer))
 508         {
 509             errorMessage = boost::str(boost::format("Cannot convert the units of counter %1% (units: %2%) "
 510                                                     "to an SWTrace string")
 511                                       % counterUid
 512                                       % counterName);
 513             return false;
 514         }
 515     }
 516
 517     // Calculate the size in words of the event record
 518     const size_t eventRecordSize = eventRecordBlockSize +
 519                                    counterNameBuffer.size() +        // The size of the variable part (the counter name,
 520                                    counterDescriptionBuffer.size() + // description and units
 521                                    counterUnitsBuffer.size();        // including the null-terminator)
 522
 523     // Allocate the space for the event record
 524     eventRecord.resize(eventRecordSize);
 525
 526     ARMNN_NO_CONVERSION_WARN_BEGIN
 527     // Create the event record
 528     eventRecord[0] = eventRecordWord0; // max_counter_uid + counter_uid
 529     eventRecord[1] = eventRecordWord1; // device + counter_set
 530     eventRecord[2] = eventRecordWord2; // class + interpolation
 531     eventRecord[3] = eventRecordWord3; // multiplier
 532     eventRecord[4] = eventRecordWord4; // multiplier
 533     eventRecord[5] = eventRecordWord5; // name_offset
 534     eventRecord[6] = eventRecordWord6; // description_offset
 535     eventRecord[7] = eventRecordWord7; // units_offset
 536     auto offset = eventRecord.begin() + 8u;
 537     std::copy(counterNameBuffer.begin(), counterNameBuffer.end(), offset); // name
 538     offset += counterNameBuffer.size();
 539     std::copy(counterDescriptionBuffer.begin(), counterDescriptionBuffer.end(), offset); // description
 540     if (includeUnits)
 541     {
 542         offset += counterDescriptionBuffer.size();
 543         std::copy(counterUnitsBuffer.begin(), counterUnitsBuffer.end(), offset); // units
 544     }
 545     ARMNN_NO_CONVERSION_WARN_END
 546
 547     return true;
 548 }
 549
 550 void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& counterDirectory)
 551 {
 552     // Get the amount of data that needs to be put into the packet
 553     const uint16_t categoryCount    = counterDirectory.GetCategoryCount();
 554     const uint16_t deviceCount      = counterDirectory.GetDeviceCount();
 555     const uint16_t counterSetCount  = counterDirectory.GetCounterSetCount();
 556
 557     // Utils
 558     const size_t uint32_t_size = sizeof(uint32_t);
 559     const size_t packetHeaderSize = 2u;
 560     const size_t bodyHeaderSize = 6u;
 561     const uint32_t bodyHeaderSizeBytes = bodyHeaderSize * uint32_t_size;
 562
 563     // Initialize the offset for the pointer tables
 564     uint32_t pointerTableOffset = 0;
 565
 566     // --------------
 567     // Device records
 568     // --------------
 569
 570     // Process device records
 571     std::vector<DeviceRecord> deviceRecords(deviceCount);
 572     const Devices& devices = counterDirectory.GetDevices();
 573     std::vector<uint32_t> deviceRecordOffsets(deviceCount, 0); // device_records_pointer_table
 574     size_t deviceRecordsSize = 0;
 575     size_t deviceIndex = 0;
 576     size_t deviceRecordOffsetIndex = 0;
 577
 578     pointerTableOffset = armnn::numeric_cast<uint32_t>(deviceCount * uint32_t_size +
 579                                                        counterSetCount * uint32_t_size +
 580                                                        categoryCount   * uint32_t_size);
 581     for (auto it = devices.begin(); it != devices.end(); it++)
 582     {
 583         const DevicePtr& device = it->second;
 584         DeviceRecord& deviceRecord = deviceRecords.at(deviceIndex);
 585
 586         std::string errorMessage;
 587         if (!CreateDeviceRecord(device, deviceRecord, errorMessage))
 588         {
 589             CancelOperationAndThrow<RuntimeException>(errorMessage);
 590         }
 591
 592         // Update the total size in words of the device records
 593         deviceRecordsSize += deviceRecord.size();
 594
 595         // Add the device record offset to the device records pointer table offset field
 596         deviceRecordOffsets[deviceRecordOffsetIndex] = pointerTableOffset;
 597         pointerTableOffset += armnn::numeric_cast<uint32_t>(deviceRecord.size() * uint32_t_size);
 598
 599         deviceIndex++;
 600         deviceRecordOffsetIndex++;
 601     }
 602
 603     // -------------------
 604     // Counter set records
 605     // -------------------
 606
 607     // Process counter set records
 608     std::vector<CounterSetRecord> counterSetRecords(counterSetCount);
 609     const CounterSets& counterSets = counterDirectory.GetCounterSets();
 610     std::vector<uint32_t> counterSetRecordOffsets(counterSetCount, 0); // counter_set_records_pointer_table
 611     size_t counterSetRecordsSize = 0;
 612     size_t counterSetIndex = 0;
 613     size_t counterSetRecordOffsetIndex = 0;
 614
 615     pointerTableOffset -= armnn::numeric_cast<uint32_t>(deviceCount * uint32_t_size);
 616     for (auto it = counterSets.begin(); it != counterSets.end(); it++)
 617     {
 618         const CounterSetPtr& counterSet = it->second;
 619         CounterSetRecord& counterSetRecord = counterSetRecords.at(counterSetIndex);
 620
 621         std::string errorMessage;
 622         if (!CreateCounterSetRecord(counterSet, counterSetRecord, errorMessage))
 623         {
 624             CancelOperationAndThrow<RuntimeException>(errorMessage);
 625         }
 626
 627         // Update the total size in words of the counter set records
 628         counterSetRecordsSize += counterSetRecord.size();
 629
 630         // Add the counter set record offset to the counter set records pointer table offset field
 631         counterSetRecordOffsets[counterSetRecordOffsetIndex] = pointerTableOffset;
 632         pointerTableOffset += armnn::numeric_cast<uint32_t>(counterSetRecord.size() * uint32_t_size);
 633
 634         counterSetIndex++;
 635         counterSetRecordOffsetIndex++;
 636     }
 637
 638     // ----------------
 639     // Category records
 640     // ----------------
 641
 642     // Process category records
 643     std::vector<CategoryRecord> categoryRecords(categoryCount);
 644     const Categories& categories = counterDirectory.GetCategories();
 645     std::vector<uint32_t> categoryRecordOffsets(categoryCount, 0); // category_records_pointer_table
 646     size_t categoryRecordsSize = 0;
 647     size_t categoryIndex = 0;
 648     size_t categoryRecordOffsetIndex = 0;
 649
 650     pointerTableOffset -= armnn::numeric_cast<uint32_t>(counterSetCount * uint32_t_size);
 651     for (auto it = categories.begin(); it != categories.end(); it++)
 652     {
 653         const CategoryPtr& category = *it;
 654         CategoryRecord& categoryRecord = categoryRecords.at(categoryIndex);
 655
 656         std::string errorMessage;
 657         if (!CreateCategoryRecord(category, counterDirectory.GetCounters(), categoryRecord, errorMessage))
 658         {
 659             CancelOperationAndThrow<RuntimeException>(errorMessage);
 660         }
 661
 662         // Update the total size in words of the category records
 663         categoryRecordsSize += categoryRecord.size();
 664
 665         // Add the category record offset to the category records pointer table offset field
 666         categoryRecordOffsets[categoryRecordOffsetIndex] = pointerTableOffset;
 667         pointerTableOffset += armnn::numeric_cast<uint32_t>(categoryRecord.size() * uint32_t_size);
 668
 669         categoryIndex++;
 670         categoryRecordOffsetIndex++;
 671     }
 672
 673     // Calculate the length in words of the counter directory packet's data (excludes the packet header size)
 674     const size_t counterDirectoryPacketDataLength =
 675                  bodyHeaderSize +                 // The size of the body header
 676                  deviceRecordOffsets.size() +     // The size of the device records pointer table
 677                  counterSetRecordOffsets.size() + // The size of counter set pointer table
 678                  categoryRecordOffsets.size() +   // The size of category records pointer table
 679                  deviceRecordsSize +              // The total size of the device records
 680                  counterSetRecordsSize +          // The total size of the counter set records
 681                  categoryRecordsSize;             // The total size of the category records
 682
 683     // Calculate the size in words of the counter directory packet (the data length plus the packet header size)
 684     const size_t counterDirectoryPacketSize = packetHeaderSize +                // The size of the packet header
 685                                               counterDirectoryPacketDataLength; // The data length
 686
 687     // Allocate the necessary space for the counter directory packet
 688     std::vector<uint32_t> counterDirectoryPacket(counterDirectoryPacketSize, 0);
 689
 690     // -------------
 691     // Packet header
 692     // -------------
 693
 694     // Packet header word 0:
 695     // 26:31 [6]  packet_family: control Packet Family
 696     // 16:25 [10] packet_id: packet identifier
 697     // 8:15  [8]  reserved: all zeros
 698     // 0:7   [8]  reserved: all zeros
 699     uint32_t packetFamily = 0;
 700     uint32_t packetId = 2;
 701     uint32_t packetHeaderWord0 = ((packetFamily & 0x3F) << 26) | ((packetId & 0x3FF) << 16);
 702
 703     // Packet header word 1:
 704     // 0:31 [32] data_length: length of data, in bytes
 705     uint32_t packetHeaderWord1 = armnn::numeric_cast<uint32_t>(
 706             counterDirectoryPacketDataLength * uint32_t_size);
 707
 708     // Create the packet header
 709     uint32_t packetHeader[2]
 710     {
 711         packetHeaderWord0, // packet_family + packet_id + reserved + reserved
 712         packetHeaderWord1  // data_length
 713     };
 714
 715     // -----------
 716     // Body header
 717     // -----------
 718
 719     // Body header word 0:
 720     // 16:31 [16] device_records_count: number of entries in the device_records_pointer_table
 721     // 0:15  [16] reserved: all zeros
 722     const uint32_t bodyHeaderWord0 = static_cast<uint32_t>(deviceCount) << 16;
 723
 724     // Body header word 1:
 725     // 0:31 [32] device_records_pointer_table_offset: offset to the device_records_pointer_table
 726     const uint32_t bodyHeaderWord1 = bodyHeaderSizeBytes; // The offset is always the bodyHeaderSize,
 727                                                           // as the device record pointer table field
 728                                                           // is always the first item in the pool
 729
 730     // Body header word 2:
 731     // 16:31 [16] counter_set_count: number of entries in the counter_set_pointer_table
 732     // 0:15  [16] reserved: all zeros
 733     const uint32_t bodyHeaderWord2 = static_cast<uint32_t>(counterSetCount) << 16;
 734
 735     // Body header word 3:
 736     // 0:31 [32] counter_set_pointer_table_offset: offset to the counter_set_pointer_table
 737     const uint32_t bodyHeaderWord3 = armnn::numeric_cast<uint32_t>(deviceRecordOffsets.size() *
 738                                                                    uint32_t_size +       // The size of the
 739                                                                    bodyHeaderSizeBytes); // device records pointer table
 740
 741     // Body header word 4:
 742     // 16:31 [16] categories_count: number of entries in the categories_pointer_table
 743     // 0:15  [16] reserved: all zeros
 744     const uint32_t bodyHeaderWord4 = static_cast<uint32_t>(categoryCount) << 16;
 745
 746     // Body header word 3:
 747     // 0:31 [32] categories_pointer_table_offset: offset to the categories_pointer_table
 748     const uint32_t bodyHeaderWord5 =
 749                    armnn::numeric_cast<uint32_t>(
 750                        deviceRecordOffsets.size() * uint32_t_size +     // The size of the device records
 751                        counterSetRecordOffsets.size() * uint32_t_size   // pointer table, plus the size of
 752                        +  bodyHeaderSizeBytes);                         // the counter set pointer table
 753
 754     // Create the body header
 755     const uint32_t bodyHeader[bodyHeaderSize]
 756     {
 757         bodyHeaderWord0, // device_records_count + reserved
 758         bodyHeaderWord1, // device_records_pointer_table_offset
 759         bodyHeaderWord2, // counter_set_count + reserved
 760         bodyHeaderWord3, // counter_set_pointer_table_offset
 761         bodyHeaderWord4, // categories_count + reserved
 762         bodyHeaderWord5  // categories_pointer_table_offset
 763     };
 764
 765     ARMNN_NO_CONVERSION_WARN_BEGIN
 766     // Create the counter directory packet
 767     auto counterDirectoryPacketOffset = counterDirectoryPacket.begin();
 768     // packet_header
 769     std::copy(packetHeader, packetHeader + packetHeaderSize, counterDirectoryPacketOffset);
 770     counterDirectoryPacketOffset += packetHeaderSize;
 771     // body_header
 772     std::copy(bodyHeader, bodyHeader + bodyHeaderSize, counterDirectoryPacketOffset);
 773     counterDirectoryPacketOffset += bodyHeaderSize;
 774     // device_records_pointer_table
 775     std::copy(deviceRecordOffsets.begin(), deviceRecordOffsets.end(), counterDirectoryPacketOffset);
 776     counterDirectoryPacketOffset += deviceRecordOffsets.size();
 777     // counter_set_pointer_table
 778     std::copy(counterSetRecordOffsets.begin(), counterSetRecordOffsets.end(), counterDirectoryPacketOffset);
 779     counterDirectoryPacketOffset += counterSetRecordOffsets.size();
 780     // category_pointer_table
 781     std::copy(categoryRecordOffsets.begin(), categoryRecordOffsets.end(), counterDirectoryPacketOffset);
 782     counterDirectoryPacketOffset += categoryRecordOffsets.size();
 783     // device_records
 784     for (const DeviceRecord& deviceRecord : deviceRecords)
 785     {
 786         std::copy(deviceRecord.begin(), deviceRecord.end(), counterDirectoryPacketOffset); // device_record
 787         counterDirectoryPacketOffset += deviceRecord.size();
 788     }
 789     // counter_set_records
 790     for (const CounterSetRecord& counterSetRecord : counterSetRecords)
 791     {
 792         std::copy(counterSetRecord.begin(), counterSetRecord.end(), counterDirectoryPacketOffset); // counter_set_record
 793         counterDirectoryPacketOffset += counterSetRecord.size();
 794     }
 795     // category_records
 796     for (const CategoryRecord& categoryRecord : categoryRecords)
 797     {
 798         std::copy(categoryRecord.begin(), categoryRecord.end(), counterDirectoryPacketOffset); // category_record
 799         counterDirectoryPacketOffset += categoryRecord.size();
 800     }
 801     ARMNN_NO_CONVERSION_WARN_END
 802
 803     // Calculate the total size in bytes of the counter directory packet
 804     uint32_t totalSize = armnn::numeric_cast<uint32_t>(counterDirectoryPacketSize * uint32_t_size);
 805
 806     // Reserve space in the buffer for the packet
 807     uint32_t reserved = 0;
 808     IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
 809
 810     if (writeBuffer == nullptr || reserved < totalSize)
 811     {
 812         CancelOperationAndThrow<BufferExhaustion>(
 813             writeBuffer,
 814             boost::str(boost::format("No space left in buffer. Unable to reserve (%1%) bytes.") % totalSize));
 815     }
 816
 817     // Offset for writing to the buffer
 818     uint32_t offset = 0;
 819
 820     // Write the counter directory packet to the buffer
 821     for (uint32_t counterDirectoryPacketWord : counterDirectoryPacket)
 822     {
 823         WriteUint32(writeBuffer, offset, counterDirectoryPacketWord);
 824         offset += armnn::numeric_cast<uint32_t>(uint32_t_size);
 825     }
 826
 827     m_BufferManager.Commit(writeBuffer, totalSize);
 828 }
 829
 830 void SendCounterPacket::SendPeriodicCounterCapturePacket(uint64_t timestamp, const IndexValuePairsVector& values)
 831 {
 832     uint32_t uint16_t_size = sizeof(uint16_t);
 833     uint32_t uint32_t_size = sizeof(uint32_t);
 834     uint32_t uint64_t_size = sizeof(uint64_t);
 835
 836     uint32_t packetFamily = 3;
 837     uint32_t packetClass = 0;
 838     uint32_t packetType = 0;
 839     uint32_t headerSize = 2 * uint32_t_size;
 840     uint32_t bodySize = uint64_t_size + armnn::numeric_cast<uint32_t>(values.size()) * (uint16_t_size + uint32_t_size);
 841     uint32_t totalSize = headerSize + bodySize;
 842     uint32_t offset = 0;
 843     uint32_t reserved = 0;
 844
 845     IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
 846
 847     if (writeBuffer == nullptr || reserved < totalSize)
 848     {
 849         CancelOperationAndThrow<BufferExhaustion>(
 850             writeBuffer,
 851             boost::str(boost::format("No space left in buffer. Unable to reserve (%1%) bytes.") % totalSize));
 852     }
 853
 854     // Create header.
 855     WriteUint32(writeBuffer,
 856                 offset,
 857                 ((packetFamily & 0x0000003F) << 26) |
 858                 ((packetClass  & 0x0000007F) << 19) |
 859                 ((packetType   & 0x00000007) << 16));
 860     offset += uint32_t_size;
 861     WriteUint32(writeBuffer, offset, bodySize);
 862
 863     // Copy captured Timestamp.
 864     offset += uint32_t_size;
 865     WriteUint64(writeBuffer, offset, timestamp);
 866
 867     // Copy selectedCounterIds.
 868     offset += uint64_t_size;
 869     for (const auto& pair: values)
 870     {
 871         WriteUint16(writeBuffer, offset, pair.counterId);
 872         offset += uint16_t_size;
 873         WriteUint32(writeBuffer, offset, pair.counterValue);
 874         offset += uint32_t_size;
 875     }
 876
 877     m_BufferManager.Commit(writeBuffer, totalSize);
 878 }
 879
 880 void SendCounterPacket::SendPeriodicCounterSelectionPacket(uint32_t capturePeriod,
 881                                                            const std::vector<uint16_t>& selectedCounterIds)
 882 {
 883     uint32_t uint16_t_size = sizeof(uint16_t);
 884     uint32_t uint32_t_size = sizeof(uint32_t);
 885
 886     uint32_t packetFamily = 0;
 887     uint32_t packetId = 4;
 888     uint32_t headerSize = 2 * uint32_t_size;
 889     uint32_t bodySize = uint32_t_size + armnn::numeric_cast<uint32_t>(selectedCounterIds.size()) * uint16_t_size;
 890     uint32_t totalSize = headerSize + bodySize;
 891     uint32_t offset = 0;
 892     uint32_t reserved = 0;
 893
 894     IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
 895
 896     if (writeBuffer == nullptr || reserved < totalSize)
 897     {
 898         CancelOperationAndThrow<BufferExhaustion>(
 899             writeBuffer,
 900             boost::str(boost::format("No space left in buffer. Unable to reserve (%1%) bytes.") % totalSize));
 901     }
 902
 903     // Create header.
 904     WriteUint32(writeBuffer, offset, ((packetFamily & 0x3F) << 26) | ((packetId & 0x3FF) << 16));
 905     offset += uint32_t_size;
 906     WriteUint32(writeBuffer, offset, bodySize);
 907
 908     // Copy capturePeriod.
 909     offset += uint32_t_size;
 910     WriteUint32(writeBuffer, offset, capturePeriod);
 911
 912     // Copy selectedCounterIds.
 913     offset += uint32_t_size;
 914     for(const uint16_t& id: selectedCounterIds)
 915     {
 916         WriteUint16(writeBuffer, offset, id);
 917         offset += uint16_t_size;
 918     }
 919
 920     m_BufferManager.Commit(writeBuffer, totalSize);
 921 }
 922
 923 } // namespace profiling
 924
 925 } // namespace armnn