ArmNN
 20.02
Typedefs | Functions
SendCounterPacketTests.cpp File Reference
#include "ProfilingMocks.hpp"
#include "SendCounterPacketTests.hpp"
#include <BufferManager.hpp>
#include <CounterDirectory.hpp>
#include <EncodeVersion.hpp>
#include <ProfilingUtils.hpp>
#include <SendCounterPacket.hpp>
#include <Processes.hpp>
#include <armnn/Exceptions.hpp>
#include <armnn/Conversion.hpp>
#include <armnn/Utils.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <chrono>

Go to the source code of this file.

Typedefs

using PacketType = MockProfilingConnection::PacketType
 

Functions

 BOOST_AUTO_TEST_CASE (MockSendCounterPacketTest)
 
 BOOST_AUTO_TEST_CASE (SendPeriodicCounterSelectionPacketTest)
 
 BOOST_AUTO_TEST_CASE (SendPeriodicCounterCapturePacketTest)
 
 BOOST_AUTO_TEST_CASE (SendStreamMetaDataPacketTest)
 
 BOOST_AUTO_TEST_CASE (CreateDeviceRecordTest)
 
 BOOST_AUTO_TEST_CASE (CreateInvalidDeviceRecordTest)
 
 BOOST_AUTO_TEST_CASE (CreateCounterSetRecordTest)
 
 BOOST_AUTO_TEST_CASE (CreateInvalidCounterSetRecordTest)
 
 BOOST_AUTO_TEST_CASE (CreateEventRecordTest)
 
 BOOST_AUTO_TEST_CASE (CreateEventRecordNoUnitsTest)
 
 BOOST_AUTO_TEST_CASE (CreateInvalidEventRecordTest1)
 
 BOOST_AUTO_TEST_CASE (CreateInvalidEventRecordTest2)
 
 BOOST_AUTO_TEST_CASE (CreateInvalidEventRecordTest3)
 
 BOOST_AUTO_TEST_CASE (CreateCategoryRecordTest)
 
 BOOST_AUTO_TEST_CASE (CreateInvalidCategoryRecordTest1)
 
 BOOST_AUTO_TEST_CASE (CreateInvalidCategoryRecordTest2)
 
 BOOST_AUTO_TEST_CASE (SendCounterDirectoryPacketTest1)
 
 BOOST_AUTO_TEST_CASE (SendCounterDirectoryPacketTest2)
 
 BOOST_AUTO_TEST_CASE (SendCounterDirectoryPacketTest3)
 
 BOOST_AUTO_TEST_CASE (SendCounterDirectoryPacketTest4)
 
 BOOST_AUTO_TEST_CASE (SendCounterDirectoryPacketTest5)
 
 BOOST_AUTO_TEST_CASE (SendCounterDirectoryPacketTest6)
 
 BOOST_AUTO_TEST_CASE (SendCounterDirectoryPacketTest7)
 
 BOOST_AUTO_TEST_CASE (SendThreadTest0)
 
 BOOST_AUTO_TEST_CASE (SendThreadTest1)
 
 BOOST_AUTO_TEST_CASE (SendThreadTest2)
 
 BOOST_AUTO_TEST_CASE (SendThreadTest3)
 
 BOOST_AUTO_TEST_CASE (SendCounterPacketTestWithSendThread)
 
 BOOST_AUTO_TEST_CASE (SendThreadBufferTest)
 
 BOOST_AUTO_TEST_CASE (SendThreadSendStreamMetadataPacket1)
 
 BOOST_AUTO_TEST_CASE (SendThreadSendStreamMetadataPacket2)
 
 BOOST_AUTO_TEST_CASE (SendThreadSendStreamMetadataPacket3)
 
 BOOST_AUTO_TEST_CASE (SendThreadSendStreamMetadataPacket4)
 

Typedef Documentation

◆ PacketType

using PacketType = MockProfilingConnection::PacketType

Definition at line 98 of file SendCounterPacketTests.cpp.

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/33]

BOOST_AUTO_TEST_CASE ( MockSendCounterPacketTest  )

Definition at line 100 of file SendCounterPacketTests.cpp.

References MockBufferManager::GetReadableBuffer(), MockBufferManager::MarkRead(), MockSendCounterPacket::SendCounterDirectoryPacket(), MockSendCounterPacket::SendPeriodicCounterCapturePacket(), MockSendCounterPacket::SendPeriodicCounterSelectionPacket(), and MockSendCounterPacket::SendStreamMetaDataPacket().

101 {
102  MockBufferManager mockBuffer(512);
103  MockSendCounterPacket mockSendCounterPacket(mockBuffer);
104 
105  mockSendCounterPacket.SendStreamMetaDataPacket();
106 
107  auto packetBuffer = mockBuffer.GetReadableBuffer();
108  const char* buffer = reinterpret_cast<const char*>(packetBuffer->GetReadableData());
109 
110  BOOST_TEST(strcmp(buffer, "SendStreamMetaDataPacket") == 0);
111 
112  mockBuffer.MarkRead(packetBuffer);
113 
114  CounterDirectory counterDirectory;
115  mockSendCounterPacket.SendCounterDirectoryPacket(counterDirectory);
116 
117  packetBuffer = mockBuffer.GetReadableBuffer();
118  buffer = reinterpret_cast<const char*>(packetBuffer->GetReadableData());
119 
120  BOOST_TEST(strcmp(buffer, "SendCounterDirectoryPacket") == 0);
121 
122  mockBuffer.MarkRead(packetBuffer);
123 
124  uint64_t timestamp = 0;
125  std::vector<CounterValue> indexValuePairs;
126 
127  mockSendCounterPacket.SendPeriodicCounterCapturePacket(timestamp, indexValuePairs);
128 
129  packetBuffer = mockBuffer.GetReadableBuffer();
130  buffer = reinterpret_cast<const char*>(packetBuffer->GetReadableData());
131 
132  BOOST_TEST(strcmp(buffer, "SendPeriodicCounterCapturePacket") == 0);
133 
134  mockBuffer.MarkRead(packetBuffer);
135 
136  uint32_t capturePeriod = 0;
137  std::vector<uint16_t> selectedCounterIds;
138  mockSendCounterPacket.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds);
139 
140  packetBuffer = mockBuffer.GetReadableBuffer();
141  buffer = reinterpret_cast<const char*>(packetBuffer->GetReadableData());
142 
143  BOOST_TEST(strcmp(buffer, "SendPeriodicCounterSelectionPacket") == 0);
144 
145  mockBuffer.MarkRead(packetBuffer);
146 }

◆ BOOST_AUTO_TEST_CASE() [2/33]

BOOST_AUTO_TEST_CASE ( SendPeriodicCounterSelectionPacketTest  )

Definition at line 148 of file SendCounterPacketTests.cpp.

References MockBufferManager::GetReadableBuffer(), armnn::profiling::ReadUint16(), armnn::profiling::ReadUint32(), and SendCounterPacket::SendPeriodicCounterSelectionPacket().

149 {
150  // Error no space left in buffer
151  MockBufferManager mockBuffer1(10);
152  SendCounterPacket sendPacket1(mockBuffer1);
153 
154  uint32_t capturePeriod = 1000;
155  std::vector<uint16_t> selectedCounterIds;
156  BOOST_CHECK_THROW(sendPacket1.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds),
157  BufferExhaustion);
158 
159  // Packet without any counters
160  MockBufferManager mockBuffer2(512);
161  SendCounterPacket sendPacket2(mockBuffer2);
162 
163  sendPacket2.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds);
164  auto readBuffer2 = mockBuffer2.GetReadableBuffer();
165 
166  uint32_t headerWord0 = ReadUint32(readBuffer2, 0);
167  uint32_t headerWord1 = ReadUint32(readBuffer2, 4);
168  uint32_t period = ReadUint32(readBuffer2, 8);
169 
170  BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0); // packet family
171  BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
172  BOOST_TEST(headerWord1 == 4); // data lenght
173  BOOST_TEST(period == 1000); // capture period
174 
175  // Full packet message
176  MockBufferManager mockBuffer3(512);
177  SendCounterPacket sendPacket3(mockBuffer3);
178 
179  selectedCounterIds.reserve(5);
180  selectedCounterIds.emplace_back(100);
181  selectedCounterIds.emplace_back(200);
182  selectedCounterIds.emplace_back(300);
183  selectedCounterIds.emplace_back(400);
184  selectedCounterIds.emplace_back(500);
185  sendPacket3.SendPeriodicCounterSelectionPacket(capturePeriod, selectedCounterIds);
186  auto readBuffer3 = mockBuffer3.GetReadableBuffer();
187 
188  headerWord0 = ReadUint32(readBuffer3, 0);
189  headerWord1 = ReadUint32(readBuffer3, 4);
190  period = ReadUint32(readBuffer3, 8);
191 
192  BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0); // packet family
193  BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
194  BOOST_TEST(headerWord1 == 14); // data lenght
195  BOOST_TEST(period == 1000); // capture period
196 
197  uint16_t counterId = 0;
198  uint32_t offset = 12;
199 
200  // Counter Ids
201  for(const uint16_t& id : selectedCounterIds)
202  {
203  counterId = ReadUint16(readBuffer3, offset);
204  BOOST_TEST(counterId == id);
205  offset += 2;
206  }
207 }
armnn::profiling::ReadUint16
uint16_t ReadUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset)
Definition: ProfilingUtils.cpp:211
armnn::profiling::ReadUint32
uint32_t ReadUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset)
Definition: ProfilingUtils.cpp:204

◆ BOOST_AUTO_TEST_CASE() [3/33]

BOOST_AUTO_TEST_CASE ( SendPeriodicCounterCapturePacketTest  )

Definition at line 209 of file SendCounterPacketTests.cpp.

References MockBufferManager::GetReadableBuffer(), armnn::profiling::ReadUint16(), armnn::profiling::ReadUint32(), armnn::profiling::ReadUint64(), and SendCounterPacket::SendPeriodicCounterCapturePacket().

210 {
211  ProfilingStateMachine profilingStateMachine;
212 
213  // Error no space left in buffer
214  MockBufferManager mockBuffer1(10);
215  SendCounterPacket sendPacket1(mockBuffer1);
216 
217  auto captureTimestamp = std::chrono::steady_clock::now();
218  uint64_t time = static_cast<uint64_t >(captureTimestamp.time_since_epoch().count());
219  std::vector<CounterValue> indexValuePairs;
220 
221  BOOST_CHECK_THROW(sendPacket1.SendPeriodicCounterCapturePacket(time, indexValuePairs),
222  BufferExhaustion);
223 
224  // Packet without any counters
225  MockBufferManager mockBuffer2(512);
226  SendCounterPacket sendPacket2(mockBuffer2);
227 
228  sendPacket2.SendPeriodicCounterCapturePacket(time, indexValuePairs);
229  auto readBuffer2 = mockBuffer2.GetReadableBuffer();
230 
231  uint32_t headerWord0 = ReadUint32(readBuffer2, 0);
232  uint32_t headerWord1 = ReadUint32(readBuffer2, 4);
233  uint64_t readTimestamp = ReadUint64(readBuffer2, 8);
234 
235  BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 3); // packet family
236  BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0); // packet class
237  BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0); // packet type
238  BOOST_TEST(headerWord1 == 8); // data length
239  BOOST_TEST(time == readTimestamp); // capture period
240 
241  // Full packet message
242  MockBufferManager mockBuffer3(512);
243  SendCounterPacket sendPacket3(mockBuffer3);
244 
245  indexValuePairs.reserve(5);
246  indexValuePairs.emplace_back(CounterValue{0, 100});
247  indexValuePairs.emplace_back(CounterValue{1, 200});
248  indexValuePairs.emplace_back(CounterValue{2, 300});
249  indexValuePairs.emplace_back(CounterValue{3, 400});
250  indexValuePairs.emplace_back(CounterValue{4, 500});
251  sendPacket3.SendPeriodicCounterCapturePacket(time, indexValuePairs);
252  auto readBuffer3 = mockBuffer3.GetReadableBuffer();
253 
254  headerWord0 = ReadUint32(readBuffer3, 0);
255  headerWord1 = ReadUint32(readBuffer3, 4);
256  uint64_t readTimestamp2 = ReadUint64(readBuffer3, 8);
257 
258  BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 3); // packet family
259  BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0); // packet class
260  BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0); // packet type
261  BOOST_TEST(headerWord1 == 38); // data length
262  BOOST_TEST(time == readTimestamp2); // capture period
263 
264  uint16_t counterIndex = 0;
265  uint32_t counterValue = 100;
266  uint32_t offset = 16;
267 
268  // Counter Ids
269  for (auto it = indexValuePairs.begin(), end = indexValuePairs.end(); it != end; ++it)
270  {
271  // Check Counter Index
272  uint16_t readIndex = ReadUint16(readBuffer3, offset);
273  BOOST_TEST(counterIndex == readIndex);
274  counterIndex++;
275  offset += 2;
276 
277  // Check Counter Value
278  uint32_t readValue = ReadUint32(readBuffer3, offset);
279  BOOST_TEST(counterValue == readValue);
280  counterValue += 100;
281  offset += 4;
282  }
283 
284 }
armnn::profiling::ReadUint64
uint64_t ReadUint64(const IPacketBufferPtr &packetBuffer, unsigned int offset)
Definition: ProfilingUtils.cpp:197
armnn::profiling::ReadUint16
uint16_t ReadUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset)
Definition: ProfilingUtils.cpp:211
armnn::profiling::ReadUint32
uint32_t ReadUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset)
Definition: ProfilingUtils.cpp:204

◆ BOOST_AUTO_TEST_CASE() [4/33]

BOOST_AUTO_TEST_CASE ( SendStreamMetaDataPacketTest  )

Definition at line 286 of file SendCounterPacketTests.cpp.

References armnn::profiling::EncodeVersion(), armnnUtils::Processes::GetCurrentId(), armnn::profiling::GetHardwareVersion(), armnn::profiling::GetProcessName(), MockBufferManager::GetReadableBuffer(), armnn::profiling::GetSoftwareInfo(), armnn::profiling::GetSoftwareVersion(), MAX_METADATA_PACKET_LENGTH, armnn::numeric_cast(), SendCounterPacket::PIPE_MAGIC, armnn::profiling::ReadUint32(), and SendCounterPacket::SendStreamMetaDataPacket().

287 {
288  using boost::numeric_cast;
289 
290  uint32_t sizeUint32 = numeric_cast<uint32_t>(sizeof(uint32_t));
291 
292  // Error no space left in buffer
293  MockBufferManager mockBuffer1(10);
294  SendCounterPacket sendPacket1(mockBuffer1);
295  BOOST_CHECK_THROW(sendPacket1.SendStreamMetaDataPacket(), armnn::profiling::BufferExhaustion);
296 
297  // Full metadata packet
298 
299  std::string processName = GetProcessName().substr(0, 60);
300 
301  uint32_t infoSize = numeric_cast<uint32_t>(GetSoftwareInfo().size()) > 0 ?
302  numeric_cast<uint32_t>(GetSoftwareInfo().size()) + 1 : 0;
303  uint32_t hardwareVersionSize = numeric_cast<uint32_t>(GetHardwareVersion().size()) > 0 ?
304  numeric_cast<uint32_t>(GetHardwareVersion().size()) + 1 : 0;
305  uint32_t softwareVersionSize = numeric_cast<uint32_t>(GetSoftwareVersion().size()) > 0 ?
306  numeric_cast<uint32_t>(GetSoftwareVersion().size()) + 1 : 0;
307  uint32_t processNameSize = numeric_cast<uint32_t>(processName.size()) > 0 ?
308  numeric_cast<uint32_t>(processName.size()) + 1 : 0;
309 
310  uint32_t packetEntries = 6;
311 
312  MockBufferManager mockBuffer2(512);
313  SendCounterPacket sendPacket2(mockBuffer2);
314  sendPacket2.SendStreamMetaDataPacket();
315  auto readBuffer2 = mockBuffer2.GetReadableBuffer();
316 
317  uint32_t headerWord0 = ReadUint32(readBuffer2, 0);
318  uint32_t headerWord1 = ReadUint32(readBuffer2, sizeUint32);
319 
320  BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0); // packet family
321  BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 0); // packet id
322 
323  uint32_t totalLength = numeric_cast<uint32_t>(2 * sizeUint32 + 10 * sizeUint32 + infoSize + hardwareVersionSize +
324  softwareVersionSize + processNameSize + sizeUint32 +
325  2 * packetEntries * sizeUint32);
326 
327  BOOST_TEST(headerWord1 == totalLength - (2 * sizeUint32)); // data length
328 
329  uint32_t offset = sizeUint32 * 2;
330  BOOST_TEST(ReadUint32(readBuffer2, offset) == SendCounterPacket::PIPE_MAGIC); // pipe_magic
331  offset += sizeUint32;
332  BOOST_TEST(ReadUint32(readBuffer2, offset) == EncodeVersion(1, 0, 0)); // stream_metadata_version
333  offset += sizeUint32;
334  BOOST_TEST(ReadUint32(readBuffer2, offset) == MAX_METADATA_PACKET_LENGTH); // max_data_len
335  offset += sizeUint32;
336  int pid = armnnUtils::Processes::GetCurrentId();
337  BOOST_TEST(ReadUint32(readBuffer2, offset) == numeric_cast<uint32_t>(pid));
338  offset += sizeUint32;
339  uint32_t poolOffset = 10 * sizeUint32;
340  BOOST_TEST(ReadUint32(readBuffer2, offset) == (infoSize ? poolOffset : 0)); // offset_info
341  offset += sizeUint32;
342  poolOffset += infoSize;
343  BOOST_TEST(ReadUint32(readBuffer2, offset) == (hardwareVersionSize ? poolOffset : 0)); // offset_hw_version
344  offset += sizeUint32;
345  poolOffset += hardwareVersionSize;
346  BOOST_TEST(ReadUint32(readBuffer2, offset) == (softwareVersionSize ? poolOffset : 0)); // offset_sw_version
347  offset += sizeUint32;
348  poolOffset += softwareVersionSize;
349  BOOST_TEST(ReadUint32(readBuffer2, offset) == (processNameSize ? poolOffset : 0)); // offset_process_name
350  offset += sizeUint32;
351  poolOffset += processNameSize;
352  BOOST_TEST(ReadUint32(readBuffer2, offset) == (packetEntries ? poolOffset : 0)); // offset_packet_version_table
353  offset += sizeUint32;
354  BOOST_TEST(ReadUint32(readBuffer2, offset) == 0); // reserved
355 
356  const unsigned char* readData2 = readBuffer2->GetReadableData();
357 
358  offset += sizeUint32;
359  if (infoSize)
360  {
361  BOOST_TEST(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetSoftwareInfo().c_str()) == 0);
362  offset += infoSize;
363  }
364 
365  if (hardwareVersionSize)
366  {
367  BOOST_TEST(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetHardwareVersion().c_str()) == 0);
368  offset += hardwareVersionSize;
369  }
370 
371  if (softwareVersionSize)
372  {
373  BOOST_TEST(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetSoftwareVersion().c_str()) == 0);
374  offset += softwareVersionSize;
375  }
376 
377  if (processNameSize)
378  {
379  BOOST_TEST(strcmp(reinterpret_cast<const char *>(&readData2[offset]), GetProcessName().c_str()) == 0);
380  offset += processNameSize;
381  }
382 
383  if (packetEntries)
384  {
385  BOOST_TEST((ReadUint32(readBuffer2, offset) >> 16) == packetEntries);
386  offset += sizeUint32;
387  for (uint32_t i = 0; i < packetEntries - 1; ++i)
388  {
389  BOOST_TEST(((ReadUint32(readBuffer2, offset) >> 26) & 0x3F) == 0);
390  BOOST_TEST(((ReadUint32(readBuffer2, offset) >> 16) & 0x3FF) == i);
391  offset += sizeUint32;
392  BOOST_TEST(ReadUint32(readBuffer2, offset) == EncodeVersion(1, 0, 0));
393  offset += sizeUint32;
394  }
395 
396  BOOST_TEST(((ReadUint32(readBuffer2, offset) >> 26) & 0x3F) == 1);
397  BOOST_TEST(((ReadUint32(readBuffer2, offset) >> 16) & 0x3FF) == 0);
398  offset += sizeUint32;
399  BOOST_TEST(ReadUint32(readBuffer2, offset) == EncodeVersion(1, 0, 0));
400  offset += sizeUint32;
401  }
402 
403  BOOST_TEST(offset == totalLength);
404 }
armnn::profiling::GetHardwareVersion
std::string GetHardwareVersion()
Definition: ProfilingUtils.cpp:287
armnn::profiling::GetProcessName
std::string GetProcessName()
Definition: ProfilingUtils.cpp:299
armnn::profiling::GetSoftwareInfo
std::string GetSoftwareInfo()
Definition: ProfilingUtils.cpp:282
armnn::profiling::EncodeVersion
constexpr uint32_t EncodeVersion(uint32_t major, uint32_t minor, uint32_t patch)
Definition: EncodeVersion.hpp:18
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33
MAX_METADATA_PACKET_LENGTH
#define MAX_METADATA_PACKET_LENGTH
Definition: IBufferManager.hpp:13
armnn::profiling::ReadUint32
uint32_t ReadUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset)
Definition: ProfilingUtils.cpp:204
armnn::profiling::GetSoftwareVersion
std::string GetSoftwareVersion()
Definition: ProfilingUtils.cpp:292

◆ BOOST_AUTO_TEST_CASE() [5/33]

BOOST_AUTO_TEST_CASE ( CreateDeviceRecordTest  )

Definition at line 406 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), and SendCounterPacketTest::CreateDeviceRecordTest().

407 {
408  MockBufferManager mockBuffer(0);
409  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
410 
411  // Create a device for testing
412  uint16_t deviceUid = 27;
413  const std::string deviceName = "some_device";
414  uint16_t deviceCores = 3;
415  const DevicePtr device = std::make_unique<Device>(deviceUid, deviceName, deviceCores);
416 
417  // Create a device record
418  SendCounterPacket::DeviceRecord deviceRecord;
419  std::string errorMessage;
420  bool result = sendCounterPacketTest.CreateDeviceRecordTest(device, deviceRecord, errorMessage);
421 
422  BOOST_CHECK(result);
423  BOOST_CHECK(errorMessage.empty());
424  BOOST_CHECK(deviceRecord.size() == 6); // Size in words: header [2] + device name [4]
425 
426  uint16_t deviceRecordWord0[]
427  {
428  static_cast<uint16_t>(deviceRecord[0] >> 16),
429  static_cast<uint16_t>(deviceRecord[0])
430  };
431  BOOST_CHECK(deviceRecordWord0[0] == deviceUid); // uid
432  BOOST_CHECK(deviceRecordWord0[1] == deviceCores); // cores
433  BOOST_CHECK(deviceRecord[1] == 0); // name_offset
434  BOOST_CHECK(deviceRecord[2] == deviceName.size() + 1); // The length of the SWTrace string (name)
435  BOOST_CHECK(std::memcmp(deviceRecord.data() + 3, deviceName.data(), deviceName.size()) == 0); // name
436 }
armnn::profiling::DevicePtr
std::unique_ptr< Device > DevicePtr
Definition: ICounterDirectory.hpp:32
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)

◆ BOOST_AUTO_TEST_CASE() [6/33]

BOOST_AUTO_TEST_CASE ( CreateInvalidDeviceRecordTest  )

Definition at line 438 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), and SendCounterPacketTest::CreateDeviceRecordTest().

439 {
440  MockBufferManager mockBuffer(0);
441  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
442 
443  // Create a device for testing
444  uint16_t deviceUid = 27;
445  const std::string deviceName = "some€£invalid‡device";
446  uint16_t deviceCores = 3;
447  const DevicePtr device = std::make_unique<Device>(deviceUid, deviceName, deviceCores);
448 
449  // Create a device record
450  SendCounterPacket::DeviceRecord deviceRecord;
451  std::string errorMessage;
452  bool result = sendCounterPacketTest.CreateDeviceRecordTest(device, deviceRecord, errorMessage);
453 
454  BOOST_CHECK(!result);
455  BOOST_CHECK(!errorMessage.empty());
456  BOOST_CHECK(deviceRecord.empty());
457 }
armnn::profiling::DevicePtr
std::unique_ptr< Device > DevicePtr
Definition: ICounterDirectory.hpp:32
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)

◆ BOOST_AUTO_TEST_CASE() [7/33]

BOOST_AUTO_TEST_CASE ( CreateCounterSetRecordTest  )

Definition at line 459 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), and SendCounterPacketTest::CreateCounterSetRecordTest().

460 {
461  MockBufferManager mockBuffer(0);
462  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
463 
464  // Create a counter set for testing
465  uint16_t counterSetUid = 27;
466  const std::string counterSetName = "some_counter_set";
467  uint16_t counterSetCount = 3421;
468  const CounterSetPtr counterSet = std::make_unique<CounterSet>(counterSetUid, counterSetName, counterSetCount);
469 
470  // Create a counter set record
471  SendCounterPacket::CounterSetRecord counterSetRecord;
472  std::string errorMessage;
473  bool result = sendCounterPacketTest.CreateCounterSetRecordTest(counterSet, counterSetRecord, errorMessage);
474 
475  BOOST_CHECK(result);
476  BOOST_CHECK(errorMessage.empty());
477  BOOST_CHECK(counterSetRecord.size() == 8); // Size in words: header [2] + counter set name [6]
478 
479  uint16_t counterSetRecordWord0[]
480  {
481  static_cast<uint16_t>(counterSetRecord[0] >> 16),
482  static_cast<uint16_t>(counterSetRecord[0])
483  };
484  BOOST_CHECK(counterSetRecordWord0[0] == counterSetUid); // uid
485  BOOST_CHECK(counterSetRecordWord0[1] == counterSetCount); // cores
486  BOOST_CHECK(counterSetRecord[1] == 0); // name_offset
487  BOOST_CHECK(counterSetRecord[2] == counterSetName.size() + 1); // The length of the SWTrace string (name)
488  BOOST_CHECK(std::memcmp(counterSetRecord.data() + 3, counterSetName.data(), counterSetName.size()) == 0); // name
489 }
armnn::profiling::SendCounterPacket::CounterSetRecord
std::vector< uint32_t > CounterSetRecord
Definition: SendCounterPacket.hpp:26
armnn::profiling::CounterSetPtr
std::unique_ptr< CounterSet > CounterSetPtr
Definition: ICounterDirectory.hpp:33
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)

◆ BOOST_AUTO_TEST_CASE() [8/33]

BOOST_AUTO_TEST_CASE ( CreateInvalidCounterSetRecordTest  )

Definition at line 491 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), and SendCounterPacketTest::CreateCounterSetRecordTest().

492 {
493  MockBufferManager mockBuffer(0);
494  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
495 
496  // Create a counter set for testing
497  uint16_t counterSetUid = 27;
498  const std::string counterSetName = "some invalid_counter€£set";
499  uint16_t counterSetCount = 3421;
500  const CounterSetPtr counterSet = std::make_unique<CounterSet>(counterSetUid, counterSetName, counterSetCount);
501 
502  // Create a counter set record
503  SendCounterPacket::CounterSetRecord counterSetRecord;
504  std::string errorMessage;
505  bool result = sendCounterPacketTest.CreateCounterSetRecordTest(counterSet, counterSetRecord, errorMessage);
506 
507  BOOST_CHECK(!result);
508  BOOST_CHECK(!errorMessage.empty());
509  BOOST_CHECK(counterSetRecord.empty());
510 }
armnn::profiling::SendCounterPacket::CounterSetRecord
std::vector< uint32_t > CounterSetRecord
Definition: SendCounterPacket.hpp:26
armnn::profiling::CounterSetPtr
std::unique_ptr< CounterSet > CounterSetPtr
Definition: ICounterDirectory.hpp:33
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)

◆ BOOST_AUTO_TEST_CASE() [9/33]

BOOST_AUTO_TEST_CASE ( CreateEventRecordTest  )

Definition at line 512 of file SendCounterPacketTests.cpp.

References ARMNN_NO_CONVERSION_WARN_BEGIN, ARMNN_NO_CONVERSION_WARN_END, BOOST_CHECK(), SendCounterPacketTest::CreateEventRecordTest(), and armnn::profiling::uint32_t_size.

513 {
514  MockBufferManager mockBuffer(0);
515  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
516 
517  // Create a counter for testing
518  uint16_t counterUid = 7256;
519  uint16_t maxCounterUid = 132;
520  uint16_t deviceUid = 132;
521  uint16_t counterSetUid = 4497;
522  uint16_t counterClass = 1;
523  uint16_t counterInterpolation = 1;
524  double counterMultiplier = 1234.567f;
525  const std::string counterName = "some_valid_counter";
526  const std::string counterDescription = "a_counter_for_testing";
527  const std::string counterUnits = "Mrads2";
528  const CounterPtr counter = std::make_unique<Counter>(armnn::profiling::BACKEND_ID,
529  counterUid,
530  maxCounterUid,
531  counterClass,
532  counterInterpolation,
533  counterMultiplier,
534  counterName,
535  counterDescription,
536  counterUnits,
537  deviceUid,
538  counterSetUid);
539  BOOST_ASSERT(counter);
540 
541  // Create an event record
542  SendCounterPacket::EventRecord eventRecord;
543  std::string errorMessage;
544  bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
545 
546  BOOST_CHECK(result);
547  BOOST_CHECK(errorMessage.empty());
548  BOOST_CHECK(eventRecord.size() == 24); // Size in words: header [8] + counter name [6] + description [7] + units [3]
549 
550  uint16_t eventRecordWord0[]
551  {
552  static_cast<uint16_t>(eventRecord[0] >> 16),
553  static_cast<uint16_t>(eventRecord[0])
554  };
555  uint16_t eventRecordWord1[]
556  {
557  static_cast<uint16_t>(eventRecord[1] >> 16),
558  static_cast<uint16_t>(eventRecord[1])
559  };
560  uint16_t eventRecordWord2[]
561  {
562  static_cast<uint16_t>(eventRecord[2] >> 16),
563  static_cast<uint16_t>(eventRecord[2])
564  };
565  uint32_t eventRecordWord34[]
566  {
567  eventRecord[3],
568  eventRecord[4]
569  };
570  BOOST_CHECK(eventRecordWord0[0] == maxCounterUid); // max_counter_uid
571  BOOST_CHECK(eventRecordWord0[1] == counterUid); // counter_uid
572  BOOST_CHECK(eventRecordWord1[0] == deviceUid); // device
573  BOOST_CHECK(eventRecordWord1[1] == counterSetUid); // counter_set
574  BOOST_CHECK(eventRecordWord2[0] == counterClass); // class
575  BOOST_CHECK(eventRecordWord2[1] == counterInterpolation); // interpolation
576  BOOST_CHECK(std::memcmp(eventRecordWord34, &counterMultiplier, sizeof(counterMultiplier)) == 0); // multiplier
577 
578  ARMNN_NO_CONVERSION_WARN_BEGIN
579  uint32_t counterNameOffset = 0; // The name is the first item in pool
580  uint32_t counterDescriptionOffset = counterNameOffset + // Counter name offset
581  4u + // Counter name length (uint32_t)
582  counterName.size() + // 18u
583  1u + // Null-terminator
584  1u; // Rounding to the next word
585  size_t counterUnitsOffset = counterDescriptionOffset + // Counter description offset
586  4u + // Counter description length (uint32_t)
587  counterDescription.size() + // 21u
588  1u + // Null-terminator
589  2u; // Rounding to the next word
590  ARMNN_NO_CONVERSION_WARN_END
591 
592  BOOST_CHECK(eventRecord[5] == counterNameOffset); // name_offset
593  BOOST_CHECK(eventRecord[6] == counterDescriptionOffset); // description_offset
594  BOOST_CHECK(eventRecord[7] == counterUnitsOffset); // units_offset
595 
596  auto eventRecordPool = reinterpret_cast<unsigned char*>(eventRecord.data() + 8u); // The start of the pool
597  size_t uint32_t_size = sizeof(uint32_t);
598 
599  // The length of the SWTrace string (name)
600  BOOST_CHECK(eventRecordPool[counterNameOffset] == counterName.size() + 1);
601  // The counter name
602  BOOST_CHECK(std::memcmp(eventRecordPool +
603  counterNameOffset + // Offset
604  uint32_t_size /* The length of the name */,
605  counterName.data(),
606  counterName.size()) == 0); // name
607  // The null-terminator at the end of the name
608  BOOST_CHECK(eventRecordPool[counterNameOffset + uint32_t_size + counterName.size()] == '\0');
609 
610  // The length of the SWTrace string (description)
611  BOOST_CHECK(eventRecordPool[counterDescriptionOffset] == counterDescription.size() + 1);
612  // The counter description
613  BOOST_CHECK(std::memcmp(eventRecordPool +
614  counterDescriptionOffset + // Offset
615  uint32_t_size /* The length of the description */,
616  counterDescription.data(),
617  counterDescription.size()) == 0); // description
618  // The null-terminator at the end of the description
619  BOOST_CHECK(eventRecordPool[counterDescriptionOffset + uint32_t_size + counterDescription.size()] == '\0');
620 
621  // The length of the SWTrace namestring (units)
622  BOOST_CHECK(eventRecordPool[counterUnitsOffset] == counterUnits.size() + 1);
623  // The counter units
624  BOOST_CHECK(std::memcmp(eventRecordPool +
625  counterUnitsOffset + // Offset
626  uint32_t_size /* The length of the units */,
627  counterUnits.data(),
628  counterUnits.size()) == 0); // units
629  // The null-terminator at the end of the units
630  BOOST_CHECK(eventRecordPool[counterUnitsOffset + uint32_t_size + counterUnits.size()] == '\0');
631 }
ARMNN_NO_CONVERSION_WARN_END
#define ARMNN_NO_CONVERSION_WARN_END
Definition: Conversion.hpp:37
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::CounterPtr
std::shared_ptr< Counter > CounterPtr
Definition: ICounterDirectory.hpp:34
ARMNN_NO_CONVERSION_WARN_BEGIN
#define ARMNN_NO_CONVERSION_WARN_BEGIN
Definition: Conversion.hpp:36

◆ BOOST_AUTO_TEST_CASE() [10/33]

BOOST_AUTO_TEST_CASE ( CreateEventRecordNoUnitsTest  )

Definition at line 633 of file SendCounterPacketTests.cpp.

References ARMNN_NO_CONVERSION_WARN_BEGIN, ARMNN_NO_CONVERSION_WARN_END, BOOST_CHECK(), SendCounterPacketTest::CreateEventRecordTest(), and armnn::profiling::uint32_t_size.

634 {
635  MockBufferManager mockBuffer(0);
636  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
637 
638  // Create a counter for testing
639  uint16_t counterUid = 44312;
640  uint16_t maxCounterUid = 345;
641  uint16_t deviceUid = 101;
642  uint16_t counterSetUid = 34035;
643  uint16_t counterClass = 0;
644  uint16_t counterInterpolation = 1;
645  double counterMultiplier = 4435.0023f;
646  const std::string counterName = "some_valid_counter";
647  const std::string counterDescription = "a_counter_for_testing";
648  const CounterPtr counter = std::make_unique<Counter>(armnn::profiling::BACKEND_ID,
649  counterUid,
650  maxCounterUid,
651  counterClass,
652  counterInterpolation,
653  counterMultiplier,
654  counterName,
655  counterDescription,
656  "",
657  deviceUid,
658  counterSetUid);
659  BOOST_ASSERT(counter);
660 
661  // Create an event record
662  SendCounterPacket::EventRecord eventRecord;
663  std::string errorMessage;
664  bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
665 
666  BOOST_CHECK(result);
667  BOOST_CHECK(errorMessage.empty());
668  BOOST_CHECK(eventRecord.size() == 21); // Size in words: header [8] + counter name [6] + description [7]
669 
670  uint16_t eventRecordWord0[]
671  {
672  static_cast<uint16_t>(eventRecord[0] >> 16),
673  static_cast<uint16_t>(eventRecord[0])
674  };
675  uint16_t eventRecordWord1[]
676  {
677  static_cast<uint16_t>(eventRecord[1] >> 16),
678  static_cast<uint16_t>(eventRecord[1])
679  };
680  uint16_t eventRecordWord2[]
681  {
682  static_cast<uint16_t>(eventRecord[2] >> 16),
683  static_cast<uint16_t>(eventRecord[2])
684  };
685  uint32_t eventRecordWord34[]
686  {
687  eventRecord[3],
688  eventRecord[4]
689  };
690  BOOST_CHECK(eventRecordWord0[0] == maxCounterUid); // max_counter_uid
691  BOOST_CHECK(eventRecordWord0[1] == counterUid); // counter_uid
692  BOOST_CHECK(eventRecordWord1[0] == deviceUid); // device
693  BOOST_CHECK(eventRecordWord1[1] == counterSetUid); // counter_set
694  BOOST_CHECK(eventRecordWord2[0] == counterClass); // class
695  BOOST_CHECK(eventRecordWord2[1] == counterInterpolation); // interpolation
696  BOOST_CHECK(std::memcmp(eventRecordWord34, &counterMultiplier, sizeof(counterMultiplier)) == 0); // multiplier
697 
698  ARMNN_NO_CONVERSION_WARN_BEGIN
699  uint32_t counterNameOffset = 0; // The name is the first item in pool
700  uint32_t counterDescriptionOffset = counterNameOffset + // Counter name offset
701  4u + // Counter name length (uint32_t)
702  counterName.size() + // 18u
703  1u + // Null-terminator
704  1u; // Rounding to the next word
705  ARMNN_NO_CONVERSION_WARN_END
706 
707  BOOST_CHECK(eventRecord[5] == counterNameOffset); // name_offset
708  BOOST_CHECK(eventRecord[6] == counterDescriptionOffset); // description_offset
709  BOOST_CHECK(eventRecord[7] == 0); // units_offset
710 
711  auto eventRecordPool = reinterpret_cast<unsigned char*>(eventRecord.data() + 8u); // The start of the pool
712  size_t uint32_t_size = sizeof(uint32_t);
713 
714  // The length of the SWTrace string (name)
715  BOOST_CHECK(eventRecordPool[counterNameOffset] == counterName.size() + 1);
716  // The counter name
717  BOOST_CHECK(std::memcmp(eventRecordPool +
718  counterNameOffset + // Offset
719  uint32_t_size, // The length of the name
720  counterName.data(),
721  counterName.size()) == 0); // name
722  // The null-terminator at the end of the name
723  BOOST_CHECK(eventRecordPool[counterNameOffset + uint32_t_size + counterName.size()] == '\0');
724 
725  // The length of the SWTrace string (description)
726  BOOST_CHECK(eventRecordPool[counterDescriptionOffset] == counterDescription.size() + 1);
727  // The counter description
728  BOOST_CHECK(std::memcmp(eventRecordPool +
729  counterDescriptionOffset + // Offset
730  uint32_t_size, // The length of the description
731  counterDescription.data(),
732  counterDescription.size()) == 0); // description
733  // The null-terminator at the end of the description
734  BOOST_CHECK(eventRecordPool[counterDescriptionOffset + uint32_t_size + counterDescription.size()] == '\0');
735 }
ARMNN_NO_CONVERSION_WARN_END
#define ARMNN_NO_CONVERSION_WARN_END
Definition: Conversion.hpp:37
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::CounterPtr
std::shared_ptr< Counter > CounterPtr
Definition: ICounterDirectory.hpp:34
ARMNN_NO_CONVERSION_WARN_BEGIN
#define ARMNN_NO_CONVERSION_WARN_BEGIN
Definition: Conversion.hpp:36

◆ BOOST_AUTO_TEST_CASE() [11/33]

BOOST_AUTO_TEST_CASE ( CreateInvalidEventRecordTest1  )

Definition at line 737 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), and SendCounterPacketTest::CreateEventRecordTest().

738 {
739  MockBufferManager mockBuffer(0);
740  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
741 
742  // Create a counter for testing
743  uint16_t counterUid = 7256;
744  uint16_t maxCounterUid = 132;
745  uint16_t deviceUid = 132;
746  uint16_t counterSetUid = 4497;
747  uint16_t counterClass = 1;
748  uint16_t counterInterpolation = 1;
749  double counterMultiplier = 1234.567f;
750  const std::string counterName = "some_invalid_counter £££"; // Invalid name
751  const std::string counterDescription = "a_counter_for_testing";
752  const std::string counterUnits = "Mrads2";
753  const CounterPtr counter = std::make_unique<Counter>(armnn::profiling::BACKEND_ID,
754  counterUid,
755  maxCounterUid,
756  counterClass,
757  counterInterpolation,
758  counterMultiplier,
759  counterName,
760  counterDescription,
761  counterUnits,
762  deviceUid,
763  counterSetUid);
764  BOOST_ASSERT(counter);
765 
766  // Create an event record
767  SendCounterPacket::EventRecord eventRecord;
768  std::string errorMessage;
769  bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
770 
771  BOOST_CHECK(!result);
772  BOOST_CHECK(!errorMessage.empty());
773  BOOST_CHECK(eventRecord.empty());
774 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::CounterPtr
std::shared_ptr< Counter > CounterPtr
Definition: ICounterDirectory.hpp:34

◆ BOOST_AUTO_TEST_CASE() [12/33]

BOOST_AUTO_TEST_CASE ( CreateInvalidEventRecordTest2  )

Definition at line 776 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), and SendCounterPacketTest::CreateEventRecordTest().

777 {
778  MockBufferManager mockBuffer(0);
779  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
780 
781  // Create a counter for testing
782  uint16_t counterUid = 7256;
783  uint16_t maxCounterUid = 132;
784  uint16_t deviceUid = 132;
785  uint16_t counterSetUid = 4497;
786  uint16_t counterClass = 1;
787  uint16_t counterInterpolation = 1;
788  double counterMultiplier = 1234.567f;
789  const std::string counterName = "some_invalid_counter";
790  const std::string counterDescription = "an invalid d€scription"; // Invalid description
791  const std::string counterUnits = "Mrads2";
792  const CounterPtr counter = std::make_unique<Counter>(armnn::profiling::BACKEND_ID,
793  counterUid,
794  maxCounterUid,
795  counterClass,
796  counterInterpolation,
797  counterMultiplier,
798  counterName,
799  counterDescription,
800  counterUnits,
801  deviceUid,
802  counterSetUid);
803  BOOST_ASSERT(counter);
804 
805  // Create an event record
806  SendCounterPacket::EventRecord eventRecord;
807  std::string errorMessage;
808  bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
809 
810  BOOST_CHECK(!result);
811  BOOST_CHECK(!errorMessage.empty());
812  BOOST_CHECK(eventRecord.empty());
813 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::CounterPtr
std::shared_ptr< Counter > CounterPtr
Definition: ICounterDirectory.hpp:34

◆ BOOST_AUTO_TEST_CASE() [13/33]

BOOST_AUTO_TEST_CASE ( CreateInvalidEventRecordTest3  )

Definition at line 815 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), and SendCounterPacketTest::CreateEventRecordTest().

816 {
817  MockBufferManager mockBuffer(0);
818  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
819 
820  // Create a counter for testing
821  uint16_t counterUid = 7256;
822  uint16_t maxCounterUid = 132;
823  uint16_t deviceUid = 132;
824  uint16_t counterSetUid = 4497;
825  uint16_t counterClass = 1;
826  uint16_t counterInterpolation = 1;
827  double counterMultiplier = 1234.567f;
828  const std::string counterName = "some_invalid_counter";
829  const std::string counterDescription = "a valid description";
830  const std::string counterUnits = "Mrad s2"; // Invalid units
831  const CounterPtr counter = std::make_unique<Counter>(armnn::profiling::BACKEND_ID,
832  counterUid,
833  maxCounterUid,
834  counterClass,
835  counterInterpolation,
836  counterMultiplier,
837  counterName,
838  counterDescription,
839  counterUnits,
840  deviceUid,
841  counterSetUid);
842  BOOST_ASSERT(counter);
843 
844  // Create an event record
845  SendCounterPacket::EventRecord eventRecord;
846  std::string errorMessage;
847  bool result = sendCounterPacketTest.CreateEventRecordTest(counter, eventRecord, errorMessage);
848 
849  BOOST_CHECK(!result);
850  BOOST_CHECK(!errorMessage.empty());
851  BOOST_CHECK(eventRecord.empty());
852 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::CounterPtr
std::shared_ptr< Counter > CounterPtr
Definition: ICounterDirectory.hpp:34

◆ BOOST_AUTO_TEST_CASE() [14/33]

BOOST_AUTO_TEST_CASE ( CreateCategoryRecordTest  )

Definition at line 854 of file SendCounterPacketTests.cpp.

References ARMNN_NO_CONVERSION_WARN_BEGIN, ARMNN_NO_CONVERSION_WARN_END, BOOST_CHECK(), SendCounterPacketTest::CreateCategoryRecordTest(), Counter::m_MaxCounterUid, Counter::m_Name, Counter::m_Uid, armnn::numeric_cast(), and armnn::profiling::uint32_t_size.

855 {
856  MockBufferManager mockBuffer(0);
857  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
858 
859  // Create a category for testing
860  const std::string categoryName = "some_category";
861  const CategoryPtr category = std::make_unique<Category>(categoryName);
862  BOOST_ASSERT(category);
863  category->m_Counters = { 11u, 23u, 5670u };
864 
865  // Create a collection of counters
866  Counters counters;
867  counters.insert(std::make_pair<uint16_t, CounterPtr>(11,
868  CounterPtr(new Counter(armnn::profiling::BACKEND_ID,
869  0,
870  11,
871  0,
872  0,
873  534.0003f,
874  "counter1",
875  "the first counter",
876  "millipi2",
877  0,
878  0))));
879  counters.insert(std::make_pair<uint16_t, CounterPtr>(23,
880  CounterPtr(new Counter(armnn::profiling::BACKEND_ID,
881  1,
882  23,
883  0,
884  1,
885  534.0003f,
886  "this is counter 2",
887  "the second counter",
888  "",
889  0,
890  0))));
891  counters.insert(std::make_pair<uint16_t, CounterPtr>(5670,
892  CounterPtr(new Counter(armnn::profiling::BACKEND_ID,
893  2,
894  5670,
895  0,
896  0,
897  534.0003f,
898  "and this is number 3",
899  "the third counter",
900  "blah_per_second",
901  0,
902  0))));
903  Counter* counter1 = counters.find(11)->second.get();
904  Counter* counter2 = counters.find(23)->second.get();
905  Counter* counter3 = counters.find(5670)->second.get();
906  BOOST_ASSERT(counter1);
907  BOOST_ASSERT(counter2);
908  BOOST_ASSERT(counter3);
909  uint16_t categoryEventCount = boost::numeric_cast<uint16_t>(counters.size());
910 
911  // Create a category record
912  SendCounterPacket::CategoryRecord categoryRecord;
913  std::string errorMessage;
914  bool result = sendCounterPacketTest.CreateCategoryRecordTest(category, counters, categoryRecord, errorMessage);
915 
916  BOOST_CHECK(result);
917  BOOST_CHECK(errorMessage.empty());
918  BOOST_CHECK(categoryRecord.size() == 79); // Size in words: header [3] + event pointer table [3] +
919  // category name [5] + event records [68 = 22 + 20 + 26]
920 
921  uint16_t categoryRecordWord1[]
922  {
923  static_cast<uint16_t>(categoryRecord[0] >> 16),
924  static_cast<uint16_t>(categoryRecord[0])
925  };
926  BOOST_CHECK(categoryRecordWord1[0] == categoryEventCount); // event_count
927  BOOST_CHECK(categoryRecordWord1[1] == 0); // reserved
928 
929  size_t uint32_t_size = sizeof(uint32_t);
930 
931  ARMNN_NO_CONVERSION_WARN_BEGIN
932  uint32_t eventPointerTableOffset = 0; // The event pointer table is the first item in pool
933  uint32_t categoryNameOffset = eventPointerTableOffset + // Event pointer table offset
934  categoryEventCount * uint32_t_size; // The size of the event pointer table
935  ARMNN_NO_CONVERSION_WARN_END
936 
937  BOOST_CHECK(categoryRecord[1] == eventPointerTableOffset); // event_pointer_table_offset
938  BOOST_CHECK(categoryRecord[2] == categoryNameOffset); // name_offset
939 
940  auto categoryRecordPool = reinterpret_cast<unsigned char*>(categoryRecord.data() + 3u); // The start of the pool
941 
942  // The event pointer table
943  uint32_t eventRecord0Offset = categoryRecordPool[eventPointerTableOffset + 0 * uint32_t_size];
944  uint32_t eventRecord1Offset = categoryRecordPool[eventPointerTableOffset + 1 * uint32_t_size];
945  uint32_t eventRecord2Offset = categoryRecordPool[eventPointerTableOffset + 2 * uint32_t_size];
946  BOOST_CHECK(eventRecord0Offset == 32);
947  BOOST_CHECK(eventRecord1Offset == 120);
948  BOOST_CHECK(eventRecord2Offset == 200);
949 
950  // The length of the SWTrace namestring (name)
951  BOOST_CHECK(categoryRecordPool[categoryNameOffset] == categoryName.size() + 1);
952  // The category name
953  BOOST_CHECK(std::memcmp(categoryRecordPool +
954  categoryNameOffset + // Offset
955  uint32_t_size, // The length of the name
956  categoryName.data(),
957  categoryName.size()) == 0); // name
958  // The null-terminator at the end of the name
959  BOOST_CHECK(categoryRecordPool[categoryNameOffset + uint32_t_size + categoryName.size()] == '\0');
960 
961  // For brevity, checking only the UIDs, max counter UIDs and names of the counters in the event records,
962  // as the event records already have a number of unit tests dedicated to them
963 
964  // Counter1 UID and max counter UID
965  uint16_t eventRecord0Word0[2] = { 0u, 0u };
966  std::memcpy(eventRecord0Word0, categoryRecordPool + eventRecord0Offset, sizeof(eventRecord0Word0));
967  BOOST_CHECK(eventRecord0Word0[0] == counter1->m_Uid);
968  BOOST_CHECK(eventRecord0Word0[1] == counter1->m_MaxCounterUid);
969 
970  // Counter1 name
971  uint32_t counter1NameOffset = 0;
972  std::memcpy(&counter1NameOffset, categoryRecordPool + eventRecord0Offset + 5u * uint32_t_size, uint32_t_size);
973  BOOST_CHECK(counter1NameOffset == 0);
974  // The length of the SWTrace string (name)
975  BOOST_CHECK(categoryRecordPool[eventRecord0Offset + // Offset to the event record
976  8u * uint32_t_size + // Offset to the event record pool
977  counter1NameOffset // Offset to the name of the counter
978  ] == counter1->m_Name.size() + 1); // The length of the name including the
979  // null-terminator
980  // The counter1 name
981  BOOST_CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool
982  eventRecord0Offset + // Offset to the event record
983  8u * uint32_t_size + // Offset to the event record pool
984  counter1NameOffset + // Offset to the name of the counter
985  uint32_t_size, // The length of the name
986  counter1->m_Name.data(),
987  counter1->m_Name.size()) == 0); // name
988  // The null-terminator at the end of the counter1 name
989  BOOST_CHECK(categoryRecordPool[eventRecord0Offset + // Offset to the event record
990  8u * uint32_t_size + // Offset to the event record pool
991  counter1NameOffset + // Offset to the name of the counter
992  uint32_t_size + // The length of the name
993  counter1->m_Name.size() // The name of the counter
994  ] == '\0');
995 
996  // Counter2 name
997  uint32_t counter2NameOffset = 0;
998  std::memcpy(&counter2NameOffset, categoryRecordPool + eventRecord1Offset + 5u * uint32_t_size, uint32_t_size);
999  BOOST_CHECK(counter2NameOffset == 0);
1000  // The length of the SWTrace string (name)
1001  BOOST_CHECK(categoryRecordPool[eventRecord1Offset + // Offset to the event record
1002  8u * uint32_t_size + // Offset to the event record pool
1003  counter2NameOffset // Offset to the name of the counter
1004  ] == counter2->m_Name.size() + 1); // The length of the name including the
1005  // null-terminator
1006  // The counter2 name
1007  BOOST_CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool
1008  eventRecord1Offset + // Offset to the event record
1009  8u * uint32_t_size + // Offset to the event record pool
1010  counter2NameOffset + // Offset to the name of the counter
1011  uint32_t_size, // The length of the name
1012  counter2->m_Name.data(),
1013  counter2->m_Name.size()) == 0); // name
1014  // The null-terminator at the end of the counter2 name
1015  BOOST_CHECK(categoryRecordPool[eventRecord1Offset + // Offset to the event record
1016  8u * uint32_t_size + // Offset to the event record pool
1017  counter2NameOffset + // Offset to the name of the counter
1018  uint32_t_size + // The length of the name
1019  counter2->m_Name.size() // The name of the counter
1020  ] == '\0');
1021 
1022  // Counter3 name
1023  uint32_t counter3NameOffset = 0;
1024  std::memcpy(&counter3NameOffset, categoryRecordPool + eventRecord2Offset + 5u * uint32_t_size, uint32_t_size);
1025  BOOST_CHECK(counter3NameOffset == 0);
1026  // The length of the SWTrace string (name)
1027  BOOST_CHECK(categoryRecordPool[eventRecord2Offset + // Offset to the event record
1028  8u * uint32_t_size + // Offset to the event record pool
1029  counter3NameOffset // Offset to the name of the counter
1030  ] == counter3->m_Name.size() + 1); // The length of the name including the
1031  // null-terminator
1032  // The counter3 name
1033  BOOST_CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool
1034  eventRecord2Offset + // Offset to the event record
1035  8u * uint32_t_size + // Offset to the event record pool
1036  counter3NameOffset + // Offset to the name of the counter
1037  uint32_t_size, // The length of the name
1038  counter3->m_Name.data(),
1039  counter3->m_Name.size()) == 0); // name
1040  // The null-terminator at the end of the counter3 name
1041  BOOST_CHECK(categoryRecordPool[eventRecord2Offset + // Offset to the event record
1042  8u * uint32_t_size + // Offset to the event record pool
1043  counter3NameOffset + // Offset to the name of the counter
1044  uint32_t_size + // The length of the name
1045  counter3->m_Name.size() // The name of the counter
1046  ] == '\0');
1047 }
armnn::profiling::Counters
std::unordered_map< uint16_t, CounterPtr > Counters
Definition: ICounterDirectory.hpp:40
ARMNN_NO_CONVERSION_WARN_END
#define ARMNN_NO_CONVERSION_WARN_END
Definition: Conversion.hpp:37
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::CounterPtr
std::shared_ptr< Counter > CounterPtr
Definition: ICounterDirectory.hpp:34
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33
ARMNN_NO_CONVERSION_WARN_BEGIN
#define ARMNN_NO_CONVERSION_WARN_BEGIN
Definition: Conversion.hpp:36
armnn::profiling::SendCounterPacket::CategoryRecord
std::vector< uint32_t > CategoryRecord
Definition: SendCounterPacket.hpp:24
armnn::profiling::CategoryPtr
std::unique_ptr< Category > CategoryPtr
Definition: ICounterDirectory.hpp:31

◆ BOOST_AUTO_TEST_CASE() [15/33]

BOOST_AUTO_TEST_CASE ( CreateInvalidCategoryRecordTest1  )

Definition at line 1049 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), and SendCounterPacketTest::CreateCategoryRecordTest().

1050 {
1051  MockBufferManager mockBuffer(0);
1052  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
1053 
1054  // Create a category for testing
1055  const std::string categoryName = "some invalid category";
1056  const CategoryPtr category = std::make_unique<Category>(categoryName);
1057  BOOST_CHECK(category);
1058 
1059  // Create a category record
1060  Counters counters;
1061  SendCounterPacket::CategoryRecord categoryRecord;
1062  std::string errorMessage;
1063  bool result = sendCounterPacketTest.CreateCategoryRecordTest(category, counters, categoryRecord, errorMessage);
1064 
1065  BOOST_CHECK(!result);
1066  BOOST_CHECK(!errorMessage.empty());
1067  BOOST_CHECK(categoryRecord.empty());
1068 }
armnn::profiling::Counters
std::unordered_map< uint16_t, CounterPtr > Counters
Definition: ICounterDirectory.hpp:40
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::SendCounterPacket::CategoryRecord
std::vector< uint32_t > CategoryRecord
Definition: SendCounterPacket.hpp:24
armnn::profiling::CategoryPtr
std::unique_ptr< Category > CategoryPtr
Definition: ICounterDirectory.hpp:31

◆ BOOST_AUTO_TEST_CASE() [16/33]

BOOST_AUTO_TEST_CASE ( CreateInvalidCategoryRecordTest2  )

Definition at line 1070 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), and SendCounterPacketTest::CreateCategoryRecordTest().

1071 {
1072  MockBufferManager mockBuffer(0);
1073  SendCounterPacketTest sendCounterPacketTest(mockBuffer);
1074 
1075  // Create a category for testing
1076  const std::string categoryName = "some_category";
1077  const CategoryPtr category = std::make_unique<Category>(categoryName);
1078  BOOST_CHECK(category);
1079  category->m_Counters = { 11u, 23u, 5670u };
1080 
1081  // Create a collection of counters
1082  Counters counters;
1083  counters.insert(std::make_pair<uint16_t, CounterPtr>(11,
1084  CounterPtr(new Counter(armnn::profiling::BACKEND_ID,
1085  11,
1086  1234,
1087  0,
1088  1,
1089  534.0003f,
1090  "count€r1", // Invalid name
1091  "the first counter",
1092  "millipi2",
1093  0,
1094  0))));
1095 
1096  Counter* counter1 = counters.find(11)->second.get();
1097  BOOST_CHECK(counter1);
1098 
1099  // Create a category record
1100  SendCounterPacket::CategoryRecord categoryRecord;
1101  std::string errorMessage;
1102  bool result = sendCounterPacketTest.CreateCategoryRecordTest(category, counters, categoryRecord, errorMessage);
1103 
1104  BOOST_CHECK(!result);
1105  BOOST_CHECK(!errorMessage.empty());
1106  BOOST_CHECK(categoryRecord.empty());
1107 }
armnn::profiling::Counters
std::unordered_map< uint16_t, CounterPtr > Counters
Definition: ICounterDirectory.hpp:40
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::CounterPtr
std::shared_ptr< Counter > CounterPtr
Definition: ICounterDirectory.hpp:34
armnn::profiling::SendCounterPacket::CategoryRecord
std::vector< uint32_t > CategoryRecord
Definition: SendCounterPacket.hpp:24
armnn::profiling::CategoryPtr
std::unique_ptr< Category > CategoryPtr
Definition: ICounterDirectory.hpp:31

◆ BOOST_AUTO_TEST_CASE() [17/33]

BOOST_AUTO_TEST_CASE ( SendCounterDirectoryPacketTest1  )

Definition at line 1109 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), CounterDirectory::GetDeviceCount(), CounterDirectory::RegisterDevice(), and SendCounterPacket::SendCounterDirectoryPacket().

1110 {
1111  // The counter directory used for testing
1112  CounterDirectory counterDirectory;
1113 
1114  // Register a device
1115  const std::string device1Name = "device1";
1116  const Device* device1 = nullptr;
1117  BOOST_CHECK_NO_THROW(device1 = counterDirectory.RegisterDevice(device1Name, 3));
1118  BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
1119  BOOST_CHECK(device1);
1120 
1121  // Register a device
1122  const std::string device2Name = "device2";
1123  const Device* device2 = nullptr;
1124  BOOST_CHECK_NO_THROW(device2 = counterDirectory.RegisterDevice(device2Name));
1125  BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
1126  BOOST_CHECK(device2);
1127 
1128  // Buffer with not enough space
1129  MockBufferManager mockBuffer(10);
1130  SendCounterPacket sendCounterPacket(mockBuffer);
1131  BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory),
1132  armnn::profiling::BufferExhaustion);
1133 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::CounterDirectory::GetDeviceCount
uint16_t GetDeviceCount() const override
Definition: CounterDirectory.hpp:52
armnn::profiling::CounterDirectory::RegisterDevice
const Device * RegisterDevice(const std::string &deviceName, uint16_t cores=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
Definition: CounterDirectory.cpp:52

◆ BOOST_AUTO_TEST_CASE() [18/33]

BOOST_AUTO_TEST_CASE ( SendCounterDirectoryPacketTest2  )

Definition at line 1135 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), CounterDirectory::GetCategory(), CounterDirectory::GetCategoryCount(), CounterDirectory::GetCounter(), CounterDirectory::GetCounterCount(), CounterDirectory::GetCounterSet(), CounterDirectory::GetCounterSetCount(), CounterDirectory::GetDevice(), CounterDirectory::GetDeviceCount(), MockBufferManager::GetReadableBuffer(), Counter::m_Class, Device::m_Cores, CounterSet::m_Count, Category::m_Counters, Counter::m_CounterSetUid, Counter::m_Description, Counter::m_DeviceUid, Counter::m_Interpolation, Counter::m_MaxCounterUid, Counter::m_Multiplier, Category::m_Name, Device::m_Name, CounterSet::m_Name, Counter::m_Name, Device::m_Uid, CounterSet::m_Uid, Counter::m_Units, armnn::profiling::ReadUint32(), armnn::profiling::ReadUint64(), armnn::profiling::ReadUint8(), CounterDirectory::RegisterCategory(), CounterDirectory::RegisterCounter(), CounterDirectory::RegisterCounterSet(), CounterDirectory::RegisterDevice(), SendCounterPacket::SendCounterDirectoryPacket(), and armnn::profiling::uint32_t_size.

1136 {
1137  // The counter directory used for testing
1138  CounterDirectory counterDirectory;
1139 
1140  // Register a device
1141  const std::string device1Name = "device1";
1142  const Device* device1 = nullptr;
1143  BOOST_CHECK_NO_THROW(device1 = counterDirectory.RegisterDevice(device1Name, 3));
1144  BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
1145  BOOST_CHECK(device1);
1146 
1147  // Register a device
1148  const std::string device2Name = "device2";
1149  const Device* device2 = nullptr;
1150  BOOST_CHECK_NO_THROW(device2 = counterDirectory.RegisterDevice(device2Name));
1151  BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
1152  BOOST_CHECK(device2);
1153 
1154  // Register a counter set
1155  const std::string counterSet1Name = "counterset1";
1156  const CounterSet* counterSet1 = nullptr;
1157  BOOST_CHECK_NO_THROW(counterSet1 = counterDirectory.RegisterCounterSet(counterSet1Name));
1158  BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
1159  BOOST_CHECK(counterSet1);
1160 
1161  // Register a category associated to "device1" and "counterset1"
1162  const std::string category1Name = "category1";
1163  const Category* category1 = nullptr;
1164  BOOST_CHECK_NO_THROW(category1 = counterDirectory.RegisterCategory(category1Name));
1165  BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
1166  BOOST_CHECK(category1);
1167 
1168  // Register a category not associated to "device2" but no counter set
1169  const std::string category2Name = "category2";
1170  const Category* category2 = nullptr;
1171  BOOST_CHECK_NO_THROW(category2 = counterDirectory.RegisterCategory(category2Name));
1172  BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
1173  BOOST_CHECK(category2);
1174 
1175  uint16_t numberOfCores = 3;
1176 
1177  // Register a counter associated to "category1"
1178  const Counter* counter1 = nullptr;
1179  BOOST_CHECK_NO_THROW(counter1 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
1180  0,
1181  category1Name,
1182  0,
1183  1,
1184  123.45f,
1185  "counter1",
1186  "counter1description",
1187  std::string("counter1units"),
1188  numberOfCores));
1189  BOOST_CHECK(counterDirectory.GetCounterCount() == 3);
1190  BOOST_CHECK(counter1);
1191 
1192  // Register a counter associated to "category1"
1193  const Counter* counter2 = nullptr;
1194  BOOST_CHECK_NO_THROW(counter2 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
1195  4,
1196  category1Name,
1197  1,
1198  0,
1199  330.1245656765f,
1200  "counter2",
1201  "counter2description",
1202  std::string("counter2units"),
1203  armnn::EmptyOptional(),
1204  device2->m_Uid,
1205  0));
1206  BOOST_CHECK(counterDirectory.GetCounterCount() == 4);
1207  BOOST_CHECK(counter2);
1208 
1209  // Register a counter associated to "category2"
1210  const Counter* counter3 = nullptr;
1211  BOOST_CHECK_NO_THROW(counter3 = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
1212  5,
1213  category2Name,
1214  1,
1215  1,
1216  0.0000045399f,
1217  "counter3",
1218  "counter3description",
1219  armnn::EmptyOptional(),
1220  5,
1221  device2->m_Uid,
1222  counterSet1->m_Uid));
1223  BOOST_CHECK(counterDirectory.GetCounterCount() == 9);
1224  BOOST_CHECK(counter3);
1225 
1226  // Buffer with enough space
1227  MockBufferManager mockBuffer(1024);
1228  SendCounterPacket sendCounterPacket(mockBuffer);
1229  BOOST_CHECK_NO_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory));
1230 
1231  // Get the readable buffer
1232  auto readBuffer = mockBuffer.GetReadableBuffer();
1233 
1234  // Check the packet header
1235  uint32_t packetHeaderWord0 = ReadUint32(readBuffer, 0);
1236  uint32_t packetHeaderWord1 = ReadUint32(readBuffer, 4);
1237  BOOST_TEST(((packetHeaderWord0 >> 26) & 0x3F) == 0); // packet_family
1238  BOOST_TEST(((packetHeaderWord0 >> 16) & 0x3FF) == 2); // packet_id
1239  BOOST_TEST(packetHeaderWord1 == 928); // data_length
1240 
1241  // Check the body header
1242  uint32_t bodyHeaderWord0 = ReadUint32(readBuffer, 8);
1243  uint32_t bodyHeaderWord1 = ReadUint32(readBuffer, 12);
1244  uint32_t bodyHeaderWord2 = ReadUint32(readBuffer, 16);
1245  uint32_t bodyHeaderWord3 = ReadUint32(readBuffer, 20);
1246  uint32_t bodyHeaderWord4 = ReadUint32(readBuffer, 24);
1247  uint32_t bodyHeaderWord5 = ReadUint32(readBuffer, 28);
1248  uint16_t deviceRecordCount = static_cast<uint16_t>(bodyHeaderWord0 >> 16);
1249  uint16_t counterSetRecordCount = static_cast<uint16_t>(bodyHeaderWord2 >> 16);
1250  uint16_t categoryRecordCount = static_cast<uint16_t>(bodyHeaderWord4 >> 16);
1251  BOOST_TEST(deviceRecordCount == 2); // device_records_count
1252  BOOST_TEST(bodyHeaderWord1 == 0); // device_records_pointer_table_offset
1253  BOOST_TEST(counterSetRecordCount == 1); // counter_set_count
1254  BOOST_TEST(bodyHeaderWord3 == 8); // counter_set_pointer_table_offset
1255  BOOST_TEST(categoryRecordCount == 2); // categories_count
1256  BOOST_TEST(bodyHeaderWord5 == 12); // categories_pointer_table_offset
1257 
1258  // Check the device records pointer table
1259  uint32_t deviceRecordOffset0 = ReadUint32(readBuffer, 32);
1260  uint32_t deviceRecordOffset1 = ReadUint32(readBuffer, 36);
1261  BOOST_TEST(deviceRecordOffset0 == 0); // Device record offset for "device1"
1262  BOOST_TEST(deviceRecordOffset1 == 20); // Device record offset for "device2"
1263 
1264  // Check the counter set pointer table
1265  uint32_t counterSetRecordOffset0 = ReadUint32(readBuffer, 40);
1266  BOOST_TEST(counterSetRecordOffset0 == 40); // Counter set record offset for "counterset1"
1267 
1268  // Check the category pointer table
1269  uint32_t categoryRecordOffset0 = ReadUint32(readBuffer, 44);
1270  uint32_t categoryRecordOffset1 = ReadUint32(readBuffer, 48);
1271  BOOST_TEST(categoryRecordOffset0 == 64); // Category record offset for "category1"
1272  BOOST_TEST(categoryRecordOffset1 == 472); // Category record offset for "category2"
1273 
1274  // Get the device record pool offset
1275  uint32_t uint32_t_size = sizeof(uint32_t);
1276  uint32_t packetBodyPoolOffset = 2u * uint32_t_size + // packet_header
1277  6u * uint32_t_size + // body_header
1278  deviceRecordCount * uint32_t_size + // Size of device_records_pointer_table
1279  counterSetRecordCount * uint32_t_size + // Size of counter_set_pointer_table
1280  categoryRecordCount * uint32_t_size; // Size of categories_pointer_table
1281 
1282  // Device record structure/collection used for testing
1283  struct DeviceRecord
1284  {
1285  uint16_t uid;
1286  uint16_t cores;
1287  uint32_t name_offset;
1288  uint32_t name_length;
1289  std::string name;
1290  };
1291  std::vector<DeviceRecord> deviceRecords;
1292  uint32_t deviceRecordsPointerTableOffset = 2u * uint32_t_size + // packet_header
1293  6u * uint32_t_size + // body_header
1294  bodyHeaderWord1; // device_records_pointer_table_offset
1295 
1296  const unsigned char* readData = readBuffer->GetReadableData();
1297 
1298  for (uint32_t i = 0; i < deviceRecordCount; i++)
1299  {
1300  // Get the device record offset
1301  uint32_t deviceRecordOffset = ReadUint32(readBuffer, deviceRecordsPointerTableOffset + i * uint32_t_size);
1302 
1303  // Collect the data for the device record
1304  uint32_t deviceRecordWord0 = ReadUint32(readBuffer,
1305  packetBodyPoolOffset + deviceRecordOffset + 0 * uint32_t_size);
1306  uint32_t deviceRecordWord1 = ReadUint32(readBuffer,
1307  packetBodyPoolOffset + deviceRecordOffset + 1 * uint32_t_size);
1308  DeviceRecord deviceRecord;
1309  deviceRecord.uid = static_cast<uint16_t>(deviceRecordWord0 >> 16); // uid
1310  deviceRecord.cores = static_cast<uint16_t>(deviceRecordWord0); // cores
1311  deviceRecord.name_offset = deviceRecordWord1; // name_offset
1312 
1313  uint32_t deviceRecordPoolOffset = packetBodyPoolOffset + // Packet body offset
1314  deviceRecordOffset + // Device record offset
1315  2 * uint32_t_size + // Device record header
1316  deviceRecord.name_offset; // Device name offset
1317  uint32_t deviceRecordNameLength = ReadUint32(readBuffer, deviceRecordPoolOffset);
1318  deviceRecord.name_length = deviceRecordNameLength; // name_length
1319  unsigned char deviceRecordNameNullTerminator = // name null-terminator
1320  ReadUint8(readBuffer, deviceRecordPoolOffset + uint32_t_size + deviceRecordNameLength - 1);
1321  BOOST_CHECK(deviceRecordNameNullTerminator == '\0');
1322  std::vector<unsigned char> deviceRecordNameBuffer(deviceRecord.name_length - 1);
1323  std::memcpy(deviceRecordNameBuffer.data(),
1324  readData + deviceRecordPoolOffset + uint32_t_size, deviceRecordNameBuffer.size());
1325  deviceRecord.name.assign(deviceRecordNameBuffer.begin(), deviceRecordNameBuffer.end()); // name
1326 
1327  deviceRecords.push_back(deviceRecord);
1328  }
1329 
1330  // Check that the device records are correct
1331  BOOST_CHECK(deviceRecords.size() == 2);
1332  for (const DeviceRecord& deviceRecord : deviceRecords)
1333  {
1334  const Device* device = counterDirectory.GetDevice(deviceRecord.uid);
1335  BOOST_CHECK(device);
1336  BOOST_CHECK(device->m_Uid == deviceRecord.uid);
1337  BOOST_CHECK(device->m_Cores == deviceRecord.cores);
1338  BOOST_CHECK(device->m_Name == deviceRecord.name);
1339  }
1340 
1341  // Counter set record structure/collection used for testing
1342  struct CounterSetRecord
1343  {
1344  uint16_t uid;
1345  uint16_t count;
1346  uint32_t name_offset;
1347  uint32_t name_length;
1348  std::string name;
1349  };
1350  std::vector<CounterSetRecord> counterSetRecords;
1351  uint32_t counterSetRecordsPointerTableOffset = 2u * uint32_t_size + // packet_header
1352  6u * uint32_t_size + // body_header
1353  bodyHeaderWord3; // counter_set_pointer_table_offset
1354  for (uint32_t i = 0; i < counterSetRecordCount; i++)
1355  {
1356  // Get the counter set record offset
1357  uint32_t counterSetRecordOffset = ReadUint32(readBuffer,
1358  counterSetRecordsPointerTableOffset + i * uint32_t_size);
1359 
1360  // Collect the data for the counter set record
1361  uint32_t counterSetRecordWord0 = ReadUint32(readBuffer,
1362  packetBodyPoolOffset + counterSetRecordOffset + 0 * uint32_t_size);
1363  uint32_t counterSetRecordWord1 = ReadUint32(readBuffer,
1364  packetBodyPoolOffset + counterSetRecordOffset + 1 * uint32_t_size);
1365  CounterSetRecord counterSetRecord;
1366  counterSetRecord.uid = static_cast<uint16_t>(counterSetRecordWord0 >> 16); // uid
1367  counterSetRecord.count = static_cast<uint16_t>(counterSetRecordWord0); // count
1368  counterSetRecord.name_offset = counterSetRecordWord1; // name_offset
1369 
1370  uint32_t counterSetRecordPoolOffset = packetBodyPoolOffset + // Packet body offset
1371  counterSetRecordOffset + // Counter set record offset
1372  2 * uint32_t_size + // Counter set record header
1373  counterSetRecord.name_offset; // Counter set name offset
1374  uint32_t counterSetRecordNameLength = ReadUint32(readBuffer, counterSetRecordPoolOffset);
1375  counterSetRecord.name_length = counterSetRecordNameLength; // name_length
1376  unsigned char counterSetRecordNameNullTerminator = // name null-terminator
1377  ReadUint8(readBuffer, counterSetRecordPoolOffset + uint32_t_size + counterSetRecordNameLength - 1);
1378  BOOST_CHECK(counterSetRecordNameNullTerminator == '\0');
1379  std::vector<unsigned char> counterSetRecordNameBuffer(counterSetRecord.name_length - 1);
1380  std::memcpy(counterSetRecordNameBuffer.data(),
1381  readData + counterSetRecordPoolOffset + uint32_t_size, counterSetRecordNameBuffer.size());
1382  counterSetRecord.name.assign(counterSetRecordNameBuffer.begin(), counterSetRecordNameBuffer.end()); // name
1383 
1384  counterSetRecords.push_back(counterSetRecord);
1385  }
1386 
1387  // Check that the counter set records are correct
1388  BOOST_CHECK(counterSetRecords.size() == 1);
1389  for (const CounterSetRecord& counterSetRecord : counterSetRecords)
1390  {
1391  const CounterSet* counterSet = counterDirectory.GetCounterSet(counterSetRecord.uid);
1392  BOOST_CHECK(counterSet);
1393  BOOST_CHECK(counterSet->m_Uid == counterSetRecord.uid);
1394  BOOST_CHECK(counterSet->m_Count == counterSetRecord.count);
1395  BOOST_CHECK(counterSet->m_Name == counterSetRecord.name);
1396  }
1397 
1398  // Event record structure/collection used for testing
1399  struct EventRecord
1400  {
1401  uint16_t counter_uid;
1402  uint16_t max_counter_uid;
1403  uint16_t device;
1404  uint16_t counter_set;
1405  uint16_t counter_class;
1406  uint16_t interpolation;
1407  double multiplier;
1408  uint32_t name_offset;
1409  uint32_t name_length;
1410  std::string name;
1411  uint32_t description_offset;
1412  uint32_t description_length;
1413  std::string description;
1414  uint32_t units_offset;
1415  uint32_t units_length;
1416  std::string units;
1417  };
1418  // Category record structure/collection used for testing
1419  struct CategoryRecord
1420  {
1421  uint16_t event_count;
1422  uint32_t event_pointer_table_offset;
1423  uint32_t name_offset;
1424  uint32_t name_length;
1425  std::string name;
1426  std::vector<uint32_t> event_pointer_table;
1427  std::vector<EventRecord> event_records;
1428  };
1429  std::vector<CategoryRecord> categoryRecords;
1430  uint32_t categoryRecordsPointerTableOffset = 2u * uint32_t_size + // packet_header
1431  6u * uint32_t_size + // body_header
1432  bodyHeaderWord5; // categories_pointer_table_offset
1433  for (uint32_t i = 0; i < categoryRecordCount; i++)
1434  {
1435  // Get the category record offset
1436  uint32_t categoryRecordOffset = ReadUint32(readBuffer, categoryRecordsPointerTableOffset + i * uint32_t_size);
1437 
1438  // Collect the data for the category record
1439  uint32_t categoryRecordWord1 = ReadUint32(readBuffer,
1440  packetBodyPoolOffset + categoryRecordOffset + 0 * uint32_t_size);
1441  uint32_t categoryRecordWord2 = ReadUint32(readBuffer,
1442  packetBodyPoolOffset + categoryRecordOffset + 1 * uint32_t_size);
1443  uint32_t categoryRecordWord3 = ReadUint32(readBuffer,
1444  packetBodyPoolOffset + categoryRecordOffset + 2 * uint32_t_size);
1445  CategoryRecord categoryRecord;
1446  categoryRecord.event_count = static_cast<uint16_t>(categoryRecordWord1 >> 16); // event_count
1447  categoryRecord.event_pointer_table_offset = categoryRecordWord2; // event_pointer_table_offset
1448  categoryRecord.name_offset = categoryRecordWord3; // name_offset
1449 
1450  uint32_t categoryRecordPoolOffset = packetBodyPoolOffset + // Packet body offset
1451  categoryRecordOffset + // Category record offset
1452  3 * uint32_t_size; // Category record header
1453 
1454  uint32_t categoryRecordNameLength = ReadUint32(readBuffer,
1455  categoryRecordPoolOffset + categoryRecord.name_offset);
1456  categoryRecord.name_length = categoryRecordNameLength; // name_length
1457  unsigned char categoryRecordNameNullTerminator =
1458  ReadUint8(readBuffer,
1459  categoryRecordPoolOffset +
1460  categoryRecord.name_offset +
1461  uint32_t_size +
1462  categoryRecordNameLength - 1); // name null-terminator
1463  BOOST_CHECK(categoryRecordNameNullTerminator == '\0');
1464  std::vector<unsigned char> categoryRecordNameBuffer(categoryRecord.name_length - 1);
1465  std::memcpy(categoryRecordNameBuffer.data(),
1466  readData +
1467  categoryRecordPoolOffset +
1468  categoryRecord.name_offset +
1469  uint32_t_size,
1470  categoryRecordNameBuffer.size());
1471  categoryRecord.name.assign(categoryRecordNameBuffer.begin(), categoryRecordNameBuffer.end()); // name
1472 
1473  categoryRecord.event_pointer_table.resize(categoryRecord.event_count);
1474  for (uint32_t eventIndex = 0; eventIndex < categoryRecord.event_count; eventIndex++)
1475  {
1476  uint32_t eventRecordOffset = ReadUint32(readBuffer,
1477  categoryRecordPoolOffset +
1478  categoryRecord.event_pointer_table_offset +
1479  eventIndex * uint32_t_size);
1480  categoryRecord.event_pointer_table[eventIndex] = eventRecordOffset;
1481 
1482  // Collect the data for the event record
1483  uint32_t eventRecordWord0 = ReadUint32(readBuffer,
1484  categoryRecordPoolOffset + eventRecordOffset + 0 * uint32_t_size);
1485  uint32_t eventRecordWord1 = ReadUint32(readBuffer,
1486  categoryRecordPoolOffset + eventRecordOffset + 1 * uint32_t_size);
1487  uint32_t eventRecordWord2 = ReadUint32(readBuffer,
1488  categoryRecordPoolOffset + eventRecordOffset + 2 * uint32_t_size);
1489  uint64_t eventRecordWord34 = ReadUint64(readBuffer,
1490  categoryRecordPoolOffset + eventRecordOffset + 3 * uint32_t_size);
1491  uint32_t eventRecordWord5 = ReadUint32(readBuffer,
1492  categoryRecordPoolOffset + eventRecordOffset + 5 * uint32_t_size);
1493  uint32_t eventRecordWord6 = ReadUint32(readBuffer,
1494  categoryRecordPoolOffset + eventRecordOffset + 6 * uint32_t_size);
1495  uint32_t eventRecordWord7 = ReadUint32(readBuffer,
1496  categoryRecordPoolOffset + eventRecordOffset + 7 * uint32_t_size);
1497  EventRecord eventRecord;
1498  eventRecord.counter_uid = static_cast<uint16_t>(eventRecordWord0); // counter_uid
1499  eventRecord.max_counter_uid = static_cast<uint16_t>(eventRecordWord0 >> 16); // max_counter_uid
1500  eventRecord.device = static_cast<uint16_t>(eventRecordWord1 >> 16); // device
1501  eventRecord.counter_set = static_cast<uint16_t>(eventRecordWord1); // counter_set
1502  eventRecord.counter_class = static_cast<uint16_t>(eventRecordWord2 >> 16); // class
1503  eventRecord.interpolation = static_cast<uint16_t>(eventRecordWord2); // interpolation
1504  std::memcpy(&eventRecord.multiplier, &eventRecordWord34, sizeof(eventRecord.multiplier)); // multiplier
1505  eventRecord.name_offset = static_cast<uint32_t>(eventRecordWord5); // name_offset
1506  eventRecord.description_offset = static_cast<uint32_t>(eventRecordWord6); // description_offset
1507  eventRecord.units_offset = static_cast<uint32_t>(eventRecordWord7); // units_offset
1508 
1509  uint32_t eventRecordPoolOffset = categoryRecordPoolOffset + // Category record pool offset
1510  eventRecordOffset + // Event record offset
1511  8 * uint32_t_size; // Event record header
1512 
1513  uint32_t eventRecordNameLength = ReadUint32(readBuffer,
1514  eventRecordPoolOffset + eventRecord.name_offset);
1515  eventRecord.name_length = eventRecordNameLength; // name_length
1516  unsigned char eventRecordNameNullTerminator =
1517  ReadUint8(readBuffer,
1518  eventRecordPoolOffset +
1519  eventRecord.name_offset +
1520  uint32_t_size +
1521  eventRecordNameLength - 1); // name null-terminator
1522  BOOST_CHECK(eventRecordNameNullTerminator == '\0');
1523  std::vector<unsigned char> eventRecordNameBuffer(eventRecord.name_length - 1);
1524  std::memcpy(eventRecordNameBuffer.data(),
1525  readData +
1526  eventRecordPoolOffset +
1527  eventRecord.name_offset +
1528  uint32_t_size,
1529  eventRecordNameBuffer.size());
1530  eventRecord.name.assign(eventRecordNameBuffer.begin(), eventRecordNameBuffer.end()); // name
1531 
1532  uint32_t eventRecordDescriptionLength = ReadUint32(readBuffer,
1533  eventRecordPoolOffset + eventRecord.description_offset);
1534  eventRecord.description_length = eventRecordDescriptionLength; // description_length
1535  unsigned char eventRecordDescriptionNullTerminator =
1536  ReadUint8(readBuffer,
1537  eventRecordPoolOffset +
1538  eventRecord.description_offset +
1539  uint32_t_size +
1540  eventRecordDescriptionLength - 1); // description null-terminator
1541  BOOST_CHECK(eventRecordDescriptionNullTerminator == '\0');
1542  std::vector<unsigned char> eventRecordDescriptionBuffer(eventRecord.description_length - 1);
1543  std::memcpy(eventRecordDescriptionBuffer.data(),
1544  readData +
1545  eventRecordPoolOffset +
1546  eventRecord.description_offset +
1547  uint32_t_size,
1548  eventRecordDescriptionBuffer.size());
1549  eventRecord.description.assign(eventRecordDescriptionBuffer.begin(),
1550  eventRecordDescriptionBuffer.end()); // description
1551 
1552  if (eventRecord.units_offset > 0)
1553  {
1554  uint32_t eventRecordUnitsLength = ReadUint32(readBuffer,
1555  eventRecordPoolOffset + eventRecord.units_offset);
1556  eventRecord.units_length = eventRecordUnitsLength; // units_length
1557  unsigned char eventRecordUnitsNullTerminator =
1558  ReadUint8(readBuffer,
1559  eventRecordPoolOffset +
1560  eventRecord.units_offset +
1561  uint32_t_size +
1562  eventRecordUnitsLength - 1); // units null-terminator
1563  BOOST_CHECK(eventRecordUnitsNullTerminator == '\0');
1564  std::vector<unsigned char> eventRecordUnitsBuffer(eventRecord.units_length - 1);
1565  std::memcpy(eventRecordUnitsBuffer.data(),
1566  readData +
1567  eventRecordPoolOffset +
1568  eventRecord.units_offset +
1569  uint32_t_size,
1570  eventRecordUnitsBuffer.size());
1571  eventRecord.units.assign(eventRecordUnitsBuffer.begin(), eventRecordUnitsBuffer.end()); // units
1572  }
1573 
1574  categoryRecord.event_records.push_back(eventRecord);
1575  }
1576 
1577  categoryRecords.push_back(categoryRecord);
1578  }
1579 
1580  // Check that the category records are correct
1581  BOOST_CHECK(categoryRecords.size() == 2);
1582  for (const CategoryRecord& categoryRecord : categoryRecords)
1583  {
1584  const Category* category = counterDirectory.GetCategory(categoryRecord.name);
1585  BOOST_CHECK(category);
1586  BOOST_CHECK(category->m_Name == categoryRecord.name);
1587  BOOST_CHECK(category->m_Counters.size() == categoryRecord.event_count);
1588 
1589  // Check that the event records are correct
1590  for (const EventRecord& eventRecord : categoryRecord.event_records)
1591  {
1592  const Counter* counter = counterDirectory.GetCounter(eventRecord.counter_uid);
1593  BOOST_CHECK(counter);
1594  BOOST_CHECK(counter->m_MaxCounterUid == eventRecord.max_counter_uid);
1595  BOOST_CHECK(counter->m_DeviceUid == eventRecord.device);
1596  BOOST_CHECK(counter->m_CounterSetUid == eventRecord.counter_set);
1597  BOOST_CHECK(counter->m_Class == eventRecord.counter_class);
1598  BOOST_CHECK(counter->m_Interpolation == eventRecord.interpolation);
1599  BOOST_CHECK(counter->m_Multiplier == eventRecord.multiplier);
1600  BOOST_CHECK(counter->m_Name == eventRecord.name);
1601  BOOST_CHECK(counter->m_Description == eventRecord.description);
1602  BOOST_CHECK(counter->m_Units == eventRecord.units);
1603  }
1604  }
1605 }
armnn::profiling::CounterDirectory::RegisterCategory
const Category * RegisterCategory(const std::string &categoryName) override
Definition: CounterDirectory.cpp:21
armnn::profiling::CounterDirectory::RegisterCounter
const Counter * RegisterCounter(const BackendId &backendId, const uint16_t uid, const std::string &parentCategoryName, uint16_t counterClass, uint16_t interpolation, double multiplier, const std::string &name, const std::string &description, const Optional< std::string > &units=EmptyOptional(), const Optional< uint16_t > &numberOfCores=EmptyOptional(), const Optional< uint16_t > &deviceUid=EmptyOptional(), const Optional< uint16_t > &counterSetUid=EmptyOptional()) override
Definition: CounterDirectory.cpp:181
armnn::profiling::ReadUint64
uint64_t ReadUint64(const IPacketBufferPtr &packetBuffer, unsigned int offset)
Definition: ProfilingUtils.cpp:197
armnn::profiling::CounterDirectory::GetDevice
const Device * GetDevice(uint16_t uid) const override
Definition: CounterDirectory.cpp:344
armnn::profiling::CounterDirectory::GetCounterSetCount
uint16_t GetCounterSetCount() const override
Definition: CounterDirectory.hpp:53
armnn::profiling::ReadUint8
uint8_t ReadUint8(const IPacketBufferPtr &packetBuffer, unsigned int offset)
Definition: ProfilingUtils.cpp:218
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::CounterDirectory::GetDeviceCount
uint16_t GetDeviceCount() const override
Definition: CounterDirectory.hpp:52
armnn::profiling::CounterDirectory::GetCategoryCount
uint16_t GetCategoryCount() const override
Definition: CounterDirectory.hpp:51
armnn::profiling::ReadUint32
uint32_t ReadUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset)
Definition: ProfilingUtils.cpp:204
armnn::profiling::Category::m_Counters
std::vector< uint16_t > m_Counters
Definition: ICounterDirectory.hpp:60
armnn::profiling::CounterDirectory::GetCounter
const Counter * GetCounter(uint16_t uid) const override
Definition: CounterDirectory.cpp:374
armnn::profiling::CounterDirectory::GetCategory
const Category * GetCategory(const std::string &name) const override
Definition: CounterDirectory.cpp:330
armnn::EmptyOptional
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
Definition: Optional.hpp:32
armnn::profiling::CounterDirectory::RegisterDevice
const Device * RegisterDevice(const std::string &deviceName, uint16_t cores=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
Definition: CounterDirectory.cpp:52
armnn::profiling::CounterDirectory::GetCounterCount
uint16_t GetCounterCount() const override
Definition: CounterDirectory.hpp:54
armnn::profiling::CounterDirectory::RegisterCounterSet
const CounterSet * RegisterCounterSet(const std::string &counterSetName, uint16_t count=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
Definition: CounterDirectory.cpp:114
armnn::profiling::CounterDirectory::GetCounterSet
const CounterSet * GetCounterSet(uint16_t uid) const override
Definition: CounterDirectory.cpp:359

◆ BOOST_AUTO_TEST_CASE() [19/33]

BOOST_AUTO_TEST_CASE ( SendCounterDirectoryPacketTest3  )

Definition at line 1607 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), MockCounterDirectory::GetDeviceCount(), MockCounterDirectory::RegisterDevice(), and SendCounterPacket::SendCounterDirectoryPacket().

1608 {
1609  // Using a mock counter directory that allows to register invalid objects
1610  MockCounterDirectory counterDirectory;
1611 
1612  // Register an invalid device
1613  const std::string deviceName = "inv@lid dev!c€";
1614  const Device* device = nullptr;
1615  BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName, 3));
1616  BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
1617  BOOST_CHECK(device);
1618 
1619  // Buffer with enough space
1620  MockBufferManager mockBuffer(1024);
1621  SendCounterPacket sendCounterPacket(mockBuffer);
1622  BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
1623 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::MockCounterDirectory::RegisterDevice
const Device * RegisterDevice(const std::string &deviceName, uint16_t cores=0)
Definition: ProfilingMocks.hpp:462
armnn::profiling::MockCounterDirectory::GetDeviceCount
uint16_t GetDeviceCount() const override
Definition: ProfilingMocks.hpp:570

◆ BOOST_AUTO_TEST_CASE() [20/33]

BOOST_AUTO_TEST_CASE ( SendCounterDirectoryPacketTest4  )

Definition at line 1625 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), MockCounterDirectory::GetCounterSetCount(), MockCounterDirectory::RegisterCounterSet(), and SendCounterPacket::SendCounterDirectoryPacket().

1626 {
1627  // Using a mock counter directory that allows to register invalid objects
1628  MockCounterDirectory counterDirectory;
1629 
1630  // Register an invalid counter set
1631  const std::string counterSetName = "inv@lid count€rs€t";
1632  const CounterSet* counterSet = nullptr;
1633  BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
1634  BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
1635  BOOST_CHECK(counterSet);
1636 
1637  // Buffer with enough space
1638  MockBufferManager mockBuffer(1024);
1639  SendCounterPacket sendCounterPacket(mockBuffer);
1640  BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
1641 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::MockCounterDirectory::GetCounterSetCount
uint16_t GetCounterSetCount() const override
Definition: ProfilingMocks.hpp:571
armnn::profiling::MockCounterDirectory::RegisterCounterSet
const CounterSet * RegisterCounterSet(const std::string &counterSetName, uint16_t count=0)
Definition: ProfilingMocks.hpp:482

◆ BOOST_AUTO_TEST_CASE() [21/33]

BOOST_AUTO_TEST_CASE ( SendCounterDirectoryPacketTest5  )

Definition at line 1643 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), MockCounterDirectory::GetCategoryCount(), MockCounterDirectory::RegisterCategory(), and SendCounterPacket::SendCounterDirectoryPacket().

1644 {
1645  // Using a mock counter directory that allows to register invalid objects
1646  MockCounterDirectory counterDirectory;
1647 
1648  // Register an invalid category
1649  const std::string categoryName = "c@t€gory";
1650  const Category* category = nullptr;
1651  BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
1652  BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
1653  BOOST_CHECK(category);
1654 
1655  // Buffer with enough space
1656  MockBufferManager mockBuffer(1024);
1657  SendCounterPacket sendCounterPacket(mockBuffer);
1658  BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
1659 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::MockCounterDirectory::GetCategoryCount
uint16_t GetCategoryCount() const override
Definition: ProfilingMocks.hpp:569
armnn::profiling::MockCounterDirectory::RegisterCategory
const Category * RegisterCategory(const std::string &categoryName)
Definition: ProfilingMocks.hpp:446

◆ BOOST_AUTO_TEST_CASE() [22/33]

BOOST_AUTO_TEST_CASE ( SendCounterDirectoryPacketTest6  )

Definition at line 1661 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), MockCounterDirectory::GetCategoryCount(), MockCounterDirectory::GetCounterSetCount(), MockCounterDirectory::GetDeviceCount(), MockCounterDirectory::RegisterCategory(), MockCounterDirectory::RegisterCounterSet(), MockCounterDirectory::RegisterDevice(), and SendCounterPacket::SendCounterDirectoryPacket().

1662 {
1663  // Using a mock counter directory that allows to register invalid objects
1664  MockCounterDirectory counterDirectory;
1665 
1666  // Register an invalid device
1667  const std::string deviceName = "inv@lid dev!c€";
1668  const Device* device = nullptr;
1669  BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName, 3));
1670  BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
1671  BOOST_CHECK(device);
1672 
1673  // Register an invalid counter set
1674  const std::string counterSetName = "inv@lid count€rs€t";
1675  const CounterSet* counterSet = nullptr;
1676  BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
1677  BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
1678  BOOST_CHECK(counterSet);
1679 
1680  // Register an invalid category associated to an invalid device and an invalid counter set
1681  const std::string categoryName = "c@t€gory";
1682  const Category* category = nullptr;
1683  BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
1684  BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
1685  BOOST_CHECK(category);
1686 
1687  // Buffer with enough space
1688  MockBufferManager mockBuffer(1024);
1689  SendCounterPacket sendCounterPacket(mockBuffer);
1690  BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
1691 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::MockCounterDirectory::GetCategoryCount
uint16_t GetCategoryCount() const override
Definition: ProfilingMocks.hpp:569
armnn::profiling::MockCounterDirectory::RegisterDevice
const Device * RegisterDevice(const std::string &deviceName, uint16_t cores=0)
Definition: ProfilingMocks.hpp:462
armnn::profiling::MockCounterDirectory::RegisterCategory
const Category * RegisterCategory(const std::string &categoryName)
Definition: ProfilingMocks.hpp:446
armnn::profiling::MockCounterDirectory::GetCounterSetCount
uint16_t GetCounterSetCount() const override
Definition: ProfilingMocks.hpp:571
armnn::profiling::MockCounterDirectory::RegisterCounterSet
const CounterSet * RegisterCounterSet(const std::string &counterSetName, uint16_t count=0)
Definition: ProfilingMocks.hpp:482
armnn::profiling::MockCounterDirectory::GetDeviceCount
uint16_t GetDeviceCount() const override
Definition: ProfilingMocks.hpp:570

◆ BOOST_AUTO_TEST_CASE() [23/33]

BOOST_AUTO_TEST_CASE ( SendCounterDirectoryPacketTest7  )

Definition at line 1693 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), MockCounterDirectory::GetCategoryCount(), MockCounterDirectory::GetCounterCount(), MockCounterDirectory::GetCounterSetCount(), MockCounterDirectory::GetDeviceCount(), Device::m_Uid, CounterSet::m_Uid, MockCounterDirectory::RegisterCategory(), MockCounterDirectory::RegisterCounter(), MockCounterDirectory::RegisterCounterSet(), MockCounterDirectory::RegisterDevice(), and SendCounterPacket::SendCounterDirectoryPacket().

1694 {
1695  // Using a mock counter directory that allows to register invalid objects
1696  MockCounterDirectory counterDirectory;
1697 
1698  // Register an valid device
1699  const std::string deviceName = "valid device";
1700  const Device* device = nullptr;
1701  BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName, 3));
1702  BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
1703  BOOST_CHECK(device);
1704 
1705  // Register an valid counter set
1706  const std::string counterSetName = "valid counterset";
1707  const CounterSet* counterSet = nullptr;
1708  BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
1709  BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
1710  BOOST_CHECK(counterSet);
1711 
1712  // Register an valid category associated to a valid device and a valid counter set
1713  const std::string categoryName = "category";
1714  const Category* category = nullptr;
1715  BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
1716  BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
1717  BOOST_CHECK(category);
1718 
1719  // Register an invalid counter associated to a valid category
1720  const Counter* counter = nullptr;
1721  BOOST_CHECK_NO_THROW(counter = counterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
1722  0,
1723  categoryName,
1724  0,
1725  1,
1726  123.45f,
1727  "counter",
1728  "counter description",
1729  std::string("invalid counter units"),
1730  5,
1731  device->m_Uid,
1732  counterSet->m_Uid));
1733  BOOST_CHECK(counterDirectory.GetCounterCount() == 5);
1734  BOOST_CHECK(counter);
1735 
1736  // Buffer with enough space
1737  MockBufferManager mockBuffer(1024);
1738  SendCounterPacket sendCounterPacket(mockBuffer);
1739  BOOST_CHECK_THROW(sendCounterPacket.SendCounterDirectoryPacket(counterDirectory), armnn::RuntimeException);
1740 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::profiling::MockCounterDirectory::RegisterCounter
const Counter * RegisterCounter(const BackendId &backendId, const uint16_t uid, const std::string &parentCategoryName, uint16_t counterClass, uint16_t interpolation, double multiplier, const std::string &name, const std::string &description, const armnn::Optional< std::string > &units=armnn::EmptyOptional(), const armnn::Optional< uint16_t > &numberOfCores=armnn::EmptyOptional(), const armnn::Optional< uint16_t > &deviceUid=armnn::EmptyOptional(), const armnn::Optional< uint16_t > &counterSetUid=armnn::EmptyOptional())
Definition: ProfilingMocks.hpp:503
armnn::profiling::MockCounterDirectory::GetCategoryCount
uint16_t GetCategoryCount() const override
Definition: ProfilingMocks.hpp:569
armnn::profiling::MockCounterDirectory::RegisterDevice
const Device * RegisterDevice(const std::string &deviceName, uint16_t cores=0)
Definition: ProfilingMocks.hpp:462
armnn::profiling::MockCounterDirectory::RegisterCategory
const Category * RegisterCategory(const std::string &categoryName)
Definition: ProfilingMocks.hpp:446
armnn::profiling::MockCounterDirectory::GetCounterCount
uint16_t GetCounterCount() const override
Definition: ProfilingMocks.hpp:572
armnn::profiling::MockCounterDirectory::GetCounterSetCount
uint16_t GetCounterSetCount() const override
Definition: ProfilingMocks.hpp:571
armnn::profiling::MockCounterDirectory::RegisterCounterSet
const CounterSet * RegisterCounterSet(const std::string &counterSetName, uint16_t count=0)
Definition: ProfilingMocks.hpp:482
armnn::profiling::MockCounterDirectory::GetDeviceCount
uint16_t GetDeviceCount() const override
Definition: ProfilingMocks.hpp:570

◆ BOOST_AUTO_TEST_CASE() [24/33]

BOOST_AUTO_TEST_CASE ( SendThreadTest0  )

Definition at line 1742 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), SendThread::IsRunning(), SendThread::Start(), and SendThread::Stop().

1743 {
1744  ProfilingStateMachine profilingStateMachine;
1745  SetActiveProfilingState(profilingStateMachine);
1746 
1747  MockProfilingConnection mockProfilingConnection;
1748  MockStreamCounterBuffer mockStreamCounterBuffer(0);
1749  SendCounterPacket sendCounterPacket(mockStreamCounterBuffer);
1750  SendThread sendThread(profilingStateMachine, mockStreamCounterBuffer, sendCounterPacket);
1751 
1752  // Try to start the send thread many times, it must only start once
1753 
1754  sendThread.Start(mockProfilingConnection);
1755  BOOST_CHECK(sendThread.IsRunning());
1756  sendThread.Start(mockProfilingConnection);
1757  sendThread.Start(mockProfilingConnection);
1758  sendThread.Start(mockProfilingConnection);
1759  sendThread.Start(mockProfilingConnection);
1760  BOOST_CHECK(sendThread.IsRunning());
1761 
1762  sendThread.Stop();
1763  BOOST_CHECK(!sendThread.IsRunning());
1764 }
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)

◆ BOOST_AUTO_TEST_CASE() [25/33]

BOOST_AUTO_TEST_CASE ( SendThreadTest1  )

Definition at line 1766 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), MockStreamCounterBuffer::GetCommittedSize(), armnn::profiling::GetProcessName(), MockStreamCounterBuffer::GetReadableSize(), MockStreamCounterBuffer::GetReadSize(), armnn::numeric_cast(), SendCounterPacket::SendCounterDirectoryPacket(), SendCounterPacket::SendPeriodicCounterCapturePacket(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), SendCounterPacket::SendStreamMetaDataPacket(), SendThread::SetReadyToRead(), SendThread::Start(), and SendThread::Stop().

1767 {
1768  ProfilingStateMachine profilingStateMachine;
1769  SetActiveProfilingState(profilingStateMachine);
1770 
1771  unsigned int totalWrittenSize = 0;
1772 
1773  MockProfilingConnection mockProfilingConnection;
1774  MockStreamCounterBuffer mockStreamCounterBuffer(1024);
1775  SendCounterPacket sendCounterPacket(mockStreamCounterBuffer);
1776  SendThread sendThread(profilingStateMachine, mockStreamCounterBuffer, sendCounterPacket);
1777  sendThread.Start(mockProfilingConnection);
1778 
1779  // Interleaving writes and reads to/from the buffer with pauses to test that the send thread actually waits for
1780  // something to become available for reading
1781 
1782  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1783 
1784  CounterDirectory counterDirectory;
1785  sendCounterPacket.SendStreamMetaDataPacket();
1786 
1787  // Get the size of the Stream Metadata Packet
1788  std::string processName = GetProcessName().substr(0, 60);
1789  unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<unsigned int>(processName.size()) + 1;
1790  unsigned int streamMetadataPacketsize = 118 + processNameSize;
1791  totalWrittenSize += streamMetadataPacketsize;
1792 
1793  sendThread.SetReadyToRead();
1794 
1795  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1796 
1797  sendCounterPacket.SendCounterDirectoryPacket(counterDirectory);
1798 
1799  // Get the size of the Counter Directory Packet
1800  unsigned int counterDirectoryPacketSize = 32;
1801  totalWrittenSize += counterDirectoryPacketSize;
1802 
1803  sendThread.SetReadyToRead();
1804 
1805  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1806 
1807  sendCounterPacket.SendPeriodicCounterCapturePacket(123u,
1808  {
1809  { 1u, 23u },
1810  { 33u, 1207623u }
1811  });
1812 
1813  // Get the size of the Periodic Counter Capture Packet
1814  unsigned int periodicCounterCapturePacketSize = 28;
1815  totalWrittenSize += periodicCounterCapturePacketSize;
1816 
1817  sendThread.SetReadyToRead();
1818 
1819  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1820 
1821  sendCounterPacket.SendPeriodicCounterCapturePacket(44u,
1822  {
1823  { 211u, 923u }
1824  });
1825 
1826  // Get the size of the Periodic Counter Capture Packet
1827  periodicCounterCapturePacketSize = 22;
1828  totalWrittenSize += periodicCounterCapturePacketSize;
1829 
1830  sendCounterPacket.SendPeriodicCounterCapturePacket(1234u,
1831  {
1832  { 555u, 23u },
1833  { 556u, 6u },
1834  { 557u, 893454u },
1835  { 558u, 1456623u },
1836  { 559u, 571090u }
1837  });
1838 
1839  // Get the size of the Periodic Counter Capture Packet
1840  periodicCounterCapturePacketSize = 46;
1841  totalWrittenSize += periodicCounterCapturePacketSize;
1842 
1843  sendCounterPacket.SendPeriodicCounterCapturePacket(997u,
1844  {
1845  { 88u, 11u },
1846  { 96u, 22u },
1847  { 97u, 33u },
1848  { 999u, 444u }
1849  });
1850 
1851  // Get the size of the Periodic Counter Capture Packet
1852  periodicCounterCapturePacketSize = 40;
1853  totalWrittenSize += periodicCounterCapturePacketSize;
1854 
1855  sendThread.SetReadyToRead();
1856 
1857  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1858 
1859  sendCounterPacket.SendPeriodicCounterSelectionPacket(1000u, { 1345u, 254u, 4536u, 408u, 54u, 6323u, 428u, 1u, 6u });
1860 
1861  // Get the size of the Periodic Counter Capture Packet
1862  periodicCounterCapturePacketSize = 30;
1863  totalWrittenSize += periodicCounterCapturePacketSize;
1864 
1865  sendThread.SetReadyToRead();
1866 
1867  // To test an exact value of the "read size" in the mock buffer, wait to allow the send thread to
1868  // read all what's remaining in the buffer
1869  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1870 
1871  sendThread.Stop();
1872 
1873  BOOST_CHECK(mockStreamCounterBuffer.GetCommittedSize() == totalWrittenSize);
1874  BOOST_CHECK(mockStreamCounterBuffer.GetReadableSize() == totalWrittenSize);
1875  BOOST_CHECK(mockStreamCounterBuffer.GetReadSize() == totalWrittenSize);
1876 }
armnn::profiling::GetProcessName
std::string GetProcessName()
Definition: ProfilingUtils.cpp:299
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33

◆ BOOST_AUTO_TEST_CASE() [26/33]

BOOST_AUTO_TEST_CASE ( SendThreadTest2  )

Definition at line 1878 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), MockStreamCounterBuffer::GetCommittedSize(), armnn::profiling::GetProcessName(), MockStreamCounterBuffer::GetReadableSize(), MockStreamCounterBuffer::GetReadSize(), armnn::numeric_cast(), SendCounterPacket::SendCounterDirectoryPacket(), SendCounterPacket::SendPeriodicCounterCapturePacket(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), SendCounterPacket::SendStreamMetaDataPacket(), SendThread::SetReadyToRead(), SendThread::Start(), and SendThread::Stop().

1879 {
1880  ProfilingStateMachine profilingStateMachine;
1881  SetActiveProfilingState(profilingStateMachine);
1882 
1883  unsigned int totalWrittenSize = 0;
1884 
1885  MockProfilingConnection mockProfilingConnection;
1886  MockStreamCounterBuffer mockStreamCounterBuffer(1024);
1887  SendCounterPacket sendCounterPacket(mockStreamCounterBuffer);
1888  SendThread sendThread(profilingStateMachine, mockStreamCounterBuffer, sendCounterPacket);
1889  sendThread.Start(mockProfilingConnection);
1890 
1891  // Adding many spurious "ready to read" signals throughout the test to check that the send thread is
1892  // capable of handling unnecessary read requests
1893 
1894  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1895 
1896  sendThread.SetReadyToRead();
1897 
1898  CounterDirectory counterDirectory;
1899  sendCounterPacket.SendStreamMetaDataPacket();
1900 
1901  // Get the size of the Stream Metadata Packet
1902  std::string processName = GetProcessName().substr(0, 60);
1903  unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<unsigned int>(processName.size()) + 1;
1904  unsigned int streamMetadataPacketsize = 118 + processNameSize;
1905  totalWrittenSize += streamMetadataPacketsize;
1906 
1907  sendThread.SetReadyToRead();
1908 
1909  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1910 
1911  sendCounterPacket.SendCounterDirectoryPacket(counterDirectory);
1912 
1913  // Get the size of the Counter Directory Packet
1914  unsigned int counterDirectoryPacketSize = 32;
1915  totalWrittenSize += counterDirectoryPacketSize;
1916 
1917  sendThread.SetReadyToRead();
1918  sendThread.SetReadyToRead();
1919 
1920  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1921 
1922  sendCounterPacket.SendPeriodicCounterCapturePacket(123u,
1923  {
1924  { 1u, 23u },
1925  { 33u, 1207623u }
1926  });
1927 
1928  // Get the size of the Periodic Counter Capture Packet
1929  unsigned int periodicCounterCapturePacketSize = 28;
1930  totalWrittenSize += periodicCounterCapturePacketSize;
1931 
1932  sendThread.SetReadyToRead();
1933 
1934  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1935 
1936  sendThread.SetReadyToRead();
1937  sendThread.SetReadyToRead();
1938  sendThread.SetReadyToRead();
1939 
1940  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1941 
1942  sendThread.SetReadyToRead();
1943  sendCounterPacket.SendPeriodicCounterCapturePacket(44u,
1944  {
1945  { 211u, 923u }
1946  });
1947 
1948  // Get the size of the Periodic Counter Capture Packet
1949  periodicCounterCapturePacketSize = 22;
1950  totalWrittenSize += periodicCounterCapturePacketSize;
1951 
1952  sendCounterPacket.SendPeriodicCounterCapturePacket(1234u,
1953  {
1954  { 555u, 23u },
1955  { 556u, 6u },
1956  { 557u, 893454u },
1957  { 558u, 1456623u },
1958  { 559u, 571090u }
1959  });
1960 
1961  // Get the size of the Periodic Counter Capture Packet
1962  periodicCounterCapturePacketSize = 46;
1963  totalWrittenSize += periodicCounterCapturePacketSize;
1964 
1965  sendThread.SetReadyToRead();
1966  sendCounterPacket.SendPeriodicCounterCapturePacket(997u,
1967  {
1968  { 88u, 11u },
1969  { 96u, 22u },
1970  { 97u, 33u },
1971  { 999u, 444u }
1972  });
1973 
1974  // Get the size of the Periodic Counter Capture Packet
1975  periodicCounterCapturePacketSize = 40;
1976  totalWrittenSize += periodicCounterCapturePacketSize;
1977 
1978  sendThread.SetReadyToRead();
1979  sendThread.SetReadyToRead();
1980 
1981  std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_UNTIL_READABLE_MS));
1982 
1983  sendCounterPacket.SendPeriodicCounterSelectionPacket(1000u, { 1345u, 254u, 4536u, 408u, 54u, 6323u, 428u, 1u, 6u });
1984 
1985  // Get the size of the Periodic Counter Capture Packet
1986  periodicCounterCapturePacketSize = 30;
1987  totalWrittenSize += periodicCounterCapturePacketSize;
1988 
1989  sendThread.SetReadyToRead();
1990 
1991  // To test an exact value of the "read size" in the mock buffer, wait to allow the send thread to
1992  // read all what's remaining in the buffer
1993  sendThread.Stop();
1994 
1995  BOOST_CHECK(mockStreamCounterBuffer.GetCommittedSize() == totalWrittenSize);
1996  BOOST_CHECK(mockStreamCounterBuffer.GetReadableSize() == totalWrittenSize);
1997  BOOST_CHECK(mockStreamCounterBuffer.GetReadSize() == totalWrittenSize);
1998 }
armnn::profiling::GetProcessName
std::string GetProcessName()
Definition: ProfilingUtils.cpp:299
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33

◆ BOOST_AUTO_TEST_CASE() [27/33]

BOOST_AUTO_TEST_CASE ( SendThreadTest3  )

Definition at line 2000 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), MockStreamCounterBuffer::GetCommittedSize(), armnn::profiling::GetProcessName(), MockStreamCounterBuffer::GetReadableSize(), MockStreamCounterBuffer::GetReadSize(), armnn::numeric_cast(), SendCounterPacket::SendCounterDirectoryPacket(), SendCounterPacket::SendPeriodicCounterCapturePacket(), SendCounterPacket::SendPeriodicCounterSelectionPacket(), SendCounterPacket::SendStreamMetaDataPacket(), SendThread::SetReadyToRead(), SendThread::Start(), and SendThread::Stop().

2001 {
2002  ProfilingStateMachine profilingStateMachine;
2003  SetActiveProfilingState(profilingStateMachine);
2004 
2005  unsigned int totalWrittenSize = 0;
2006 
2007  MockProfilingConnection mockProfilingConnection;
2008  MockStreamCounterBuffer mockStreamCounterBuffer(1024);
2009  SendCounterPacket sendCounterPacket(mockStreamCounterBuffer);
2010  SendThread sendThread(profilingStateMachine, mockStreamCounterBuffer, sendCounterPacket);
2011  sendThread.Start(mockProfilingConnection);
2012 
2013  // Not using pauses or "grace periods" to stress test the send thread
2014 
2015  sendThread.SetReadyToRead();
2016 
2017  CounterDirectory counterDirectory;
2018  sendCounterPacket.SendStreamMetaDataPacket();
2019 
2020  // Get the size of the Stream Metadata Packet
2021  std::string processName = GetProcessName().substr(0, 60);
2022  unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<unsigned int>(processName.size()) + 1;
2023  unsigned int streamMetadataPacketsize = 118 + processNameSize;
2024  totalWrittenSize += streamMetadataPacketsize;
2025 
2026  sendThread.SetReadyToRead();
2027  sendCounterPacket.SendCounterDirectoryPacket(counterDirectory);
2028 
2029  // Get the size of the Counter Directory Packet
2030  unsigned int counterDirectoryPacketSize =32;
2031  totalWrittenSize += counterDirectoryPacketSize;
2032 
2033  sendThread.SetReadyToRead();
2034  sendThread.SetReadyToRead();
2035  sendCounterPacket.SendPeriodicCounterCapturePacket(123u,
2036  {
2037  { 1u, 23u },
2038  { 33u, 1207623u }
2039  });
2040 
2041  // Get the size of the Periodic Counter Capture Packet
2042  unsigned int periodicCounterCapturePacketSize = 28;
2043  totalWrittenSize += periodicCounterCapturePacketSize;
2044 
2045  sendThread.SetReadyToRead();
2046  sendThread.SetReadyToRead();
2047  sendThread.SetReadyToRead();
2048  sendThread.SetReadyToRead();
2049  sendThread.SetReadyToRead();
2050  sendCounterPacket.SendPeriodicCounterCapturePacket(44u,
2051  {
2052  { 211u, 923u }
2053  });
2054 
2055  // Get the size of the Periodic Counter Capture Packet
2056  periodicCounterCapturePacketSize = 22;
2057  totalWrittenSize += periodicCounterCapturePacketSize;
2058 
2059  sendCounterPacket.SendPeriodicCounterCapturePacket(1234u,
2060  {
2061  { 555u, 23u },
2062  { 556u, 6u },
2063  { 557u, 893454u },
2064  { 558u, 1456623u },
2065  { 559u, 571090u }
2066  });
2067 
2068  // Get the size of the Periodic Counter Capture Packet
2069  periodicCounterCapturePacketSize = 46;
2070  totalWrittenSize += periodicCounterCapturePacketSize;
2071 
2072  sendThread.SetReadyToRead();
2073  sendThread.SetReadyToRead();
2074  sendCounterPacket.SendPeriodicCounterCapturePacket(997u,
2075  {
2076  { 88u, 11u },
2077  { 96u, 22u },
2078  { 97u, 33u },
2079  { 999u, 444u }
2080  });
2081 
2082  // Get the size of the Periodic Counter Capture Packet
2083  periodicCounterCapturePacketSize = 40;
2084  totalWrittenSize += periodicCounterCapturePacketSize;
2085 
2086  sendThread.SetReadyToRead();
2087  sendThread.SetReadyToRead();
2088  sendCounterPacket.SendPeriodicCounterSelectionPacket(1000u, { 1345u, 254u, 4536u, 408u, 54u, 6323u, 428u, 1u, 6u });
2089 
2090  // Get the size of the Periodic Counter Capture Packet
2091  periodicCounterCapturePacketSize = 30;
2092  totalWrittenSize += periodicCounterCapturePacketSize;
2093 
2094  sendThread.SetReadyToRead();
2095 
2096  // Abruptly terminating the send thread, the amount of data sent may be less that the amount written (the send
2097  // thread is not guaranteed to flush the buffer)
2098  sendThread.Stop();
2099 
2100  BOOST_CHECK(mockStreamCounterBuffer.GetCommittedSize() == totalWrittenSize);
2101  BOOST_CHECK(mockStreamCounterBuffer.GetReadableSize() <= totalWrittenSize);
2102  BOOST_CHECK(mockStreamCounterBuffer.GetReadSize() <= totalWrittenSize);
2103  BOOST_CHECK(mockStreamCounterBuffer.GetReadSize() <= mockStreamCounterBuffer.GetReadableSize());
2104  BOOST_CHECK(mockStreamCounterBuffer.GetReadSize() <= mockStreamCounterBuffer.GetCommittedSize());
2105 }
armnn::profiling::GetProcessName
std::string GetProcessName()
Definition: ProfilingUtils.cpp:299
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33

◆ BOOST_AUTO_TEST_CASE() [28/33]

BOOST_AUTO_TEST_CASE ( SendCounterPacketTestWithSendThread  )

Definition at line 2107 of file SendCounterPacketTests.cpp.

References BOOST_CHECK(), MockProfilingConnection::CheckForPacket(), armnn::profiling::GetProcessName(), armnn::numeric_cast(), SendCounterPacket::SendCounterDirectoryPacket(), SendCounterPacket::SendPeriodicCounterCapturePacket(), SendThread::Start(), and SendThread::Stop().

2108 {
2109  ProfilingStateMachine profilingStateMachine;
2110  SetWaitingForAckProfilingState(profilingStateMachine);
2111 
2112  MockProfilingConnection mockProfilingConnection;
2113  BufferManager bufferManager(1, 1024);
2114  SendCounterPacket sendCounterPacket(bufferManager);
2115  SendThread sendThread(profilingStateMachine, bufferManager, sendCounterPacket, -1);
2116  sendThread.Start(mockProfilingConnection);
2117 
2118  std::string processName = GetProcessName().substr(0, 60);
2119  unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<unsigned int>(processName.size()) + 1;
2120  unsigned int streamMetadataPacketsize = 118 + processNameSize;
2121 
2122  sendThread.Stop();
2123 
2124  // check for packet in ProfilingConnection
2125  BOOST_CHECK(mockProfilingConnection.CheckForPacket({PacketType::StreamMetaData, streamMetadataPacketsize}) == 1);
2126 
2127  SetActiveProfilingState(profilingStateMachine);
2128  sendThread.Start(mockProfilingConnection);
2129 
2130  // SendCounterDirectoryPacket
2131  CounterDirectory counterDirectory;
2132  sendCounterPacket.SendCounterDirectoryPacket(counterDirectory);
2133 
2134  sendThread.Stop();
2135  unsigned int counterDirectoryPacketSize = 32;
2136  // check for packet in ProfilingConnection
2137  BOOST_CHECK(mockProfilingConnection.CheckForPacket(
2138  {PacketType::CounterDirectory, counterDirectoryPacketSize}) == 1);
2139 
2140  sendThread.Start(mockProfilingConnection);
2141 
2142  // SendPeriodicCounterCapturePacket
2143  sendCounterPacket.SendPeriodicCounterCapturePacket(123u,
2144  {
2145  { 1u, 23u },
2146  { 33u, 1207623u }
2147  });
2148 
2149  sendThread.Stop();
2150 
2151  unsigned int periodicCounterCapturePacketSize = 28;
2152  BOOST_CHECK(mockProfilingConnection.CheckForPacket(
2153  {PacketType::PeriodicCounterCapture, periodicCounterCapturePacketSize}) == 1);
2154 }
armnn::profiling::GetProcessName
std::string GetProcessName()
Definition: ProfilingUtils.cpp:299
BOOST_CHECK
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33
armnn::profiling::MockProfilingConnection::CheckForPacket
long CheckForPacket(const std::pair< PacketType, uint32_t > packetInfo)
Definition: ProfilingMocks.hpp:106

◆ BOOST_AUTO_TEST_CASE() [29/33]

BOOST_AUTO_TEST_CASE ( SendThreadBufferTest  )

Definition at line 2156 of file SendCounterPacketTests.cpp.

References MockProfilingConnection::CheckForPacket(), BufferManager::Commit(), armnn::profiling::GetProcessName(), BufferManager::GetReadableBuffer(), MockProfilingConnection::GetWrittenDataSize(), armnn::numeric_cast(), BufferManager::Reserve(), SendCounterPacket::SendCounterDirectoryPacket(), SendCounterPacket::SendPeriodicCounterCapturePacket(), SendCounterPacket::SendStreamMetaDataPacket(), SendThread::Start(), SendThread::Stop(), and armnn::profiling::StreamMetaData.

2157 {
2158  ProfilingStateMachine profilingStateMachine;
2159  SetActiveProfilingState(profilingStateMachine);
2160 
2161  MockProfilingConnection mockProfilingConnection;
2162  BufferManager bufferManager(3, 1024);
2163  SendCounterPacket sendCounterPacket(bufferManager);
2164  SendThread sendThread(profilingStateMachine, bufferManager, sendCounterPacket, -1);
2165  sendThread.Start(mockProfilingConnection);
2166 
2167  // SendStreamMetaDataPacket
2168  sendCounterPacket.SendStreamMetaDataPacket();
2169 
2170  // Read data from the buffer
2171  // Buffer should become readable after commit by SendStreamMetaDataPacket
2172  auto packetBuffer = bufferManager.GetReadableBuffer();
2173  BOOST_TEST(packetBuffer.get());
2174 
2175  std::string processName = GetProcessName().substr(0, 60);
2176  unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<unsigned int>(processName.size()) + 1;
2177  unsigned int streamMetadataPacketsize = 118 + processNameSize;
2178  BOOST_TEST(packetBuffer->GetSize() == streamMetadataPacketsize);
2179 
2180  // Recommit to be read by sendCounterPacket
2181  bufferManager.Commit(packetBuffer, streamMetadataPacketsize);
2182 
2183  // SendCounterDirectoryPacket
2184  CounterDirectory counterDirectory;
2185  sendCounterPacket.SendCounterDirectoryPacket(counterDirectory);
2186 
2187  // SendPeriodicCounterCapturePacket
2188  sendCounterPacket.SendPeriodicCounterCapturePacket(123u,
2189  {
2190  { 1u, 23u },
2191  { 33u, 1207623u }
2192  });
2193 
2194  sendThread.Stop();
2195 
2196  // The buffer is read by the send thread so it should not be in the readable buffer.
2197  auto readBuffer = bufferManager.GetReadableBuffer();
2198  BOOST_TEST(!readBuffer);
2199 
2200  // Successfully reserved the buffer with requested size
2201  unsigned int reservedSize = 0;
2202  auto reservedBuffer = bufferManager.Reserve(512, reservedSize);
2203  BOOST_TEST(reservedSize == 512);
2204  BOOST_TEST(reservedBuffer.get());
2205 
2206  const auto writtenDataSize = mockProfilingConnection.GetWrittenDataSize();
2207  const auto metaDataPacketCount =
2208  mockProfilingConnection.CheckForPacket({PacketType::StreamMetaData, streamMetadataPacketsize});
2209 
2210  BOOST_TEST(metaDataPacketCount >= 1);
2211  BOOST_TEST(mockProfilingConnection.CheckForPacket({PacketType::CounterDirectory, 32}) == 1);
2212  BOOST_TEST(mockProfilingConnection.CheckForPacket({PacketType::PeriodicCounterCapture, 28}) == 1);
2213  // Check that we only received the packets we expected
2214  BOOST_TEST(metaDataPacketCount + 2 == writtenDataSize);
2215 }
armnn::profiling::GetProcessName
std::string GetProcessName()
Definition: ProfilingUtils.cpp:299
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33
armnn::profiling::MockProfilingConnection::CheckForPacket
long CheckForPacket(const std::pair< PacketType, uint32_t > packetInfo)
Definition: ProfilingMocks.hpp:106

◆ BOOST_AUTO_TEST_CASE() [30/33]

BOOST_AUTO_TEST_CASE ( SendThreadSendStreamMetadataPacket1  )

Definition at line 2217 of file SendCounterPacketTests.cpp.

References SendThread::Start(), and SendThread::Stop().

2218 {
2219  ProfilingStateMachine profilingStateMachine;
2220 
2221  MockProfilingConnection mockProfilingConnection;
2222  BufferManager bufferManager(3, 1024);
2223  SendCounterPacket sendCounterPacket(bufferManager);
2224  SendThread sendThread(profilingStateMachine, bufferManager, sendCounterPacket);
2225  sendThread.Start(mockProfilingConnection);
2226 
2227  // The profiling state is set to "Uninitialized", so the send thread should throw an exception
2228  BOOST_CHECK_THROW(sendThread.Stop(), armnn::RuntimeException);
2229 }

◆ BOOST_AUTO_TEST_CASE() [31/33]

BOOST_AUTO_TEST_CASE ( SendThreadSendStreamMetadataPacket2  )

Definition at line 2231 of file SendCounterPacketTests.cpp.

References SendThread::Start(), and SendThread::Stop().

2232 {
2233  ProfilingStateMachine profilingStateMachine;
2234  SetNotConnectedProfilingState(profilingStateMachine);
2235 
2236  MockProfilingConnection mockProfilingConnection;
2237  BufferManager bufferManager(3, 1024);
2238  SendCounterPacket sendCounterPacket(bufferManager);
2239  SendThread sendThread(profilingStateMachine, bufferManager, sendCounterPacket);
2240  sendThread.Start(mockProfilingConnection);
2241 
2242  // The profiling state is set to "NotConnected", so the send thread should throw an exception
2243  BOOST_CHECK_THROW(sendThread.Stop(), armnn::RuntimeException);
2244 }

◆ BOOST_AUTO_TEST_CASE() [32/33]

BOOST_AUTO_TEST_CASE ( SendThreadSendStreamMetadataPacket3  )

Definition at line 2246 of file SendCounterPacketTests.cpp.

References MockProfilingConnection::CheckForPacket(), armnn::profiling::GetProcessName(), MockProfilingConnection::GetWrittenDataSize(), armnn::numeric_cast(), SendThread::Start(), and SendThread::Stop().

2247 {
2248  ProfilingStateMachine profilingStateMachine;
2249  SetWaitingForAckProfilingState(profilingStateMachine);
2250 
2251  // Calculate the size of a Stream Metadata packet
2252  std::string processName = GetProcessName().substr(0, 60);
2253  unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<unsigned int>(processName.size()) + 1;
2254  unsigned int streamMetadataPacketsize = 118 + processNameSize;
2255 
2256  MockProfilingConnection mockProfilingConnection;
2257  BufferManager bufferManager(3, 1024);
2258  SendCounterPacket sendCounterPacket(bufferManager);
2259  SendThread sendThread(profilingStateMachine, bufferManager, sendCounterPacket);
2260  sendThread.Start(mockProfilingConnection);
2261 
2262  // The profiling state is set to "WaitingForAck", so the send thread should send a Stream Metadata packet
2263  // Wait for sendThread to join
2264  BOOST_CHECK_NO_THROW(sendThread.Stop());
2265 
2266  // Check that the buffer contains at least one Stream Metadata packet and no other packets
2267  const auto writtenDataSize = mockProfilingConnection.GetWrittenDataSize();
2268 
2269  BOOST_TEST(writtenDataSize >= 1);
2270  BOOST_TEST(mockProfilingConnection.CheckForPacket(
2271  {PacketType::StreamMetaData, streamMetadataPacketsize}) == writtenDataSize);
2272 }
armnn::profiling::GetProcessName
std::string GetProcessName()
Definition: ProfilingUtils.cpp:299
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33
armnn::profiling::MockProfilingConnection::CheckForPacket
long CheckForPacket(const std::pair< PacketType, uint32_t > packetInfo)
Definition: ProfilingMocks.hpp:106

◆ BOOST_AUTO_TEST_CASE() [33/33]

BOOST_AUTO_TEST_CASE ( SendThreadSendStreamMetadataPacket4  )

Definition at line 2274 of file SendCounterPacketTests.cpp.

References BOOST_AUTO_TEST_SUITE_END(), MockProfilingConnection::CheckForPacket(), MockProfilingConnection::Clear(), ProfilingStateMachine::GetCurrentState(), armnn::profiling::GetProcessName(), MockProfilingConnection::GetWrittenDataSize(), armnn::numeric_cast(), SendThread::SetReadyToRead(), SendThread::Start(), SendThread::Stop(), and armnn::profiling::WaitingForAck.

2275 {
2276  ProfilingStateMachine profilingStateMachine;
2277  SetWaitingForAckProfilingState(profilingStateMachine);
2278 
2279  // Calculate the size of a Stream Metadata packet
2280  std::string processName = GetProcessName().substr(0, 60);
2281  unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<unsigned int>(processName.size()) + 1;
2282  unsigned int streamMetadataPacketsize = 118 + processNameSize;
2283 
2284  MockProfilingConnection mockProfilingConnection;
2285  BufferManager bufferManager(3, 1024);
2286  SendCounterPacket sendCounterPacket(bufferManager);
2287  SendThread sendThread(profilingStateMachine, bufferManager, sendCounterPacket);
2288  sendThread.Start(mockProfilingConnection);
2289 
2290  // The profiling state is set to "WaitingForAck", so the send thread should send a Stream Metadata packet
2291  // Wait for sendThread to join
2292  sendThread.Stop();
2293 
2294  sendThread.Start(mockProfilingConnection);
2295  // Check that the profiling state is still "WaitingForAck"
2296  BOOST_TEST((profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck));
2297 
2298  // Check that the buffer contains at least one Stream Metadata packet
2299  BOOST_TEST(mockProfilingConnection.CheckForPacket({PacketType::StreamMetaData, streamMetadataPacketsize}) >= 1);
2300 
2301  mockProfilingConnection.Clear();
2302 
2303  sendThread.Stop();
2304  sendThread.Start(mockProfilingConnection);
2305 
2306  // Try triggering a new buffer read
2307  sendThread.SetReadyToRead();
2308 
2309  // Wait for sendThread to join
2310  BOOST_CHECK_NO_THROW(sendThread.Stop());
2311 
2312  // Check that the profiling state is still "WaitingForAck"
2313  BOOST_TEST((profilingStateMachine.GetCurrentState() == ProfilingState::WaitingForAck));
2314 
2315  // Check that the buffer contains at least one Stream Metadata packet and no other packets
2316  const auto writtenDataSize = mockProfilingConnection.GetWrittenDataSize();
2317 
2318  BOOST_TEST(writtenDataSize >= 1);
2319  BOOST_TEST(mockProfilingConnection.CheckForPacket(
2320  {PacketType::StreamMetaData, streamMetadataPacketsize}) == writtenDataSize);
2321 }
armnn::profiling::GetProcessName
std::string GetProcessName()
Definition: ProfilingUtils.cpp:299
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:33
armnn::profiling::MockProfilingConnection::CheckForPacket
long CheckForPacket(const std::pair< PacketType, uint32_t > packetInfo)
Definition: ProfilingMocks.hpp:106