13 #include <boost/format.hpp> 14 #include <boost/numeric/conversion/cast.hpp> 15 #include <boost/core/ignore_unused.hpp> 25 using boost::numeric_cast;
36 uint32_t infoSize = numeric_cast<uint32_t>(info.size()) > 0 ? numeric_cast<uint32_t>(info.size()) + 1 : 0;
37 uint32_t hardwareVersionSize = numeric_cast<uint32_t>(hardwareVersion.size()) > 0 ?
38 numeric_cast<uint32_t>(hardwareVersion.size()) + 1 : 0;
39 uint32_t softwareVersionSize = numeric_cast<uint32_t>(softwareVersion.size()) > 0 ?
40 numeric_cast<uint32_t>(softwareVersion.size()) + 1 : 0;
41 uint32_t processNameSize = numeric_cast<uint32_t>(processName.size()) > 0 ?
42 numeric_cast<uint32_t>(processName.size()) + 1 : 0;
44 uint32_t sizeUint32 = numeric_cast<uint32_t>(
sizeof(uint32_t));
46 uint32_t headerSize = 2 * sizeUint32;
47 uint32_t bodySize = 10 * sizeUint32;
48 uint32_t packetVersionCountSize = sizeUint32;
57 uint32_t packetVersionEntries = 6;
59 uint32_t payloadSize = numeric_cast<uint32_t>(infoSize + hardwareVersionSize + softwareVersionSize +
60 processNameSize + packetVersionCountSize +
61 (packetVersionEntries * 2 * sizeUint32));
63 uint32_t totalSize = headerSize + bodySize + payloadSize;
65 uint32_t reserved = 0;
69 if (writeBuffer ==
nullptr || reserved < totalSize)
71 CancelOperationAndThrow<BufferExhaustion>(
73 boost::str(boost::format(
"No space left in buffer. Unable to reserve (%1%) bytes.") % totalSize));
82 WriteUint32(writeBuffer, offset, totalSize - headerSize);
94 WriteUint32(writeBuffer, offset, numeric_cast<uint32_t>(pid));
96 uint32_t poolOffset = bodySize;
97 WriteUint32(writeBuffer, offset, infoSize ? poolOffset : 0);
99 poolOffset += infoSize;
100 WriteUint32(writeBuffer, offset, hardwareVersionSize ? poolOffset : 0);
101 offset += sizeUint32;
102 poolOffset += hardwareVersionSize;
103 WriteUint32(writeBuffer, offset, softwareVersionSize ? poolOffset : 0);
104 offset += sizeUint32;
105 poolOffset += softwareVersionSize;
106 WriteUint32(writeBuffer, offset, processNameSize ? poolOffset : 0);
107 offset += sizeUint32;
108 poolOffset += processNameSize;
109 WriteUint32(writeBuffer, offset, packetVersionEntries ? poolOffset : 0);
110 offset += sizeUint32;
112 offset += sizeUint32;
118 memcpy(&writeBuffer->GetWritableData()[offset], info.c_str(), infoSize);
122 if (hardwareVersionSize)
124 memcpy(&writeBuffer->GetWritableData()[offset], hardwareVersion.c_str(), hardwareVersionSize);
125 offset += hardwareVersionSize;
128 if (softwareVersionSize)
130 memcpy(&writeBuffer->GetWritableData()[offset], softwareVersion.c_str(), softwareVersionSize);
131 offset += softwareVersionSize;
136 memcpy(&writeBuffer->GetWritableData()[offset], processName.c_str(), processNameSize);
137 offset += processNameSize;
140 if (packetVersionEntries)
143 WriteUint32(writeBuffer, offset, packetVersionEntries << 16);
146 uint32_t packetFamily = 0;
147 uint32_t packetId = 0;
149 offset += sizeUint32;
150 for (uint32_t i = 0; i < packetVersionEntries - 1; ++i)
152 WriteUint32(writeBuffer, offset, ((packetFamily & 0x3F) << 26) | ((packetId++ & 0x3FF) << 16));
153 offset += sizeUint32;
155 offset += sizeUint32;
161 WriteUint32(writeBuffer, offset, ((packetFamily & 0x3F) << 26) | ((packetId & 0x3FF) << 16));
162 offset += sizeUint32;
168 CancelOperationAndThrow<RuntimeException>(writeBuffer,
"Error processing packet.");
171 m_BufferManager.
Commit(writeBuffer, totalSize,
false);
177 std::string& errorMessage)
179 using namespace boost::numeric;
181 BOOST_ASSERT(category);
183 const std::string& categoryName = category->m_Name;
184 const std::vector<uint16_t> categoryCounters = category->m_Counters;
185 uint16_t deviceUid = category->m_DeviceUid;
186 uint16_t counterSetUid = category->m_CounterSetUid;
188 BOOST_ASSERT(!categoryName.empty());
197 uint32_t categoryRecordWord0 = (
static_cast<uint32_t
>(deviceUid) << 16) |
198 (
static_cast<uint32_t
>(counterSetUid));
203 uint32_t categoryRecordWord1 =
static_cast<uint32_t
>(categoryCounters.size()) << 16;
208 uint32_t categoryRecordWord2 = 0;
212 std::vector<uint32_t> categoryNameBuffer;
213 if (!StringToSwTraceString<SwTraceNameCharPolicy>(categoryName, categoryNameBuffer))
215 errorMessage = boost::str(boost::format(
"Cannot convert the name of category \"%1%\" to an SWTrace namestring")
221 size_t counterCount = categoryCounters.size();
222 std::vector<EventRecord> eventRecords(counterCount);
223 std::vector<uint32_t> eventRecordOffsets(counterCount, 0);
224 size_t eventRecordsSize = 0;
225 uint32_t eventRecordsOffset =
226 numeric_cast<uint32_t>((eventRecords.size() + categoryNameBuffer.size()) * uint32_t_size);
227 for (
size_t counterIndex = 0, eventRecordIndex = 0, eventRecordOffsetIndex = 0;
228 counterIndex < counterCount;
229 counterIndex++, eventRecordIndex++, eventRecordOffsetIndex++)
231 uint16_t counterUid = categoryCounters.at(counterIndex);
232 auto it = counters.find(counterUid);
233 BOOST_ASSERT(it != counters.end());
236 EventRecord& eventRecord = eventRecords.at(eventRecordIndex);
243 eventRecordsSize += eventRecord.size();
246 eventRecordOffsets[eventRecordOffsetIndex] = eventRecordsOffset;
247 eventRecordsOffset += numeric_cast<uint32_t>(eventRecord.size() *
uint32_t_size);
252 uint32_t categoryRecordWord3 = numeric_cast<uint32_t>(eventRecordOffsets.size() *
uint32_t_size);
255 size_t categoryRecordSize = 4u +
257 eventRecordOffsets.size() +
258 categoryNameBuffer.size() +
262 categoryRecord.resize(categoryRecordSize);
266 categoryRecord[0] = categoryRecordWord0;
267 categoryRecord[1] = categoryRecordWord1;
268 categoryRecord[2] = categoryRecordWord2;
269 categoryRecord[3] = categoryRecordWord3;
270 auto offset = categoryRecord.begin() + 4u;
271 std::copy(eventRecordOffsets.begin(), eventRecordOffsets.end(), offset);
272 offset += eventRecordOffsets.size();
273 std::copy(categoryNameBuffer.begin(), categoryNameBuffer.end(), offset);
274 offset += categoryNameBuffer.size();
275 for (
const EventRecord& eventRecord : eventRecords)
277 std::copy(eventRecord.begin(), eventRecord.end(), offset);
278 offset += eventRecord.size();
287 std::string& errorMessage)
289 BOOST_ASSERT(device);
291 uint16_t deviceUid = device->m_Uid;
292 const std::string& deviceName = device->m_Name;
293 uint16_t deviceCores = device->m_Cores;
295 BOOST_ASSERT(!deviceName.empty());
300 uint32_t deviceRecordWord0 = (
static_cast<uint32_t
>(deviceUid) << 16) |
301 (
static_cast<uint32_t
>(deviceCores));
305 uint32_t deviceRecordWord1 = 0;
309 std::vector<uint32_t> deviceNameBuffer;
310 if (!StringToSwTraceString<SwTraceCharPolicy>(deviceName, deviceNameBuffer))
312 errorMessage = boost::str(boost::format(
"Cannot convert the name of device %1% (\"%2%\") to an SWTrace string")
319 size_t deviceRecordSize = 2u +
320 deviceNameBuffer.size();
324 deviceRecord.resize(deviceRecordSize);
327 deviceRecord[0] = deviceRecordWord0;
328 deviceRecord[1] = deviceRecordWord1;
329 auto offset = deviceRecord.begin() + 2u;
330 std::copy(deviceNameBuffer.begin(), deviceNameBuffer.end(), offset);
337 std::string& errorMessage)
339 BOOST_ASSERT(counterSet);
341 uint16_t counterSetUid = counterSet->m_Uid;
342 const std::string& counterSetName = counterSet->m_Name;
343 uint16_t counterSetCount = counterSet->m_Count;
345 BOOST_ASSERT(!counterSetName.empty());
350 uint32_t counterSetRecordWord0 = (
static_cast<uint32_t
>(counterSetUid) << 16) |
351 (
static_cast<uint32_t
>(counterSetCount));
355 uint32_t counterSetRecordWord1 = 0;
359 std::vector<uint32_t> counterSetNameBuffer;
360 if (!StringToSwTraceString<SwTraceNameCharPolicy>(counterSet->m_Name, counterSetNameBuffer))
362 errorMessage = boost::str(boost::format(
"Cannot convert the name of counter set %1% (\"%2%\") to " 363 "an SWTrace namestring")
370 size_t counterSetRecordSize = 2u +
371 counterSetNameBuffer.size();
375 counterSetRecord.resize(counterSetRecordSize);
378 counterSetRecord[0] = counterSetRecordWord0;
379 counterSetRecord[1] = counterSetRecordWord1;
380 auto offset = counterSetRecord.begin() + 2u;
381 std::copy(counterSetNameBuffer.begin(), counterSetNameBuffer.end(), offset);
388 std::string& errorMessage)
390 using namespace boost::numeric;
392 BOOST_ASSERT(counter);
394 uint16_t counterUid = counter->m_Uid;
395 uint16_t maxCounterUid = counter->m_MaxCounterUid;
396 uint16_t deviceUid = counter->m_DeviceUid;
397 uint16_t counterSetUid = counter->m_CounterSetUid;
398 uint16_t counterClass = counter->m_Class;
399 uint16_t counterInterpolation = counter->m_Interpolation;
400 double counterMultiplier = counter->m_Multiplier;
401 const std::string& counterName = counter->m_Name;
402 const std::string& counterDescription = counter->m_Description;
403 const std::string& counterUnits = counter->m_Units;
405 BOOST_ASSERT(counterClass == 0 || counterClass == 1);
406 BOOST_ASSERT(counterInterpolation == 0 || counterInterpolation == 1);
407 BOOST_ASSERT(counterMultiplier);
419 uint32_t eventRecordWord0 = (
static_cast<uint32_t
>(maxCounterUid) << 16) |
420 (
static_cast<uint32_t
>(counterUid));
427 uint32_t eventRecordWord1 = (
static_cast<uint32_t
>(deviceUid) << 16) |
428 (
static_cast<uint32_t
>(counterSetUid));
433 uint32_t eventRecordWord2 = (
static_cast<uint32_t
>(counterClass) << 16) |
434 (
static_cast<uint32_t
>(counterInterpolation));
439 uint32_t multiplier[2] = { 0u, 0u };
440 BOOST_ASSERT(
sizeof(counterMultiplier) ==
sizeof(multiplier));
441 std::memcpy(multiplier, &counterMultiplier,
sizeof(multiplier));
442 uint32_t eventRecordWord3 = multiplier[0];
443 uint32_t eventRecordWord4 = multiplier[1];
447 uint32_t eventRecordWord5 = 0;
451 std::vector<uint32_t> counterNameBuffer;
452 if (!StringToSwTraceString<SwTraceCharPolicy>(counterName, counterNameBuffer))
454 errorMessage = boost::str(boost::format(
"Cannot convert the name of counter %1% (name: \"%2%\") " 455 "to an SWTrace string")
464 uint32_t eventRecordWord6 = numeric_cast<uint32_t>(counterNameBuffer.size() *
uint32_t_size);
467 std::vector<uint32_t> counterDescriptionBuffer;
468 if (!StringToSwTraceString<SwTraceCharPolicy>(counterDescription, counterDescriptionBuffer))
470 errorMessage = boost::str(boost::format(
"Cannot convert the description of counter %1% (description: \"%2%\") " 471 "to an SWTrace string")
480 bool includeUnits = !counterUnits.empty();
482 uint32_t eventRecordWord7 = includeUnits ?
484 numeric_cast<uint32_t>(counterDescriptionBuffer.size() *
uint32_t_size) :
488 std::vector<uint32_t> counterUnitsBuffer;
492 if (!StringToSwTraceString<SwTraceNameCharPolicy>(counterUnits, counterUnitsBuffer))
494 errorMessage = boost::str(boost::format(
"Cannot convert the units of counter %1% (units: \"%2%\") " 495 "to an SWTrace string")
503 size_t eventRecordSize = 8u +
507 counterNameBuffer.size() +
508 counterDescriptionBuffer.size() +
509 counterUnitsBuffer.size();
512 eventRecord.resize(eventRecordSize);
516 eventRecord[0] = eventRecordWord0;
517 eventRecord[1] = eventRecordWord1;
518 eventRecord[2] = eventRecordWord2;
519 eventRecord[3] = eventRecordWord3;
520 eventRecord[4] = eventRecordWord4;
521 eventRecord[5] = eventRecordWord5;
522 eventRecord[6] = eventRecordWord6;
523 eventRecord[7] = eventRecordWord7;
524 auto offset = eventRecord.begin() + 8u;
525 std::copy(counterNameBuffer.begin(), counterNameBuffer.end(), offset);
526 offset += counterNameBuffer.size();
527 std::copy(counterDescriptionBuffer.begin(), counterDescriptionBuffer.end(), offset);
530 offset += counterDescriptionBuffer.size();
531 std::copy(counterUnitsBuffer.begin(), counterUnitsBuffer.end(), offset);
540 using namespace boost::numeric;
549 size_t packetHeaderSize = 2u;
550 size_t bodyHeaderSize = 6u;
553 uint32_t pointerTableOffset = 0;
560 std::vector<DeviceRecord> deviceRecords(deviceCount);
562 std::vector<uint32_t> deviceRecordOffsets(deviceCount, 0);
563 size_t deviceRecordsSize = 0;
564 size_t deviceIndex = 0;
565 size_t deviceRecordOffsetIndex = 0;
566 for (
auto it = devices.begin(); it != devices.end(); it++)
569 DeviceRecord& deviceRecord = deviceRecords.at(deviceIndex);
571 std::string errorMessage;
574 CancelOperationAndThrow<RuntimeException>(errorMessage);
578 deviceRecordsSize += deviceRecord.size();
581 deviceRecordOffsets[deviceRecordOffsetIndex] = pointerTableOffset;
582 pointerTableOffset += numeric_cast<uint32_t>(deviceRecord.size() *
uint32_t_size);
585 deviceRecordOffsetIndex++;
593 std::vector<CounterSetRecord> counterSetRecords(counterSetCount);
595 std::vector<uint32_t> counterSetRecordOffsets(counterSetCount, 0);
596 size_t counterSetRecordsSize = 0;
597 size_t counterSetIndex = 0;
598 size_t counterSetRecordOffsetIndex = 0;
599 for (
auto it = counterSets.begin(); it != counterSets.end(); it++)
604 std::string errorMessage;
607 CancelOperationAndThrow<RuntimeException>(errorMessage);
611 counterSetRecordsSize += counterSetRecord.size();
614 counterSetRecordOffsets[counterSetRecordOffsetIndex] = pointerTableOffset;
615 pointerTableOffset += numeric_cast<uint32_t>(counterSetRecord.size() *
uint32_t_size);
618 counterSetRecordOffsetIndex++;
626 std::vector<CategoryRecord> categoryRecords(categoryCount);
628 std::vector<uint32_t> categoryRecordOffsets(categoryCount, 0);
629 size_t categoryRecordsSize = 0;
630 size_t categoryIndex = 0;
631 size_t categoryRecordOffsetIndex = 0;
632 for (
auto it = categories.begin(); it != categories.end(); it++)
635 CategoryRecord& categoryRecord = categoryRecords.at(categoryIndex);
637 std::string errorMessage;
640 CancelOperationAndThrow<RuntimeException>(errorMessage);
644 categoryRecordsSize += categoryRecord.size();
647 categoryRecordOffsets[categoryRecordOffsetIndex] = pointerTableOffset;
648 pointerTableOffset += numeric_cast<uint32_t>(categoryRecord.size() *
uint32_t_size);
651 categoryRecordOffsetIndex++;
657 size_t counterDirectoryPacketDataLength =
659 deviceRecordOffsets.size() +
660 counterSetRecordOffsets.size() +
661 categoryRecordOffsets.size() +
663 counterSetRecordsSize +
667 size_t counterDirectoryPacketSize = packetHeaderSize +
668 counterDirectoryPacketDataLength;
672 std::vector<uint32_t> counterDirectoryPacket(counterDirectoryPacketSize, 0);
683 uint32_t packetFamily = 0;
684 uint32_t packetId = 2;
685 uint32_t packetHeaderWord0 = ((packetFamily & 0x3F) << 26) | ((packetId & 0x3FF) << 16);
689 uint32_t packetHeaderWord1 = numeric_cast<uint32_t>(counterDirectoryPacketDataLength *
uint32_t_size);
692 uint32_t packetHeader[2]
705 uint32_t bodyHeaderWord0 =
static_cast<uint32_t
>(deviceCount) << 16;
709 uint32_t bodyHeaderWord1 = 0;
715 uint32_t bodyHeaderWord2 =
static_cast<uint32_t
>(counterSetCount) << 16;
719 uint32_t bodyHeaderWord3 =
720 numeric_cast<uint32_t>(deviceRecordOffsets.size() *
uint32_t_size);
727 uint32_t bodyHeaderWord4 =
static_cast<uint32_t
>(categoryCount) << 16;
731 uint32_t bodyHeaderWord5 =
732 numeric_cast<uint32_t>(deviceRecordOffsets.size() * uint32_t_size +
737 uint32_t bodyHeader[6]
749 auto counterDirectoryPacketOffset = counterDirectoryPacket.begin();
751 std::copy(packetHeader, packetHeader + packetHeaderSize, counterDirectoryPacketOffset);
752 counterDirectoryPacketOffset += packetHeaderSize;
754 std::copy(bodyHeader, bodyHeader + bodyHeaderSize, counterDirectoryPacketOffset);
755 counterDirectoryPacketOffset += bodyHeaderSize;
757 std::copy(deviceRecordOffsets.begin(), deviceRecordOffsets.end(), counterDirectoryPacketOffset);
758 counterDirectoryPacketOffset += deviceRecordOffsets.size();
760 std::copy(counterSetRecordOffsets.begin(), counterSetRecordOffsets.end(), counterDirectoryPacketOffset);
761 counterDirectoryPacketOffset += counterSetRecordOffsets.size();
763 std::copy(categoryRecordOffsets.begin(), categoryRecordOffsets.end(), counterDirectoryPacketOffset);
764 counterDirectoryPacketOffset += categoryRecordOffsets.size();
768 std::copy(deviceRecord.begin(), deviceRecord.end(), counterDirectoryPacketOffset);
769 counterDirectoryPacketOffset += deviceRecord.size();
774 std::copy(counterSetRecord.begin(), counterSetRecord.end(), counterDirectoryPacketOffset);
775 counterDirectoryPacketOffset += counterSetRecord.size();
780 std::copy(categoryRecord.begin(), categoryRecord.end(), counterDirectoryPacketOffset);
781 counterDirectoryPacketOffset += categoryRecord.size();
786 uint32_t totalSize = numeric_cast<uint32_t>(counterDirectoryPacketSize *
uint32_t_size);
789 uint32_t reserved = 0;
790 IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
792 if (writeBuffer ==
nullptr || reserved < totalSize)
794 CancelOperationAndThrow<BufferExhaustion>(
796 boost::str(boost::format(
"No space left in buffer. Unable to reserve (%1%) bytes.") % totalSize));
803 for (uint32_t counterDirectoryPacketWord : counterDirectoryPacket)
805 WriteUint32(writeBuffer, offset, counterDirectoryPacketWord);
809 m_BufferManager.Commit(writeBuffer, totalSize);
816 uint32_t uint64_t_size =
sizeof(uint64_t);
818 uint32_t packetFamily = 3;
819 uint32_t packetClass = 0;
820 uint32_t packetType = 0;
822 uint32_t bodySize = uint64_t_size + numeric_cast<uint32_t>(values.size()) * (uint16_t_size + uint32_t_size);
823 uint32_t totalSize = headerSize + bodySize;
825 uint32_t reserved = 0;
827 IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
829 if (writeBuffer ==
nullptr || reserved < totalSize)
831 CancelOperationAndThrow<BufferExhaustion>(
833 boost::str(boost::format(
"No space left in buffer. Unable to reserve (%1%) bytes.") % totalSize));
839 ((packetFamily & 0x0000003F) << 26) |
840 ((packetClass & 0x0000007F) << 19) |
841 ((packetType & 0x00000007) << 16));
850 offset += uint64_t_size;
851 for (
const auto& pair: values)
855 WriteUint32(writeBuffer, offset, pair.counterValue);
859 m_BufferManager.Commit(writeBuffer, totalSize);
863 const std::vector<uint16_t>& selectedCounterIds)
868 uint32_t packetFamily = 0;
869 uint32_t packetId = 4;
871 uint32_t bodySize = uint32_t_size + numeric_cast<uint32_t>(selectedCounterIds.size()) * uint16_t_size;
872 uint32_t totalSize = headerSize + bodySize;
874 uint32_t reserved = 0;
876 IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
878 if (writeBuffer ==
nullptr || reserved < totalSize)
880 CancelOperationAndThrow<BufferExhaustion>(
882 boost::str(boost::format(
"No space left in buffer. Unable to reserve (%1%) bytes.") % totalSize));
886 WriteUint32(writeBuffer, offset, ((packetFamily & 0x3F) << 26) | ((packetId & 0x3FF) << 16));
896 for(
const uint16_t&
id: selectedCounterIds)
902 m_BufferManager.Commit(writeBuffer, totalSize);
virtual const Devices & GetDevices() const =0
void SendPeriodicCounterSelectionPacket(uint32_t capturePeriod, const std::vector< uint16_t > &selectedCounterIds) override
Create and write a PeriodicCounterSelectionPacket from the parameters to the buffer.
std::unordered_set< CategoryPtr > Categories
std::string GetSoftwareVersion()
#define ARMNN_NO_CONVERSION_WARN_BEGIN
std::unordered_map< uint16_t, DevicePtr > Devices
std::unique_ptr< CounterSet > CounterSetPtr
void WriteUint64(const std::unique_ptr< IPacketBuffer > &packetBuffer, unsigned int offset, uint64_t value)
std::unordered_map< uint16_t, CounterSetPtr > CounterSets
void WriteUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint16_t value)
virtual uint16_t GetCategoryCount() const =0
bool CreateEventRecord(const CounterPtr &counter, EventRecord &eventRecord, std::string &errorMessage)
std::vector< uint32_t > EventRecord
virtual const Categories & GetCategories() const =0
std::unique_ptr< IPacketBuffer > IPacketBufferPtr
std::string GetSoftwareInfo()
static const unsigned int PIPE_MAGIC
std::string GetProcessName()
void SendCounterDirectoryPacket(const ICounterDirectory &counterDirectory) override
Create and write a CounterDirectoryPacket from the parameters to the buffer.
virtual uint16_t GetDeviceCount() const =0
virtual const CounterSets & GetCounterSets() const =0
std::string GetHardwareVersion()
constexpr uint32_t EncodeVersion(uint32_t major, uint32_t minor, uint32_t patch)
std::shared_ptr< Counter > CounterPtr
bool CreateDeviceRecord(const DevicePtr &device, DeviceRecord &deviceRecord, std::string &errorMessage)
std::unique_ptr< Category > CategoryPtr
void SendStreamMetaDataPacket() override
Create and write a StreamMetaDataPacket in the buffer.
virtual const Counters & GetCounters() const =0
virtual void Commit(IPacketBufferPtr &packetBuffer, unsigned int size, bool notifyConsumer=true)=0
std::vector< uint32_t > CounterSetRecord
std::unique_ptr< Device > DevicePtr
void SendPeriodicCounterCapturePacket(uint64_t timestamp, const IndexValuePairsVector &values) override
Create and write a PeriodicCounterCapturePacket from the parameters to the buffer.
std::vector< uint32_t > CategoryRecord
virtual IPacketBufferPtr Reserve(unsigned int requestedSize, unsigned int &reservedSize)=0
#define MAX_METADATA_PACKET_LENGTH
virtual uint16_t GetCounterSetCount() const =0
#define ARMNN_NO_CONVERSION_WARN_END
std::unordered_map< uint16_t, CounterPtr > Counters
bool CreateCounterSetRecord(const CounterSetPtr &counterSet, CounterSetRecord &counterSetRecord, std::string &errorMessage)
std::vector< uint32_t > DeviceRecord
std::vector< CounterValue > IndexValuePairsVector
void WriteUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint32_t value)
bool CreateCategoryRecord(const CategoryPtr &category, const Counters &counters, CategoryRecord &categoryRecord, std::string &errorMessage)