src/profiling/test/SendCounterPacketTests.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include "../SendCounterPacket.hpp"
   7 #include "../ProfilingUtils.hpp"
   8
   9 #include <armnn/Exceptions.hpp>
  10
  11 #include <boost/test/unit_test.hpp>
  12
  13 #include <chrono>
  14 #include <iostream>
  15
  16 BOOST_AUTO_TEST_SUITE(SendCounterPacketTests)
  17
  18 using namespace armnn::profiling;
  19
  20 class MockBuffer : public IBufferWrapper
  21 {
  22 public:
  23     MockBuffer(unsigned int size)
  24     : m_BufferSize(size),
  25       m_Buffer(std::make_unique<unsigned char[]>(size)) {}
  26
  27     unsigned char* Reserve(unsigned int requestedSize, unsigned int& reservedSize) override
  28     {
  29         if (requestedSize > m_BufferSize)
  30         {
  31             reservedSize = m_BufferSize;
  32         }
  33         else
  34         {
  35             reservedSize = requestedSize;
  36         }
  37
  38         return m_Buffer.get();
  39     }
  40
  41     void Commit(unsigned int size) override {}
  42
  43     const unsigned char* GetReadBuffer(unsigned int& size) override
  44     {
  45         size = static_cast<unsigned int>(strlen(reinterpret_cast<const char*>(m_Buffer.get())) + 1);
  46         return m_Buffer.get();
  47     }
  48
  49     void Release( unsigned int size) override {}
  50
  51 private:
  52     unsigned int m_BufferSize;
  53     std::unique_ptr<unsigned char[]> m_Buffer;
  54 };
  55
  56 class MockSendCounterPacket : public ISendCounterPacket
  57 {
  58 public:
  59     MockSendCounterPacket(IBufferWrapper& sendBuffer) : m_Buffer(sendBuffer) {}
  60
  61     void SendStreamMetaDataPacket() override
  62     {
  63         std::string message("SendStreamMetaDataPacket");
  64         unsigned int reserved = 0;
  65         unsigned char* buffer = m_Buffer.Reserve(1024, reserved);
  66         memcpy(buffer, message.c_str(), static_cast<unsigned int>(message.size()) + 1);
  67     }
  68
  69     void SendCounterDirectoryPacket(const Category& category, const std::vector<Counter>& counters) override
  70     {
  71         std::string message("SendCounterDirectoryPacket");
  72         unsigned int reserved = 0;
  73         unsigned char* buffer = m_Buffer.Reserve(1024, reserved);
  74         memcpy(buffer, message.c_str(), static_cast<unsigned int>(message.size()) + 1);
  75     }
  76
  77     void SendPeriodicCounterCapturePacket(uint64_t timestamp,
  78                                           const std::vector<std::pair<uint16_t, uint32_t>>& values) override
  79     {
  80         std::string message("SendPeriodicCounterCapturePacket");
  81         unsigned int reserved = 0;
  82         unsigned char* buffer = m_Buffer.Reserve(1024, reserved);
  83         memcpy(buffer, message.c_str(), static_cast<unsigned int>(message.size()) + 1);
  84     }
  85
  86     void SendPeriodicCounterSelectionPacket(uint32_t capturePeriod,
  87                                             const std::vector<uint16_t>& selectedCounterIds) override
  88     {
  89         std::string message("SendPeriodicCounterSelectionPacket");
  90         unsigned int reserved = 0;
  91         unsigned char* buffer = m_Buffer.Reserve(1024, reserved);
  92         memcpy(buffer, message.c_str(), static_cast<unsigned int>(message.size()) + 1);
  93         m_Buffer.Commit(reserved);
  94     }
  95
  96     void SetReadyToRead() override
  97     {}
  98
  99 private:
 100     IBufferWrapper& m_Buffer;
 101 };
 102
 103 BOOST_AUTO_TEST_CASE(MockSendCounterPacketTest)
 104 {
 105     unsigned int size = 0;
 106
 107     MockBuffer mockBuffer(512);
 108     MockSendCounterPacket sendCounterPacket(mockBuffer);
 109
 110     sendCounterPacket.SendStreamMetaDataPacket();
 111     const char* buffer = reinterpret_cast<const char*>(mockBuffer.GetReadBuffer(size));
 112
 113     BOOST_TEST(strcmp(buffer, "SendStreamMetaDataPacket") == 0);
 114
 115     Category category;
 116     std::vector<Counter> counters;
 117     sendCounterPacket.SendCounterDirectoryPacket(category, counters);
 118
 119     BOOST_TEST(strcmp(buffer, "SendCounterDirectoryPacket") == 0);
 120
 121     uint64_t timestamp = 0;
 122     std::vector<std::pair<uint16_t, uint32_t>> indexValuePairs;
 123
 124     sendCounterPacket.SendPeriodicCounterCapturePacket(timestamp, indexValuePairs);
 125
 126     BOOST_TEST(strcmp(buffer, "SendPeriodicCounterCapturePacket") == 0);
 127
 128     uint32_t capturePeriod = 0;
 129     std::vector<uint16_t> selectedCounterIds;
 130     sendCounterPacket.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds);
 131
 132     BOOST_TEST(strcmp(buffer, "SendPeriodicCounterSelectionPacket") == 0);
 133
 134 }
 135
 136 BOOST_AUTO_TEST_CASE(SendPeriodicCounterSelectionPacketTest)
 137 {
 138     // Error no space left in buffer
 139     MockBuffer mockBuffer1(10);
 140     SendCounterPacket sendPacket1(mockBuffer1);
 141
 142     uint32_t capturePeriod = 1000;
 143     std::vector<uint16_t> selectedCounterIds;
 144     BOOST_CHECK_THROW(sendPacket1.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds),
 145                       armnn::Exception);
 146
 147     // Packet without any counters
 148     MockBuffer mockBuffer2(512);
 149     SendCounterPacket sendPacket2(mockBuffer2);
 150
 151     sendPacket2.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds);
 152     unsigned int sizeRead = 0;
 153     const unsigned char* readBuffer2 = mockBuffer2.GetReadBuffer(sizeRead);
 154
 155     uint32_t headerWord0 = ReadUint32(readBuffer2, 0);
 156     uint32_t headerWord1 = ReadUint32(readBuffer2, 4);
 157     uint32_t period = ReadUint32(readBuffer2, 8);
 158
 159     BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);  // packet family
 160     BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
 161     BOOST_TEST(headerWord1 == 4);                   // data lenght
 162     BOOST_TEST(period == 1000);                     // capture period
 163
 164     // Full packet message
 165     MockBuffer mockBuffer3(512);
 166     SendCounterPacket sendPacket3(mockBuffer3);
 167
 168     selectedCounterIds.reserve(5);
 169     selectedCounterIds.emplace_back(100);
 170     selectedCounterIds.emplace_back(200);
 171     selectedCounterIds.emplace_back(300);
 172     selectedCounterIds.emplace_back(400);
 173     selectedCounterIds.emplace_back(500);
 174     sendPacket3.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds);
 175     sizeRead = 0;
 176     const unsigned char* readBuffer3 = mockBuffer3.GetReadBuffer(sizeRead);
 177
 178     headerWord0 = ReadUint32(readBuffer3, 0);
 179     headerWord1 = ReadUint32(readBuffer3, 4);
 180     period = ReadUint32(readBuffer3, 8);
 181
 182     BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);  // packet family
 183     BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
 184     BOOST_TEST(headerWord1 == 14);                  // data lenght
 185     BOOST_TEST(period == 1000);                     // capture period
 186
 187     uint16_t counterId = 0;
 188     uint32_t offset = 12;
 189
 190     // Counter Ids
 191     for(const uint16_t& id : selectedCounterIds)
 192     {
 193         counterId = ReadUint16(readBuffer3, offset);
 194         BOOST_TEST(counterId == id);
 195         offset += 2;
 196     }
 197 }
 198
 199 BOOST_AUTO_TEST_CASE(SendPeriodicCounterCapturePacketTest)
 200 {
 201     // Error no space left in buffer
 202     MockBuffer mockBuffer1(10);
 203     SendCounterPacket sendPacket1(mockBuffer1);
 204
 205     auto captureTimestamp = std::chrono::steady_clock::now();
 206     uint64_t time =  static_cast<uint64_t >(captureTimestamp.time_since_epoch().count());
 207     std::vector<std::pair<uint16_t, uint32_t>> indexValuePairs;
 208
 209     BOOST_CHECK_THROW(sendPacket1.SendPeriodicCounterCapturePacket(time, indexValuePairs),
 210                       BufferExhaustion);
 211
 212     // Packet without any counters
 213     MockBuffer mockBuffer2(512);
 214     SendCounterPacket sendPacket2(mockBuffer2);
 215
 216     sendPacket2.SendPeriodicCounterCapturePacket(time, indexValuePairs);
 217     unsigned int sizeRead = 0;
 218     const unsigned char* readBuffer2 = mockBuffer2.GetReadBuffer(sizeRead);
 219
 220     uint32_t headerWord0 = ReadUint32(readBuffer2, 0);
 221     uint32_t headerWord1 = ReadUint32(readBuffer2, 4);
 222     uint64_t readTimestamp = ReadUint64(readBuffer2, 8);
 223
 224     BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 1);   // packet family
 225     BOOST_TEST(((headerWord0 >> 19) & 0x3F) == 0);   // packet class
 226     BOOST_TEST(((headerWord0 >> 16) & 0x3) == 0);    // packet type
 227     BOOST_TEST(headerWord1 == 8);                    // data length
 228     BOOST_TEST(time == readTimestamp);               // capture period
 229
 230     // Full packet message
 231     MockBuffer mockBuffer3(512);
 232     SendCounterPacket sendPacket3(mockBuffer3);
 233
 234     indexValuePairs.reserve(5);
 235     indexValuePairs.emplace_back(std::make_pair<uint16_t, uint32_t >(0, 100));
 236     indexValuePairs.emplace_back(std::make_pair<uint16_t, uint32_t >(1, 200));
 237     indexValuePairs.emplace_back(std::make_pair<uint16_t, uint32_t >(2, 300));
 238     indexValuePairs.emplace_back(std::make_pair<uint16_t, uint32_t >(3, 400));
 239     indexValuePairs.emplace_back(std::make_pair<uint16_t, uint32_t >(4, 500));
 240     sendPacket3.SendPeriodicCounterCapturePacket(time, indexValuePairs);
 241     sizeRead = 0;
 242     const unsigned char* readBuffer3 = mockBuffer3.GetReadBuffer(sizeRead);
 243
 244     headerWord0 = ReadUint32(readBuffer3, 0);
 245     headerWord1 = ReadUint32(readBuffer3, 4);
 246     uint64_t readTimestamp2 = ReadUint64(readBuffer3, 8);
 247
 248     BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 1);   // packet family
 249     BOOST_TEST(((headerWord0 >> 19) & 0x3F) == 0);   // packet class
 250     BOOST_TEST(((headerWord0 >> 16) & 0x3) == 0);    // packet type
 251     BOOST_TEST(headerWord1 == 38);                   // data length
 252     BOOST_TEST(time == readTimestamp2);              // capture period
 253
 254     uint16_t counterIndex = 0;
 255     uint32_t counterValue = 100;
 256     uint32_t offset = 16;
 257
 258     // Counter Ids
 259     for (auto it = indexValuePairs.begin(), end = indexValuePairs.end(); it != end; ++it)
 260     {
 261         // Check Counter Index
 262         uint16_t readIndex = ReadUint16(readBuffer3, offset);
 263         BOOST_TEST(counterIndex == readIndex);
 264         counterIndex++;
 265         offset += 2;
 266
 267         // Check Counter Value
 268         uint32_t readValue = ReadUint32(readBuffer3, offset);
 269         BOOST_TEST(counterValue == readValue);
 270         counterValue += 100;
 271         offset += 4;
 272     }
 273
 274 }
 275
 276 BOOST_AUTO_TEST_SUITE_END()