13 #include <CounterDirectory.hpp> 37 #include <boost/algorithm/string.hpp> 38 #include <boost/numeric/conversion/cast.hpp> 83 BOOST_CHECK(testKey1 == testKey2 && testKey2 == testKey1);
84 BOOST_CHECK(testKey0 == testKey1 && testKey1 == testKey2 && testKey0 == testKey2);
94 std::sort(vect.begin(), vect.end());
140 SendThread sendThread(profilingStateMachine, mockBuffer, sendCounterPacket);
144 sendCounterPacket, sendTimelinePacket,
145 profilingStateMachine);
148 commandHandlerRegistry.
RegisterFunctor(&connectionAcknowledgedCommandHandler);
153 CommandHandler commandHandler0(1,
true, commandHandlerRegistry, packetVersionResolver);
157 commandHandler0.
Start(testProfilingConnectionBase);
159 commandHandler0.
Start(testProfilingConnectionBase);
162 for (
int i = 0; i < 10; i++)
168 std::this_thread::sleep_for(std::chrono::milliseconds(2));
174 commandHandler0.
Stop();
181 CommandHandler commandHandler1(1,
true, commandHandlerRegistry, packetVersionResolver);
183 commandHandler1.
Start(testProfilingConnectionTimeOutError);
185 for (
int i = 0; i < 10; i++)
191 std::this_thread::sleep_for(std::chrono::milliseconds(2));
196 uint32_t timeout = 50;
197 uint32_t timeSlept = 0;
200 if (timeSlept >= timeout)
202 BOOST_FAIL(
"Timeout: The command handler loop did not stop after the timeout");
204 std::this_thread::sleep_for(std::chrono::milliseconds(1));
208 commandHandler1.
Stop();
214 commandHandler1.
Start(testProfilingConnectionBadAckPacket);
215 commandHandler1.
Stop();
222 commandHandler1.
Start(testProfilingConnectionTimeOutError);
225 for (
int i = 0; i < 10; i++)
231 std::this_thread::sleep_for(std::chrono::milliseconds(2));
233 commandHandler1.
Stop();
239 CommandHandler commandHandler2(1,
false, commandHandlerRegistry, packetVersionResolver);
241 commandHandler2.Start(testProfilingConnectionArmnnError);
244 for (
int i = 0; i < 10; i++)
250 std::this_thread::sleep_for(std::chrono::milliseconds(2));
254 commandHandler2.Stop();
284 BOOST_CHECK(version5.GetEncodedValue() == 4194304);
290 std::unique_ptr<unsigned char[]> packetData0 = std::make_unique<unsigned char[]>(length);
291 std::unique_ptr<unsigned char[]> packetData1 = std::make_unique<unsigned char[]>(0);
292 std::unique_ptr<unsigned char[]> nullPacketData;
294 Packet packetTest0(472580096, length, packetData0);
304 BOOST_CHECK_NO_THROW(
Packet packetTest2(472580096, 0, nullPacketData));
306 Packet packetTest3(472580096, 0, nullPacketData);
310 const unsigned char* packetTest0Data = packetTest0.
GetData();
311 Packet packetTest4(std::move(packetTest0));
327 uint32_t version = 1;
338 std::map<CommandHandlerKey, CommandHandlerFunctor*> registry;
340 registry.insert(std::make_pair(keyB, &testFunctorB));
341 registry.insert(std::make_pair(keyA, &testFunctorA));
342 registry.insert(std::make_pair(keyC, &testFunctorC));
345 auto it = registry.begin();
352 std::unique_ptr<unsigned char[]> packetDataA;
353 std::unique_ptr<unsigned char[]> packetDataB;
354 std::unique_ptr<unsigned char[]> packetDataC;
356 Packet packetA(500000000, 0, packetDataA);
357 Packet packetB(600000000, 0, packetDataB);
358 Packet packetC(400000000, 0, packetDataC);
380 uint32_t version = 1;
394 std::unique_ptr<unsigned char[]> packetDataA;
395 std::unique_ptr<unsigned char[]> packetDataB;
396 std::unique_ptr<unsigned char[]> packetDataC;
398 Packet packetA(500000000, 0, packetDataA);
399 Packet packetB(600000000, 0, packetDataB);
400 Packet packetC(400000000, 0, packetDataC);
432 std::random_device device;
433 std::mt19937 generator(device());
434 std::uniform_int_distribution<uint32_t> distribution(std::numeric_limits<uint32_t>::min(),
435 std::numeric_limits<uint32_t>::max());
438 const Version expectedVersion(1, 0, 0);
442 constexpr
unsigned int numTests = 10u;
444 for (
unsigned int i = 0u; i < numTests; ++i)
446 const uint32_t familyId = distribution(generator);
447 const uint32_t packetId = distribution(generator);
450 BOOST_TEST(resolvedVersion == expectedVersion);
549 std::map<uint32_t, std::vector<uint16_t>> periodIdMap;
550 std::vector<uint16_t> counterIds;
551 uint32_t numThreads = 10;
552 for (uint32_t i = 0; i < numThreads; ++i)
554 counterIds.emplace_back(i);
555 periodIdMap.insert(std::make_pair(i, counterIds));
579 BOOST_CHECK(captureData.GetCounterIds() == periodIdMap[2]);
581 std::map<uint32_t, CaptureData> captureDataIdMap;
582 for (uint32_t i = 0; i < numThreads; ++i)
585 captureDataIdMap.insert(std::make_pair(i, perThreadCaptureData));
588 std::vector<std::thread> threadsVect;
589 std::vector<std::thread> readThreadsVect;
590 for (uint32_t i = 0; i < numThreads; ++i)
592 threadsVect.emplace_back(
596 BOOST_CHECK(captureDataIdMap.at(i).GetCapturePeriod() == 0);
597 BOOST_CHECK(captureDataIdMap.at(i).GetCounterIds().empty());
598 readThreadsVect.emplace_back(
602 for (uint32_t i = 0; i < numThreads; ++i)
604 threadsVect[i].join();
605 readThreadsVect[i].join();
610 for (uint32_t i = 0; i < numThreads; ++i)
612 CaptureData perThreadCaptureData = captureDataIdMap.at(i);
620 std::vector<uint16_t> counterIds = { 42, 29, 13 };
632 secondCaptureData = captureData;
633 BOOST_CHECK(secondCaptureData.GetCapturePeriod() == 150);
634 BOOST_CHECK(secondCaptureData.GetCounterIds() == counterIds);
637 CaptureData copyConstructedCaptureData(captureData);
639 BOOST_CHECK(copyConstructedCaptureData.GetCapturePeriod() == 150);
640 BOOST_CHECK(copyConstructedCaptureData.GetCounterIds() == counterIds);
645 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
649 profilingService.
Update();
655 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
661 profilingService.
Update();
664 options.m_EnableProfiling =
true;
669 profilingService.
Update();
672 options.m_EnableProfiling =
false;
678 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
679 options.m_EnableProfiling =
true;
683 profilingService.
Update();
691 std::vector<std::thread> writers;
693 for (
int i = 0; i < 100; ++i)
698 armnn::profiling::REGISTERED_BACKENDS));
702 armnn::profiling::UNREGISTERED_BACKENDS));
707 armnn::profiling::INFERENCES_RUN,
711 armnn::profiling::INFERENCES_RUN,
714 std::for_each(writers.begin(), writers.end(), mem_fn(&std::thread::join));
716 uint32_t counterValue = 0;
718 (profilingService.
GetCounterValue(armnn::profiling::UNREGISTERED_BACKENDS)
719 - profilingService.
GetCounterValue(armnn::profiling::REGISTERED_BACKENDS)));
722 BOOST_CHECK_NO_THROW(profilingService.
SetCounterValue(armnn::profiling::UNREGISTERED_BACKENDS, 4));
723 BOOST_CHECK_NO_THROW(counterValue = profilingService.
GetCounterValue(armnn::profiling::UNREGISTERED_BACKENDS));
726 options.m_EnableProfiling =
false;
736 uint16_t nextUid = 0;
740 std::vector<uint16_t> counterUids;
744 std::vector<uint16_t> nextCounterUids;
749 std::vector<uint16_t> counterUidsMultiCore;
750 uint16_t thirdUid = 4;
751 uint16_t numberOfCores = 13;
752 BOOST_CHECK_NO_THROW(counterUidsMultiCore =
GetNextCounterUids(thirdUid, numberOfCores));
753 BOOST_CHECK(counterUidsMultiCore.size() == numberOfCores);
754 BOOST_CHECK(counterUidsMultiCore.front() >= nextCounterUids[0]);
755 for (
size_t i = 1; i < numberOfCores; i++)
757 BOOST_CHECK(counterUidsMultiCore[i] == counterUidsMultiCore[i - 1] + 1);
759 BOOST_CHECK(counterUidsMultiCore.back() == counterUidsMultiCore.front() + numberOfCores - 1);
771 const Category* noCategory =
nullptr;
777 BOOST_CHECK_THROW(noCategory = counterDirectory.
RegisterCategory(
"invalid category"),
783 const std::string categoryName =
"some_category";
785 BOOST_CHECK_NO_THROW(category = counterDirectory.
RegisterCategory(categoryName));
800 const Category* notRegisteredCategory = counterDirectory.
GetCategory(
"not_registered_category");
805 const Category* anotherCategory =
nullptr;
806 BOOST_CHECK_THROW(anotherCategory = counterDirectory.
RegisterCategory(categoryName),
812 const std::string deviceName =
"some_device";
813 const Device* device =
nullptr;
814 BOOST_CHECK_NO_THROW(device = counterDirectory.
RegisterDevice(deviceName));
822 const std::string categoryWoDeviceName =
"some_category_without_device";
823 const Category* categoryWoDevice =
nullptr;
824 BOOST_CHECK_NO_THROW(categoryWoDevice = counterDirectory.
RegisterCategory(categoryWoDeviceName, 0));
833 const std::string categoryWInvalidDeviceName =
"some_category_with_invalid_device";
836 uint16_t invalidDeviceUid = device->
m_Uid + 10;
839 const Category* categoryWInvalidDevice =
nullptr;
840 BOOST_CHECK_THROW(categoryWInvalidDevice =
841 counterDirectory.
RegisterCategory(categoryWInvalidDeviceName, invalidDeviceUid),
847 const std::string categoryWValidDeviceName =
"some_category_with_valid_device";
848 const Category* categoryWValidDevice =
nullptr;
849 BOOST_CHECK_NO_THROW(categoryWValidDevice =
859 const std::string counterSetName =
"some_counter_set";
861 BOOST_CHECK_NO_THROW(counterSet = counterDirectory.
RegisterCounterSet(counterSetName));
869 const std::string categoryWoCounterSetName =
"some_category_without_counter_set";
870 const Category* categoryWoCounterSet =
nullptr;
871 BOOST_CHECK_NO_THROW(categoryWoCounterSet =
880 const std::string categoryWInvalidCounterSetName =
"some_category_with_invalid_counter_set";
883 uint16_t invalidCunterSetUid = counterSet->
m_Uid + 10;
886 const Category* categoryWInvalidCounterSet =
nullptr;
887 BOOST_CHECK_THROW(categoryWInvalidCounterSet = counterDirectory.
RegisterCategory(
894 const std::string categoryWValidCounterSetName =
"some_category_with_valid_counter_set";
895 const Category* categoryWValidCounterSet =
nullptr;
896 BOOST_CHECK_NO_THROW(categoryWValidCounterSet = counterDirectory.
RegisterCategory(
906 const std::string categoryWValidDeviceAndValidCounterSetName =
"some_category_with_valid_device_and_counter_set";
907 const Category* categoryWValidDeviceAndValidCounterSet =
nullptr;
908 BOOST_CHECK_NO_THROW(categoryWValidDeviceAndValidCounterSet = counterDirectory.
RegisterCategory(
909 categoryWValidDeviceAndValidCounterSetName, device->
m_Uid, counterSet->
m_Uid));
911 BOOST_CHECK(categoryWValidDeviceAndValidCounterSet);
912 BOOST_CHECK(categoryWValidDeviceAndValidCounterSet != category);
913 BOOST_CHECK(categoryWValidDeviceAndValidCounterSet->
m_Name == categoryWValidDeviceAndValidCounterSetName);
927 const Device* noDevice =
nullptr;
938 const std::string deviceName =
"some_device";
939 const Device* device =
nullptr;
940 BOOST_CHECK_NO_THROW(device = counterDirectory.
RegisterDevice(deviceName));
958 const Device* deviceSameName =
nullptr;
964 const std::string deviceWCoresName =
"some_device_with_cores";
965 const Device* deviceWCores =
nullptr;
966 BOOST_CHECK_NO_THROW(deviceWCores = counterDirectory.
RegisterDevice(deviceWCoresName, 2));
978 BOOST_CHECK(registeredDeviceWCores == deviceWCores);
982 const std::string deviceWCoresWInvalidParentCategoryName =
"some_device_with_cores_with_invalid_parent_category";
983 const Device* deviceWCoresWInvalidParentCategory =
nullptr;
984 BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory =
985 counterDirectory.
RegisterDevice(deviceWCoresWInvalidParentCategoryName, 3, std::string(
"")),
991 const std::string deviceWCoresWInvalidParentCategoryName2 =
"some_device_with_cores_with_invalid_parent_category2";
992 const Device* deviceWCoresWInvalidParentCategory2 =
nullptr;
993 BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory2 = counterDirectory.
RegisterDevice(
994 deviceWCoresWInvalidParentCategoryName2, 3, std::string(
"invalid_parent_category")),
1000 const std::string categoryName =
"some_category";
1001 const Category* category =
nullptr;
1002 BOOST_CHECK_NO_THROW(category = counterDirectory.
RegisterCategory(categoryName));
1011 const std::string deviceWCoresWValidParentCategoryName =
"some_device_with_cores_with_valid_parent_category";
1012 const Device* deviceWCoresWValidParentCategory =
nullptr;
1013 BOOST_CHECK_NO_THROW(deviceWCoresWValidParentCategory =
1014 counterDirectory.
RegisterDevice(deviceWCoresWValidParentCategoryName, 4, categoryName));
1017 BOOST_CHECK(deviceWCoresWValidParentCategory->
m_Name == deviceWCoresWValidParentCategoryName);
1025 const std::string deviceSameCategoryName =
"some_device_with_invalid_parent_category";
1026 const Device* deviceSameCategory =
nullptr;
1027 BOOST_CHECK_THROW(deviceSameCategory = counterDirectory.
RegisterDevice(deviceSameCategoryName, 0, categoryName),
1048 BOOST_CHECK_THROW(noCounterSet = counterDirectory.
RegisterCounterSet(
"invalid name"),
1054 const std::string counterSetName =
"some_counter_set";
1056 BOOST_CHECK_NO_THROW(counterSet = counterDirectory.
RegisterCounterSet(counterSetName));
1074 const CounterSet* counterSetSameName =
nullptr;
1075 BOOST_CHECK_THROW(counterSetSameName = counterDirectory.
RegisterCounterSet(counterSetName),
1081 const std::string counterSetWCountName =
"some_counter_set_with_count";
1082 const CounterSet* counterSetWCount =
nullptr;
1083 BOOST_CHECK_NO_THROW(counterSetWCount = counterDirectory.
RegisterCounterSet(counterSetWCountName, 37));
1095 BOOST_CHECK(registeredCounterSetWCount == counterSetWCount);
1096 BOOST_CHECK(registeredCounterSetWCount != counterSet);
1099 const std::string counterSetWCountWInvalidParentCategoryName =
"some_counter_set_with_count_" 1100 "with_invalid_parent_category";
1101 const CounterSet* counterSetWCountWInvalidParentCategory =
nullptr;
1102 BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory = counterDirectory.
RegisterCounterSet(
1103 counterSetWCountWInvalidParentCategoryName, 42, std::string(
"")),
1106 BOOST_CHECK(!counterSetWCountWInvalidParentCategory);
1109 const std::string counterSetWCountWInvalidParentCategoryName2 =
"some_counter_set_with_count_" 1110 "with_invalid_parent_category2";
1111 const CounterSet* counterSetWCountWInvalidParentCategory2 =
nullptr;
1112 BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory2 = counterDirectory.
RegisterCounterSet(
1113 counterSetWCountWInvalidParentCategoryName2, 42, std::string(
"invalid_parent_category")),
1116 BOOST_CHECK(!counterSetWCountWInvalidParentCategory2);
1119 const std::string categoryName =
"some_category";
1120 const Category* category =
nullptr;
1121 BOOST_CHECK_NO_THROW(category = counterDirectory.
RegisterCategory(categoryName));
1130 const std::string counterSetWCountWValidParentCategoryName =
"some_counter_set_with_count_" 1131 "with_valid_parent_category";
1132 const CounterSet* counterSetWCountWValidParentCategory =
nullptr;
1133 BOOST_CHECK_NO_THROW(counterSetWCountWValidParentCategory = counterDirectory.
RegisterCounterSet(
1134 counterSetWCountWValidParentCategoryName, 42, categoryName));
1136 BOOST_CHECK(counterSetWCountWValidParentCategory);
1137 BOOST_CHECK(counterSetWCountWValidParentCategory->
m_Name == counterSetWCountWValidParentCategoryName);
1145 const std::string counterSetSameCategoryName =
"some_counter_set_with_invalid_parent_category";
1146 const CounterSet* counterSetSameCategory =
nullptr;
1147 BOOST_CHECK_THROW(counterSetSameCategory =
1163 const Counter* noCounter =
nullptr;
1164 BOOST_CHECK_THROW(noCounter =
1178 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1180 "invalid parent category",
1185 "valid description"),
1191 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1193 "valid_parent_category",
1199 "valid description"),
1205 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1207 "valid_parent_category",
1213 "valid description"),
1219 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1221 "valid_parent_category",
1227 "valid description"),
1234 noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1236 "valid_parent_category",
1241 "valid description"),
1247 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1249 "valid_parent_category",
1254 "valid description"),
1260 BOOST_CHECK_THROW(noCounter =
1263 "valid_parent_category",
1274 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1276 "valid_parent_category",
1282 "inv@lid description"),
1288 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1290 "valid_parent_category",
1295 "valid description",
1296 std::string(
"Mb/s2")),
1302 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1304 "invalid_parent_category",
1309 "valid description"),
1319 const std::string categoryName =
"some_category";
1320 const Category* category =
nullptr;
1321 BOOST_CHECK_NO_THROW(category = counterDirectory.
RegisterCategory(categoryName));
1330 const Counter* counter =
nullptr;
1331 BOOST_CHECK_NO_THROW(
1332 counter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1339 "valid description"));
1355 const Counter* counterSameName =
nullptr;
1356 BOOST_CHECK_THROW(counterSameName =
1364 "valid description",
1365 std::string(
"description")),
1371 const Counter* counterWUnits =
nullptr;
1372 BOOST_CHECK_NO_THROW(counterWUnits = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1379 "valid description",
1380 std::string(
"Mnnsq2")));
1397 const Counter* counterWoDevice =
nullptr;
1398 BOOST_CHECK_NO_THROW(counterWoDevice = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1405 "valid description",
1412 BOOST_CHECK(counterWoDevice->m_MaxCounterUid == counterWoDevice->m_Uid);
1414 BOOST_CHECK(counterWoDevice->m_Interpolation == 1);
1415 BOOST_CHECK(counterWoDevice->m_Multiplier == 123.45f);
1416 BOOST_CHECK(counterWoDevice->m_Name ==
"valid name 3");
1417 BOOST_CHECK(counterWoDevice->m_Description ==
"valid description");
1420 BOOST_CHECK(counterWoDevice->m_CounterSetUid == 0);
1425 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1432 "valid description",
1441 const std::string deviceName =
"some_device";
1442 const Device* device =
nullptr;
1443 BOOST_CHECK_NO_THROW(device = counterDirectory.
RegisterDevice(deviceName));
1451 const Counter* counterWDevice =
nullptr;
1452 BOOST_CHECK_NO_THROW(counterWDevice = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1459 std::string(
"valid description"),
1479 const Counter* counterWoCounterSet =
nullptr;
1480 BOOST_CHECK_NO_THROW(counterWoCounterSet = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1487 "valid description",
1495 BOOST_CHECK(counterWoCounterSet->m_MaxCounterUid == counterWoCounterSet->m_Uid);
1497 BOOST_CHECK(counterWoCounterSet->m_Interpolation == 1);
1498 BOOST_CHECK(counterWoCounterSet->m_Multiplier == 123.45f);
1499 BOOST_CHECK(counterWoCounterSet->m_Name ==
"valid name 6");
1500 BOOST_CHECK(counterWoCounterSet->m_Description ==
"valid description");
1502 BOOST_CHECK(counterWoCounterSet->m_DeviceUid == 0);
1503 BOOST_CHECK(counterWoCounterSet->m_CounterSetUid == 0);
1508 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1516 std::string(
"valid description"),
1525 const Counter* counterWNumberOfCores =
nullptr;
1526 uint16_t numberOfCores = 15;
1527 BOOST_CHECK_NO_THROW(counterWNumberOfCores = counterDirectory.
RegisterCounter(
1528 armnn::profiling::BACKEND_ID, 50,
1529 categoryName, 0, 1, 123.45f,
"valid name 8",
"valid description",
1547 for (
size_t i = 0; i < numberOfCores; i++)
1550 counterWNumberOfCores->
m_Uid + i);
1554 const std::string multiCoreDeviceName =
"some_multi_core_device";
1555 const Device* multiCoreDevice =
nullptr;
1556 BOOST_CHECK_NO_THROW(multiCoreDevice = counterDirectory.
RegisterDevice(multiCoreDeviceName, 4));
1564 const Counter* counterWMultiCoreDevice =
nullptr;
1565 BOOST_CHECK_NO_THROW(counterWMultiCoreDevice = counterDirectory.
RegisterCounter(
1566 armnn::profiling::BACKEND_ID, 19, categoryName, 0, 1,
1567 123.45f,
"valid name 9",
"valid description",
1570 multiCoreDevice->
m_Uid,
1576 counterWMultiCoreDevice->
m_Uid + multiCoreDevice->
m_Cores - 1);
1586 for (
size_t i = 0; i < 4; i++)
1592 const std::string multiCoreDeviceNameWParentCategory =
"some_multi_core_device_with_parent_category";
1593 const Device* multiCoreDeviceWParentCategory =
nullptr;
1594 BOOST_CHECK_NO_THROW(multiCoreDeviceWParentCategory =
1595 counterDirectory.
RegisterDevice(multiCoreDeviceNameWParentCategory, 2, categoryName));
1598 BOOST_CHECK(multiCoreDeviceWParentCategory->
m_Name == multiCoreDeviceNameWParentCategory);
1604 const Counter* counterWMultiCoreDeviceWParentCategory =
nullptr;
1605 BOOST_CHECK_NO_THROW(counterWMultiCoreDeviceWParentCategory =
1613 "valid description",
1619 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory);
1622 counterWMultiCoreDeviceWParentCategory->
m_Uid + multiCoreDeviceWParentCategory->
m_Cores - 1);
1632 for (
size_t i = 0; i < 2; i++)
1635 counterWMultiCoreDeviceWParentCategory->
m_Uid + i);
1639 const std::string counterSetName =
"some_counter_set";
1641 BOOST_CHECK_NO_THROW(counterSet = counterDirectory.
RegisterCounterSet(counterSetName));
1649 const Counter* counterWCounterSet =
nullptr;
1650 BOOST_CHECK_NO_THROW(counterWCounterSet = counterDirectory.
RegisterCounter(
1651 armnn::profiling::BACKEND_ID, 300,
1652 categoryName, 0, 1, 123.45f,
"valid name 11",
"valid description",
1656 counterSet->
m_Uid));
1673 const Counter* counterWDeviceWCounterSet =
nullptr;
1674 BOOST_CHECK_NO_THROW(counterWDeviceWCounterSet = counterDirectory.
RegisterCounter(
1675 armnn::profiling::BACKEND_ID, 23,
1676 categoryName, 0, 1, 123.45f,
"valid name 12",
"valid description",
1680 counterSet->
m_Uid));
1684 BOOST_CHECK(counterWDeviceWCounterSet->m_MaxCounterUid == counterWDeviceWCounterSet->m_Uid);
1685 BOOST_CHECK(counterWDeviceWCounterSet->m_Class == 0);
1686 BOOST_CHECK(counterWDeviceWCounterSet->m_Interpolation == 1);
1687 BOOST_CHECK(counterWDeviceWCounterSet->m_Multiplier == 123.45f);
1688 BOOST_CHECK(counterWDeviceWCounterSet->m_Name ==
"valid name 12");
1689 BOOST_CHECK(counterWDeviceWCounterSet->m_Description ==
"valid description");
1690 BOOST_CHECK(counterWDeviceWCounterSet->m_Units ==
"");
1692 BOOST_CHECK(counterWDeviceWCounterSet->m_CounterSetUid == counterSet->
m_Uid);
1697 const std::string anotherCategoryName =
"some_other_category";
1698 const Category* anotherCategory =
nullptr;
1699 BOOST_CHECK_NO_THROW(anotherCategory = counterDirectory.
RegisterCategory(anotherCategoryName));
1709 const Counter* anotherCounter =
nullptr;
1710 BOOST_CHECK_NO_THROW(anotherCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID, 24,
1711 anotherCategoryName, 1, 0, .00043f,
1712 "valid name",
"valid description",
1716 counterSet->
m_Uid));
1734 using boost::numeric_cast;
1740 void Start()
override 1742 void Stop()
override 1748 bool IsCounterRegistered(uint16_t counterUid)
const override 1750 boost::ignore_unused(counterUid);
1753 uint16_t GetCounterCount()
const override 1757 uint32_t GetCounterValue(uint16_t counterUid)
const override 1759 boost::ignore_unused(counterUid);
1763 const uint32_t familyId = 0;
1764 const uint32_t packetId = 0x40000;
1766 uint32_t version = 1;
1768 std::shared_ptr<armnn::profiling::IBackendProfilingContext>> backendProfilingContext;
1771 TestCaptureThread captureThread;
1772 TestReadCounterValues readCounterValues;
1775 SendThread sendThread(profilingStateMachine, mockBuffer, sendCounterPacket);
1777 uint32_t sizeOfUint32 = numeric_cast<uint32_t>(
sizeof(uint32_t));
1778 uint32_t sizeOfUint16 = numeric_cast<uint32_t>(
sizeof(uint16_t));
1782 uint32_t dataLength1 = 8;
1783 uint32_t offset = 0;
1785 std::unique_ptr<unsigned char[]> uniqueData1 = std::make_unique<unsigned char[]>(dataLength1);
1786 unsigned char* data1 =
reinterpret_cast<unsigned char*
>(uniqueData1.get());
1789 offset += sizeOfUint32;
1791 offset += sizeOfUint16;
1794 Packet packetA(packetId, dataLength1, uniqueData1);
1797 counterIdMap, holder, 10000u, captureThread,
1798 readCounterValues, sendCounterPacket, profilingStateMachine);
1807 BOOST_CHECK_NO_THROW(commandHandler(packetA));
1812 BOOST_TEST(counterIdsA.size() == 2);
1813 BOOST_TEST(counterIdsA[0] == 4000);
1814 BOOST_TEST(counterIdsA[1] == 5000);
1820 uint32_t headerWord0 =
ReadUint32(readBuffer, offset);
1821 offset += sizeOfUint32;
1822 uint32_t headerWord1 =
ReadUint32(readBuffer, offset);
1823 offset += sizeOfUint32;
1824 uint32_t period =
ReadUint32(readBuffer, offset);
1826 BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);
1827 BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4);
1828 BOOST_TEST(headerWord1 == 8);
1831 uint16_t counterId = 0;
1832 offset += sizeOfUint32;
1834 BOOST_TEST(counterId == 4000);
1835 offset += sizeOfUint16;
1837 BOOST_TEST(counterId == 5000);
1842 uint32_t period2 = 9000;
1843 uint32_t dataLength2 = 4;
1845 std::unique_ptr<unsigned char[]> uniqueData2 = std::make_unique<unsigned char[]>(dataLength2);
1847 WriteUint32(reinterpret_cast<unsigned char*>(uniqueData2.get()), 0, period2);
1849 Packet packetB(packetId, dataLength2, uniqueData2);
1851 commandHandler(packetB);
1857 BOOST_TEST(counterIdsB.size() == 0);
1863 headerWord0 =
ReadUint32(readBuffer, offset);
1864 offset += sizeOfUint32;
1865 headerWord1 =
ReadUint32(readBuffer, offset);
1866 offset += sizeOfUint32;
1869 BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);
1870 BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4);
1871 BOOST_TEST(headerWord1 == 4);
1877 using boost::numeric_cast;
1879 const uint32_t packetFamilyId = 0;
1880 const uint32_t connectionPacketId = 0x10000;
1881 const uint32_t version = 1;
1883 uint32_t sizeOfUint32 = numeric_cast<uint32_t>(
sizeof(uint32_t));
1884 uint32_t sizeOfUint16 = numeric_cast<uint32_t>(
sizeof(uint16_t));
1887 uint32_t period1 = 10;
1888 uint32_t dataLength1 = 8;
1889 uint32_t offset = 0;
1891 std::unique_ptr<unsigned char[]> uniqueData1 = std::make_unique<unsigned char[]>(dataLength1);
1892 unsigned char* data1 =
reinterpret_cast<unsigned char*
>(uniqueData1.get());
1895 offset += sizeOfUint32;
1897 offset += sizeOfUint16;
1900 Packet packetA(connectionPacketId, dataLength1, uniqueData1);
1907 SendThread sendThread(profilingState, mockBuffer, sendCounterPacket);
1911 sendCounterPacket, sendTimelinePacket, profilingState);
1924 BOOST_CHECK_NO_THROW(commandHandler(packetA));
1928 BOOST_CHECK_NO_THROW(commandHandler(packetA));
1932 const uint32_t differentPacketId = 0x40000;
1933 Packet packetB(differentPacketId, dataLength1, uniqueData1);
1937 counterDirectory, sendCounterPacket,
1938 sendTimelinePacket, profilingState);
1951 for (
unsigned char c = 0; c < 128; c++)
1957 for (
unsigned char c = 255; c >= 128; c++)
1966 const unsigned char validChars[] =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
1967 for (
unsigned char i = 0; i <
sizeof(validChars) /
sizeof(validChars[0]) - 1; i++)
1973 for (
unsigned char c = 0; c < 48; c++)
1977 for (
unsigned char c = 58; c < 65; c++)
1981 for (
unsigned char c = 91; c < 95; c++)
1985 for (
unsigned char c = 96; c < 97; c++)
1989 for (
unsigned char c = 123; c < 128; c++)
1995 for (
unsigned char c = 255; c >= 128; c++)
2004 BOOST_CHECK(IsValidSwTraceString<SwTraceCharPolicy>(
""));
2005 BOOST_CHECK(IsValidSwTraceString<SwTraceCharPolicy>(
"_"));
2006 BOOST_CHECK(IsValidSwTraceString<SwTraceCharPolicy>(
"0123"));
2007 BOOST_CHECK(IsValidSwTraceString<SwTraceCharPolicy>(
"valid_string"));
2008 BOOST_CHECK(IsValidSwTraceString<SwTraceCharPolicy>(
"VALID_string_456"));
2009 BOOST_CHECK(IsValidSwTraceString<SwTraceCharPolicy>(
" "));
2010 BOOST_CHECK(IsValidSwTraceString<SwTraceCharPolicy>(
"valid string"));
2011 BOOST_CHECK(IsValidSwTraceString<SwTraceCharPolicy>(
"!$%"));
2012 BOOST_CHECK(IsValidSwTraceString<SwTraceCharPolicy>(
"valid|\\~string#123"));
2015 BOOST_CHECK(!IsValidSwTraceString<SwTraceCharPolicy>(
"€£"));
2016 BOOST_CHECK(!IsValidSwTraceString<SwTraceCharPolicy>(
"invalid‡string"));
2017 BOOST_CHECK(!IsValidSwTraceString<SwTraceCharPolicy>(
"12Ž34"));
2023 BOOST_CHECK(IsValidSwTraceString<SwTraceNameCharPolicy>(
""));
2024 BOOST_CHECK(IsValidSwTraceString<SwTraceNameCharPolicy>(
"_"));
2025 BOOST_CHECK(IsValidSwTraceString<SwTraceNameCharPolicy>(
"0123"));
2026 BOOST_CHECK(IsValidSwTraceString<SwTraceNameCharPolicy>(
"valid_string"));
2027 BOOST_CHECK(IsValidSwTraceString<SwTraceNameCharPolicy>(
"VALID_string_456"));
2030 BOOST_CHECK(!IsValidSwTraceString<SwTraceNameCharPolicy>(
" "));
2031 BOOST_CHECK(!IsValidSwTraceString<SwTraceNameCharPolicy>(
"invalid string"));
2032 BOOST_CHECK(!IsValidSwTraceString<SwTraceNameCharPolicy>(
"!$%"));
2033 BOOST_CHECK(!IsValidSwTraceString<SwTraceNameCharPolicy>(
"invalid|\\~string#123"));
2034 BOOST_CHECK(!IsValidSwTraceString<SwTraceNameCharPolicy>(
"€£"));
2035 BOOST_CHECK(!IsValidSwTraceString<SwTraceNameCharPolicy>(
"invalid‡string"));
2036 BOOST_CHECK(!IsValidSwTraceString<SwTraceNameCharPolicy>(
"12Ž34"));
2039 template <
typename SwTracePolicy>
2043 BOOST_CHECK(StringToSwTraceString<SwTracePolicy>(testString, buffer));
2055 BOOST_CHECK(std::memcmp(testString.data(), buffer.data() + 1, testString.size()) == 0);
2058 size_t nullTerminatorIndex =
sizeof(uint32_t) + testString.size();
2059 BOOST_CHECK(reinterpret_cast<unsigned char*>(buffer.data())[nullTerminatorIndex] ==
'\0');
2064 std::vector<uint32_t> buffer;
2067 StringToSwTraceStringTestHelper<SwTraceCharPolicy>(
"", buffer, 2);
2068 StringToSwTraceStringTestHelper<SwTraceCharPolicy>(
"_", buffer, 2);
2069 StringToSwTraceStringTestHelper<SwTraceCharPolicy>(
"0123", buffer, 3);
2070 StringToSwTraceStringTestHelper<SwTraceCharPolicy>(
"valid_string", buffer, 5);
2071 StringToSwTraceStringTestHelper<SwTraceCharPolicy>(
"VALID_string_456", buffer, 6);
2072 StringToSwTraceStringTestHelper<SwTraceCharPolicy>(
" ", buffer, 2);
2073 StringToSwTraceStringTestHelper<SwTraceCharPolicy>(
"valid string", buffer, 5);
2074 StringToSwTraceStringTestHelper<SwTraceCharPolicy>(
"!$%", buffer, 2);
2075 StringToSwTraceStringTestHelper<SwTraceCharPolicy>(
"valid|\\~string#123", buffer, 6);
2078 BOOST_CHECK(!StringToSwTraceString<SwTraceCharPolicy>(
"€£", buffer));
2080 BOOST_CHECK(!StringToSwTraceString<SwTraceCharPolicy>(
"invalid‡string", buffer));
2082 BOOST_CHECK(!StringToSwTraceString<SwTraceCharPolicy>(
"12Ž34", buffer));
2088 std::vector<uint32_t> buffer;
2091 StringToSwTraceStringTestHelper<SwTraceNameCharPolicy>(
"", buffer, 2);
2092 StringToSwTraceStringTestHelper<SwTraceNameCharPolicy>(
"_", buffer, 2);
2093 StringToSwTraceStringTestHelper<SwTraceNameCharPolicy>(
"0123", buffer, 3);
2094 StringToSwTraceStringTestHelper<SwTraceNameCharPolicy>(
"valid_string", buffer, 5);
2095 StringToSwTraceStringTestHelper<SwTraceNameCharPolicy>(
"VALID_string_456", buffer, 6);
2098 BOOST_CHECK(!StringToSwTraceString<SwTraceNameCharPolicy>(
" ", buffer));
2100 BOOST_CHECK(!StringToSwTraceString<SwTraceNameCharPolicy>(
"invalid string", buffer));
2102 BOOST_CHECK(!StringToSwTraceString<SwTraceNameCharPolicy>(
"!$%", buffer));
2104 BOOST_CHECK(!StringToSwTraceString<SwTraceNameCharPolicy>(
"invalid|\\~string#123", buffer));
2106 BOOST_CHECK(!StringToSwTraceString<SwTraceNameCharPolicy>(
"€£", buffer));
2108 BOOST_CHECK(!StringToSwTraceString<SwTraceNameCharPolicy>(
"invalid‡string", buffer));
2110 BOOST_CHECK(!StringToSwTraceString<SwTraceNameCharPolicy>(
"12Ž34", buffer));
2119 CaptureReader(uint16_t counterSize)
2121 for (uint16_t i = 0; i < counterSize; ++i)
2125 m_CounterSize = counterSize;
2128 bool IsCounterRegistered(uint16_t counterUid)
const override 2130 boost::ignore_unused(counterUid);
2134 uint16_t GetCounterCount()
const override 2136 return m_CounterSize;
2139 uint32_t GetCounterValue(uint16_t counterUid)
const override 2141 if (counterUid > m_CounterSize)
2143 BOOST_FAIL(
"Invalid counter Uid");
2145 return m_Data.at(counterUid).load();
2148 void SetCounterValue(uint16_t counterUid, uint32_t value)
2150 if (counterUid > m_CounterSize)
2152 BOOST_FAIL(
"Invalid counter Uid");
2154 m_Data.at(counterUid).store(value);
2158 std::unordered_map<uint16_t, std::atomic<uint32_t>> m_Data;
2159 uint16_t m_CounterSize;
2165 std::shared_ptr<armnn::profiling::IBackendProfilingContext>> backendProfilingContext;
2168 std::vector<uint16_t> captureIds1 = { 0, 1 };
2169 std::vector<uint16_t> captureIds2;
2173 SendThread sendThread(profilingStateMachine, mockBuffer, sendCounterPacket);
2175 std::vector<uint16_t> counterIds;
2176 CaptureReader captureReader(2);
2178 unsigned int valueA = 10;
2179 unsigned int valueB = 15;
2180 unsigned int numSteps = 5;
2182 PeriodicCounterCapture periodicCounterCapture(std::ref(data), std::ref(sendCounterPacket), captureReader,
2183 counterIdMap, backendProfilingContext);
2185 for (
unsigned int i = 0; i < numSteps; ++i)
2188 captureReader.SetCounterValue(0, valueA * (i + 1));
2189 captureReader.SetCounterValue(1, valueB * (i + 1));
2191 periodicCounterCapture.
Start();
2192 periodicCounterCapture.
Stop();
2197 uint32_t headerWord0 =
ReadUint32(buffer, 0);
2198 uint32_t headerWord1 =
ReadUint32(buffer, 4);
2200 BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 3);
2201 BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0);
2202 BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0);
2203 BOOST_TEST(headerWord1 == 20);
2205 uint32_t offset = 16;
2206 uint16_t readIndex =
ReadUint16(buffer, offset);
2207 BOOST_TEST(0 == readIndex);
2210 uint32_t readValue =
ReadUint32(buffer, offset);
2211 BOOST_TEST((valueA * numSteps) == readValue);
2215 BOOST_TEST(1 == readIndex);
2219 BOOST_TEST((valueB * numSteps) == readValue);
2224 using boost::numeric_cast;
2226 const uint32_t familyId = 0;
2227 const uint32_t packetId = 3;
2228 const uint32_t version = 1;
2233 SendThread sendThread(profilingStateMachine, mockBuffer1, sendCounterPacket);
2237 sendCounterPacket, sendTimelinePacket, profilingStateMachine);
2239 const uint32_t wrongPacketId = 47;
2240 const uint32_t wrongHeader = (wrongPacketId & 0x000003FF) << 16;
2242 Packet wrongPacket(wrongHeader);
2253 const uint32_t rightHeader = (packetId & 0x000003FF) << 16;
2255 Packet rightPacket(rightHeader);
2257 BOOST_CHECK_NO_THROW(commandHandler(rightPacket));
2261 uint32_t header1Word0 =
ReadUint32(readBuffer1, 0);
2262 uint32_t header1Word1 =
ReadUint32(readBuffer1, 4);
2265 BOOST_TEST(((header1Word0 >> 26) & 0x0000003F) == 0);
2266 BOOST_TEST(((header1Word0 >> 16) & 0x000003FF) == 2);
2267 BOOST_TEST(header1Word1 == 24);
2269 uint32_t bodyHeader1Word0 =
ReadUint32(readBuffer1, 8);
2270 uint16_t deviceRecordCount = numeric_cast<uint16_t>(bodyHeader1Word0 >> 16);
2271 BOOST_TEST(deviceRecordCount == 0);
2275 uint32_t header2Word0 =
ReadUint32(readBuffer2, 0);
2276 uint32_t header2Word1 =
ReadUint32(readBuffer2, 4);
2279 BOOST_TEST(((header2Word0 >> 26) & 0x0000003F) == 1);
2280 BOOST_TEST(((header2Word0 >> 16) & 0x000003FF) == 0);
2281 BOOST_TEST(header2Word1 == 419);
2286 using boost::numeric_cast;
2288 const uint32_t familyId = 0;
2289 const uint32_t packetId = 3;
2290 const uint32_t version = 1;
2295 SendThread sendThread(profilingStateMachine, mockBuffer1, sendCounterPacket);
2299 sendCounterPacket, sendTimelinePacket, profilingStateMachine);
2300 const uint32_t header = (packetId & 0x000003FF) << 16;
2309 "categoryA", 0, 1, 2.0f,
"counterA",
"descA");
2311 "categoryA", 1, 1, 3.0f,
"counterB",
"descB");
2320 BOOST_CHECK_NO_THROW(commandHandler(packet));
2324 uint32_t header1Word0 =
ReadUint32(readBuffer1, 0);
2325 uint32_t header1Word1 =
ReadUint32(readBuffer1, 4);
2327 BOOST_TEST(((header1Word0 >> 26) & 0x0000003F) == 0);
2328 BOOST_TEST(((header1Word0 >> 16) & 0x000003FF) == 2);
2329 BOOST_TEST(header1Word1 == 240);
2331 uint32_t bodyHeader1Word0 =
ReadUint32(readBuffer1, 8);
2332 uint32_t bodyHeader1Word1 =
ReadUint32(readBuffer1, 12);
2333 uint32_t bodyHeader1Word2 =
ReadUint32(readBuffer1, 16);
2334 uint32_t bodyHeader1Word3 =
ReadUint32(readBuffer1, 20);
2335 uint32_t bodyHeader1Word4 =
ReadUint32(readBuffer1, 24);
2336 uint32_t bodyHeader1Word5 =
ReadUint32(readBuffer1, 28);
2337 uint16_t deviceRecordCount = numeric_cast<uint16_t>(bodyHeader1Word0 >> 16);
2338 uint16_t counterSetRecordCount = numeric_cast<uint16_t>(bodyHeader1Word2 >> 16);
2339 uint16_t categoryRecordCount = numeric_cast<uint16_t>(bodyHeader1Word4 >> 16);
2340 BOOST_TEST(deviceRecordCount == 1);
2341 BOOST_TEST(bodyHeader1Word1 == 0);
2342 BOOST_TEST(counterSetRecordCount == 1);
2343 BOOST_TEST(bodyHeader1Word3 == 4);
2344 BOOST_TEST(categoryRecordCount == 1);
2345 BOOST_TEST(bodyHeader1Word5 == 8);
2347 uint32_t deviceRecordOffset =
ReadUint32(readBuffer1, 32);
2348 BOOST_TEST(deviceRecordOffset == 0);
2350 uint32_t counterSetRecordOffset =
ReadUint32(readBuffer1, 36);
2351 BOOST_TEST(counterSetRecordOffset == 20);
2353 uint32_t categoryRecordOffset =
ReadUint32(readBuffer1, 40);
2354 BOOST_TEST(categoryRecordOffset == 44);
2358 uint32_t header2Word0 =
ReadUint32(readBuffer2, 0);
2359 uint32_t header2Word1 =
ReadUint32(readBuffer2, 4);
2362 BOOST_TEST(((header2Word0 >> 26) & 0x0000003F) == 1);
2363 BOOST_TEST(((header2Word0 >> 16) & 0x000003FF) == 0);
2364 BOOST_TEST(header2Word1 == 419);
2374 unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<
unsigned int>(processName.size()) + 1;
2375 unsigned int streamMetadataPacketsize = 118 + processNameSize;
2378 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2379 options.m_EnableProfiling =
true;
2385 profilingService.
Update();
2387 profilingService.
Update();
2394 mockProfilingConnection->
Clear();
2397 profilingService.
Update();
2411 uint32_t packetFamily = 0;
2412 uint32_t packetId = 1;
2413 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2416 Packet connectionAcknowledgedPacket(header);
2419 mockProfilingConnection->
WritePacket(std::move(connectionAcknowledgedPacket));
2428 options.m_EnableProfiling =
false;
2438 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2439 options.m_EnableProfiling =
true;
2445 profilingService.
Update();
2447 profilingService.
Update();
2449 profilingService.
Update();
2467 uint32_t packetFamily = 0;
2468 uint32_t packetId = 3;
2469 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2472 Packet requestCounterDirectoryPacket(header);
2475 mockProfilingConnection->
WritePacket(std::move(requestCounterDirectoryPacket));
2486 options.m_EnableProfiling =
false;
2496 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2497 options.m_EnableProfiling =
true;
2503 profilingService.
Update();
2505 profilingService.
Update();
2507 profilingService.
Update();
2518 mockProfilingConnection->
Clear();
2528 uint32_t packetFamily = 0;
2529 uint32_t packetId = 4;
2530 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2532 uint32_t capturePeriod = 123456;
2538 uint16_t counterUidA = counters.begin()->first;
2539 uint16_t counterUidB = 9999;
2541 uint32_t length = 8;
2543 auto data = std::make_unique<unsigned char[]>(length);
2549 Packet periodicCounterSelectionPacket(header, length, data);
2553 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
2564 options.m_EnableProfiling =
false;
2574 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2575 options.m_EnableProfiling =
true;
2581 profilingService.
Update();
2583 profilingService.
Update();
2585 profilingService.
Update();
2607 uint32_t packetFamily = 0;
2608 uint32_t packetId = 4;
2609 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2612 Packet periodicCounterSelectionPacket(header);
2615 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
2628 options.m_EnableProfiling =
false;
2638 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2639 options.m_EnableProfiling =
true;
2645 profilingService.
Update();
2647 profilingService.
Update();
2649 profilingService.
Update();
2671 uint32_t packetFamily = 0;
2672 uint32_t packetId = 4;
2673 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2675 uint32_t capturePeriod = 123456;
2681 uint16_t counterUid = counters.begin()->first;
2683 uint32_t length = 6;
2685 auto data = std::make_unique<unsigned char[]>(length);
2690 Packet periodicCounterSelectionPacket(header, length, data);
2694 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
2705 options.m_EnableProfiling =
false;
2714 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2715 options.m_EnableProfiling =
true;
2721 profilingService.
Update();
2723 profilingService.
Update();
2725 profilingService.
Update();
2747 uint32_t packetFamily = 0;
2748 uint32_t packetId = 4;
2749 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2751 uint32_t capturePeriod = 123456;
2757 uint16_t counterUidA = counters.begin()->first;
2758 uint16_t counterUidB = (counters.begin()++)->first;
2760 uint32_t length = 8;
2762 auto data = std::make_unique<unsigned char[]>(length);
2768 Packet periodicCounterSelectionPacket(header, length, data);
2772 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
2783 options.m_EnableProfiling =
false;
2792 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2793 options.m_EnableProfiling =
true;
2803 profilingService.
Update();
2809 profilingService.
Update();
2815 profilingService.
Update();
2840 options.m_EnableProfiling =
false;
2849 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2850 options.m_EnableProfiling =
true;
2856 profilingService.
Update();
2858 profilingService.
Update();
2860 profilingService.
Update();
2882 uint32_t packetFamily = 0;
2883 uint32_t packetId = 5;
2884 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2887 Packet periodicCounterSelectionPacket(header);
2890 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
2894 std::this_thread::sleep_for(std::chrono::milliseconds(5));
2901 const auto StreamMetaDataSize =
static_cast<unsigned long>(
2906 options.m_EnableProfiling =
false;
2912 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2913 options.m_EnableProfiling =
true;
2920 options.m_EnableProfiling =
false;
2926 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2933 options.m_EnableProfiling =
false;
2941 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2942 options.m_EnableProfiling =
true;
2946 profilingService.
Update();
2950 std::stringstream ss;
2952 profilingService.
Update();
2955 options.m_EnableProfiling =
false;
2958 streamRedirector.CancelRedirect();
2961 if (!boost::contains(ss.str(),
"Cannot connect to stream socket: Connection refused"))
2963 std::cout << ss.str();
2964 BOOST_FAIL(
"Expected string not found.");
2972 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
2976 profilingService.
Update();
2978 options.m_EnableProfiling =
true;
2981 profilingService.
Update();
2985 std::stringstream ss;
2987 profilingService.
Update();
2990 options.m_EnableProfiling =
false;
2993 streamRedirector.CancelRedirect();
2996 if (!boost::contains(ss.str(),
"Cannot connect to stream socket: Connection refused"))
2998 std::cout << ss.str();
2999 BOOST_FAIL(
"Expected string not found.");
3011 std::stringstream ss;
3015 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
3016 options.m_EnableProfiling =
true;
3022 profilingService.
Update();
3024 profilingService.
Update();
3037 uint32_t packetFamily = 0;
3038 uint32_t packetId = 37;
3039 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
3042 Packet connectionAcknowledgedPacket(header);
3045 mockProfilingConnection->
WritePacket(std::move(connectionAcknowledgedPacket));
3048 profilingService.
Update();
3051 options.m_EnableProfiling =
false;
3054 streamRedirector.CancelRedirect();
3057 if (!boost::contains(ss.str(),
"Functor with requested PacketId=37 and Version=4194304 does not exist"))
3059 std::cout << ss.str();
3060 BOOST_FAIL(
"Expected string not found.");
3072 std::stringstream ss;
3076 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
3077 options.m_EnableProfiling =
true;
3085 profilingService.
Update();
3100 uint32_t packetFamily = 0;
3101 uint32_t packetId = 123;
3102 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
3105 Packet requestCounterDirectoryPacket(header);
3108 mockProfilingConnection->WritePacket(std::move(requestCounterDirectoryPacket));
3111 profilingService.
Update();
3114 options.m_EnableProfiling =
false;
3117 streamRedirector.CancelRedirect();
3120 if (!boost::contains(ss.str(),
"Functor with requested PacketId=123 and Version=4194304 does not exist"))
3122 std::cout << ss.str();
3123 BOOST_FAIL(
"Expected string not found.");
3135 std::stringstream ss;
3139 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
3140 options.m_EnableProfiling =
true;
3146 profilingService.
Update();
3148 profilingService.
Update();
3150 profilingService.
Update();
3164 uint32_t packetFamily = 0;
3165 uint32_t packetId = 999;
3166 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
3169 Packet periodicCounterSelectionPacket(header);
3172 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
3173 profilingService.
Update();
3176 options.m_EnableProfiling =
false;
3180 streamRedirector.CancelRedirect();
3183 if (!boost::contains(ss.str(),
"Functor with requested PacketId=999 and Version=4194304 does not exist"))
3185 std::cout << ss.str();
3186 BOOST_FAIL(
"Expected string not found.");
3196 uint16_t globalCounterIds = 0;
3201 std::vector<uint16_t> cpuRefCounters = {0, 1, 2, 3};
3202 std::vector<uint16_t> cpuAccCounters = {0, 1};
3204 for (uint16_t backendCounterId : cpuRefCounters)
3206 counterIdMap.
RegisterMapping(globalCounterIds, backendCounterId, cpuRefId);
3209 for (uint16_t backendCounterId : cpuAccCounters)
3211 counterIdMap.
RegisterMapping(globalCounterIds, backendCounterId, cpuAccId);
3232 uint16_t globalCounterIds = armnn::profiling::INFERENCES_RUN;
3238 armnn::Runtime::CreationOptions::ExternalProfilingOptions
options;
3239 options.m_EnableProfiling =
true;
3249 globalCounterIds = registerBackendCounters.
RegisterDevice(
"deviceOne");
3258 BOOST_CHECK(counterSetOnePtr->m_Name ==
"counterSetOne");
3260 uint16_t newGlobalCounterId = registerBackendCounters.
RegisterCounter(0,
3266 "first test counter");
3267 BOOST_CHECK(newGlobalCounterId = armnn::profiling::INFERENCES_RUN + 1);
3269 BOOST_CHECK(mappedGlobalId == newGlobalCounterId);
3275 options.m_EnableProfiling =
false;
3292 BackendProfiling backendProfilingCpuRef(options, profilingService, cpuRefId);
3293 BackendProfiling backendProfilingCpuAcc(options, profilingService, cpuAccId);
3295 uint16_t initialNumGlobalCounterIds = armnn::profiling::INFERENCES_RUN;
3312 std::vector<uint16_t> cpuRefCounters = {0, 1};
3313 std::vector<uint16_t> cpuAccCounters = {0};
3316 uint16_t currentNumGlobalCounterIds = registerBackendCountersCpuRef.
RegisterCounter(
3317 0,
"testCategory", 0, 0, 1.f,
"CpuRefCounter0",
"Zeroth CpuRef Counter");
3318 BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 1);
3320 BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
3325 currentNumGlobalCounterIds = registerBackendCountersCpuRef.
RegisterCounter(
3326 1,
"testCategory", 0, 0, 1.f,
"CpuRefCounter1",
"First CpuRef Counter");
3327 BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 2);
3329 BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
3338 currentNumGlobalCounterIds = registerBackendCountersCpuAcc.
RegisterCounter(
3339 0,
"testCategory", 0, 0, 1.f,
"CpuAccCounter0",
"Zeroth CpuAcc Counter");
3340 BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 3);
3342 BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
3348 const std::vector<uint16_t> activeGlobalCounterIds = {5};
3349 const std::vector<uint16_t> newActiveGlobalCounterIds = {6, 7};
3351 const uint32_t capturePeriod = 200;
3352 const uint32_t newCapturePeriod = 100;
3355 profilingService.
SetCaptureData(capturePeriod, activeGlobalCounterIds, {});
3358 std::vector<CounterStatus> cpuRefCounterStatus = backendProfilingCpuRef.
GetActiveCounters();
3359 std::vector<CounterStatus> cpuAccCounterStatus = backendProfilingCpuAcc.
GetActiveCounters();
3360 BOOST_CHECK_EQUAL(cpuRefCounterStatus.size(), 1);
3361 BOOST_CHECK_EQUAL(cpuAccCounterStatus.size(), 0);
3364 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_GlobalCounterId, activeGlobalCounterIds[0]);
3365 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[0]);
3366 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, capturePeriod);
3367 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_Enabled,
true);
3374 BOOST_CHECK_EQUAL(inactiveCpuRefCounter.
m_Enabled,
false);
3381 BOOST_CHECK_EQUAL(inactiveCpuAccCounter.
m_Enabled,
false);
3384 profilingService.
SetCaptureData(newCapturePeriod, newActiveGlobalCounterIds, {});
3389 BOOST_CHECK_EQUAL(cpuRefCounterStatus.size(), 1);
3390 BOOST_CHECK_EQUAL(cpuAccCounterStatus.size(), 1);
3393 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[0]);
3394 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[1]);
3395 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
3396 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_Enabled,
true);
3399 BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[1]);
3400 BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_BackendCounterId, cpuAccCounters[0]);
3401 BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
3402 BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_Enabled,
true);
3405 inactiveCpuRefCounter = backendProfilingCpuRef.
GetCounterStatus(cpuRefCounters[0]);
3409 BOOST_CHECK_EQUAL(inactiveCpuRefCounter.
m_Enabled,
false);
3431 mockProfilingService,
3438 std::vector<armnn::profiling::Timestamp> timestamps;
3439 timestamps.push_back(timestamp);
3444 uint32_t headerWord0 =
ReadUint32(readBuffer, 0);
3445 uint32_t headerWord1 =
ReadUint32(readBuffer, 4);
3446 uint64_t readTimestamp =
ReadUint64(readBuffer, 8);
3448 BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 3);
3449 BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0);
3450 BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0);
3451 BOOST_TEST(headerWord1 == 20);
3452 BOOST_TEST(1000998 == readTimestamp);
3454 uint32_t offset = 16;
3456 uint16_t readIndex =
ReadUint16(readBuffer, offset);
3457 BOOST_TEST(6 == readIndex);
3461 uint32_t readValue =
ReadUint32(readBuffer, offset);
3462 BOOST_TEST(700 == readValue);
3467 BOOST_TEST(8 == readIndex);
3472 BOOST_TEST(93 == readValue);
virtual const Devices & GetDevices() const =0
static bool IsValidChar(unsigned char c)
uint32_t GetPacketType() const
uint32_t GetVersion() const
uint64_t ReadUint64(const IPacketBufferPtr &packetBuffer, unsigned int offset)
uint32_t GetCounterValue(uint16_t counterUid) const override
void StringToSwTraceStringTestHelper(const std::string &testString, std::vector< uint32_t > buffer, size_t expectedSize)
uint32_t SubtractCounterValue(uint16_t counterUid, uint32_t value) override
uint16_t m_GlobalCounterId
Version ResolvePacketVersion(uint32_t familyId, uint32_t packetId) const
#define ARMNN_NO_CONVERSION_WARN_BEGIN
uint32_t AddCounterValue(uint16_t counterUid, uint32_t value) override
CommandHandlerFunctor * GetFunctor(uint32_t familyId, uint32_t packetId, uint32_t version) const
uint16_t RegisterCounter(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
CounterStatus GetCounterStatus(uint16_t backendCounterId) override
const CounterSet * GetCounterSet(uint16_t uid) const override
uint16_t GetNextUid(bool peekOnly)
const Device * GetDevice(uint16_t uid) const override
const Category * RegisterCategory(const std::string &categoryName, const Optional< uint16_t > &deviceUid=EmptyOptional(), const Optional< uint16_t > &counterSetUid=EmptyOptional()) override
const ICounterMappings & GetCounterMappings() const override
CaptureData GetCaptureData() const
void WriteUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint16_t value)
uint16_t ReadUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset)
void SetCaptureData(uint32_t capturePeriod, const std::vector< uint16_t > &counterIds, const std::set< armnn::BackendId > &activeBackends)
virtual const Categories & GetCategories() const =0
BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
void CaptureDataWriteThreadImpl(Holder &holder, uint32_t capturePeriod, const std::vector< uint16_t > &counterIds)
const Device * RegisterDevice(const std::string &deviceName, uint16_t cores=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
void TransitionToState(ProfilingState newState)
const std::vector< uint16_t > & GetCounterIds() const
const Counter * GetCounter(uint16_t uid) const override
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
std::string GetProcessName()
virtual const CounterSets & GetCounterSets() const =0
static bool IsValidChar(unsigned char c)
std::vector< uint16_t > GetNextCounterUids(uint16_t firstUid, uint16_t cores)
std::string m_Description
virtual const CounterSet * GetCounterSet(uint16_t uid) const =0
constexpr unsigned int LOWEST_CAPTURE_PERIOD
uint32_t GetCapturePeriod() const
bool WritePacket(const unsigned char *buffer, uint32_t length) override
long WaitForPacketsSent(MockProfilingConnection *mockProfilingConnection, MockProfilingConnection::PacketType packetType, uint32_t length=0, uint32_t timeout=1000)
virtual const Device * GetDevice(uint16_t uid) const =0
ExternalProfilingOptions m_ProfilingOptions
void ForceTransitionToState(ProfilingState newState)
void SetCounterValue(uint16_t counterUid, uint32_t value) override
void RegisterMapping(uint16_t globalCounterId, uint16_t backendCounterId, const armnn::BackendId &backendId) override
virtual uint16_t GetGlobalId(uint16_t backendCounterId, const armnn::BackendId &backendId) const =0
uint16_t GetGlobalId(uint16_t backendCounterId, const armnn::BackendId &backendId) const override
virtual uint16_t GetCounterCount() const =0
void MarkRead(IPacketBufferPtr &packetBuffer) override
const ICounterDirectory & GetCounterDirectory() const
uint32_t GetLength() const
void SetCapturePeriod(uint32_t capturePeriod)
MockProfilingConnection * GetMockProfilingConnection()
virtual const Category * GetCategory(const std::string &name) const =0
uint32_t GetHeader() const
std::vector< uint16_t > m_Counters
void Start(IProfilingConnection &profilingConnection)
void RegisterCategory(const std::string &categoryName, const Optional< uint16_t > &deviceUid=EmptyOptional(), const Optional< uint16_t > &counterSetUid=EmptyOptional()) override
uint16_t GetCounterCount() const override
uint16_t GetCategoryCount() const override
void ResetExternalProfilingOptions(const ExternalProfilingOptions &options, bool resetProfilingService=false)
ProfilingState GetCurrentState() const
virtual const Counters & GetCounters() const =0
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
void RegisterFunctor(CommandHandlerFunctor *functor, uint32_t familyId, uint32_t packetId, uint32_t version)
void SetStopAfterTimeout(bool stopAfterTimeout)
uint32_t IncrementCounterValue(uint16_t counterUid) override
virtual const std::pair< uint16_t, armnn::BackendId > & GetBackendId(uint16_t globalCounterId) const =0
uint32_t GetPacketId() const
uint16_t m_BackendCounterId
uint32_t GetVersion() const
Base class for all ArmNN exceptions so that users can filter to just those.
void CaptureDataReadThreadImpl(const Holder &holder, CaptureData &captureData)
CPU Execution: Reference C++ kernels.
static ProfilingService & Instance()
void RegisterMapping(uint16_t globalCounterId, uint16_t backendCounterId, const armnn::BackendId &backendId) override
uint32_t ReadUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset)
BOOST_AUTO_TEST_SUITE_END()
void ReportCounters(const std::vector< Timestamp > &) override
CPU Execution: NEON: ArmCompute.
const std::pair< uint16_t, armnn::BackendId > & GetBackendId(uint16_t globalCounterId) const override
std::vector< CounterValue > counterValues
uint16_t GetCounterSetCount() const override
uint32_t GetPacketClass() const
void ProfilingCurrentStateThreadImpl(ProfilingStateMachine &states)
uint32_t GetFamilyId() const
bool IsOpen() const override
#define ARMNN_NO_CONVERSION_WARN_END
std::unordered_map< uint16_t, CounterPtr > Counters
IPacketBufferPtr GetReadableBuffer() override
FileOnlyHelperService helper
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
uint32_t GetPacketFamily() const
uint32_t m_SamplingRateInMicroseconds
uint16_t GetDeviceCount() const override
ProfilingState GetCurrentState() const
void SetCounterIds(const std::vector< uint16_t > &counterIds)
uint16_t RegisterCounterSet(const std::string &counterSetName, uint16_t count=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
unsigned long GetWrittenDataSize()
ProfilingService & profilingService
ProfilingState ConfigureProfilingService(const ExternalProfilingOptions &options, bool resetProfilingService=false)
armnn::Runtime::CreationOptions::ExternalProfilingOptions options
const unsigned char * GetData() const
uint32_t GetPacketId() const
const Category * GetCategory(const std::string &name) const override
const CounterSet * RegisterCounterSet(const std::string &counterSetName, uint16_t count=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
void SetCaptureData(uint32_t capturePeriod, const std::vector< uint16_t > &counterIds, const std::set< BackendId > &activeBackends)
uint32_t GetPacketId() const
void WriteUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint32_t value)
uint16_t RegisterDevice(const std::string &deviceName, uint16_t cores=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
std::vector< CounterStatus > GetActiveCounters() override