10 #include <common/include/EncodeVersion.hpp> 11 #include <common/include/PacketVersionResolver.hpp> 12 #include <common/include/SwTrace.hpp> 15 #include <CounterDirectory.hpp> 38 #include <common/include/CommandHandlerKey.hpp> 39 #include <common/include/CommandHandlerRegistry.hpp> 40 #include <common/include/SocketConnectionException.hpp> 41 #include <common/include/Packet.hpp> 58 arm::pipe::CommandHandlerKey testKey1_0(1, 1, 1);
59 arm::pipe::CommandHandlerKey testKey1_1(1, 1, 1);
60 arm::pipe::CommandHandlerKey testKey1_2(1, 2, 1);
62 arm::pipe::CommandHandlerKey testKey0(0, 1, 1);
63 arm::pipe::CommandHandlerKey testKey1(0, 1, 1);
64 arm::pipe::CommandHandlerKey testKey2(0, 1, 1);
65 arm::pipe::CommandHandlerKey testKey3(0, 0, 0);
66 arm::pipe::CommandHandlerKey testKey4(0, 2, 2);
67 arm::pipe::CommandHandlerKey testKey5(0, 0, 2);
69 BOOST_CHECK(testKey1_0 > testKey0);
70 BOOST_CHECK(testKey1_0 == testKey1_1);
71 BOOST_CHECK(testKey1_0 < testKey1_2);
73 BOOST_CHECK(testKey1 < testKey4);
74 BOOST_CHECK(testKey1 > testKey3);
75 BOOST_CHECK(testKey1 <= testKey4);
76 BOOST_CHECK(testKey1 >= testKey3);
77 BOOST_CHECK(testKey1 <= testKey2);
78 BOOST_CHECK(testKey1 >= testKey2);
79 BOOST_CHECK(testKey1 == testKey2);
80 BOOST_CHECK(testKey1 == testKey1);
82 BOOST_CHECK(!(testKey1 == testKey5));
83 BOOST_CHECK(!(testKey1 != testKey1));
84 BOOST_CHECK(testKey1 != testKey5);
86 BOOST_CHECK(testKey1 == testKey2 && testKey2 == testKey1);
87 BOOST_CHECK(testKey0 == testKey1 && testKey1 == testKey2 && testKey0 == testKey2);
89 BOOST_CHECK(testKey1.GetPacketId() == 1);
90 BOOST_CHECK(testKey1.GetVersion() == 1);
92 std::vector<arm::pipe::CommandHandlerKey> vect = {
93 arm::pipe::CommandHandlerKey(0, 0, 1), arm::pipe::CommandHandlerKey(0, 2, 0),
94 arm::pipe::CommandHandlerKey(0, 1, 0), arm::pipe::CommandHandlerKey(0, 2, 1),
95 arm::pipe::CommandHandlerKey(0, 1, 1), arm::pipe::CommandHandlerKey(0, 0, 1),
96 arm::pipe::CommandHandlerKey(0, 2, 0), arm::pipe::CommandHandlerKey(0, 0, 0) };
98 std::sort(vect.begin(), vect.end());
100 std::vector<arm::pipe::CommandHandlerKey> expectedVect = {
101 arm::pipe::CommandHandlerKey(0, 0, 0), arm::pipe::CommandHandlerKey(0, 0, 1),
102 arm::pipe::CommandHandlerKey(0, 0, 1), arm::pipe::CommandHandlerKey(0, 1, 0),
103 arm::pipe::CommandHandlerKey(0, 1, 1), arm::pipe::CommandHandlerKey(0, 2, 0),
104 arm::pipe::CommandHandlerKey(0, 2, 0), arm::pipe::CommandHandlerKey(0, 2, 1) };
106 BOOST_CHECK(vect == expectedVect);
111 arm::pipe::PacketKey key0(0, 0);
112 arm::pipe::PacketKey key1(0, 0);
113 arm::pipe::PacketKey key2(0, 1);
114 arm::pipe::PacketKey key3(0, 2);
115 arm::pipe::PacketKey key4(1, 0);
116 arm::pipe::PacketKey key5(1, 0);
117 arm::pipe::PacketKey key6(1, 1);
119 BOOST_CHECK(!(key0 < key1));
120 BOOST_CHECK(!(key0 > key1));
121 BOOST_CHECK(key0 <= key1);
122 BOOST_CHECK(key0 >= key1);
123 BOOST_CHECK(key0 == key1);
124 BOOST_CHECK(key0 < key2);
125 BOOST_CHECK(key2 < key3);
126 BOOST_CHECK(key3 > key0);
127 BOOST_CHECK(key4 == key5);
128 BOOST_CHECK(key4 > key0);
129 BOOST_CHECK(key5 < key6);
130 BOOST_CHECK(key5 <= key6);
131 BOOST_CHECK(key5 != key6);
136 arm::pipe::PacketVersionResolver packetVersionResolver;
145 SendThread sendThread(profilingStateMachine, mockBuffer, sendCounterPacket);
150 sendCounterPacket, sendTimelinePacket,
151 profilingStateMachine,
152 mockProfilingServiceStatus);
153 arm::pipe::CommandHandlerRegistry commandHandlerRegistry;
155 commandHandlerRegistry.RegisterFunctor(&connectionAcknowledgedCommandHandler);
160 CommandHandler commandHandler0(1,
true, commandHandlerRegistry, packetVersionResolver);
164 commandHandler0.
Start(testProfilingConnectionBase);
166 commandHandler0.
Start(testProfilingConnectionBase);
169 for (
int i = 0; i < 10; i++)
175 std::this_thread::sleep_for(std::chrono::milliseconds(2));
181 commandHandler0.
Stop();
188 CommandHandler commandHandler1(1,
true, commandHandlerRegistry, packetVersionResolver);
190 commandHandler1.
Start(testProfilingConnectionTimeOutError);
192 for (
int i = 0; i < 10; i++)
198 std::this_thread::sleep_for(std::chrono::milliseconds(2));
203 uint32_t timeout = 50;
204 uint32_t timeSlept = 0;
207 if (timeSlept >= timeout)
209 BOOST_FAIL(
"Timeout: The command handler loop did not stop after the timeout");
211 std::this_thread::sleep_for(std::chrono::milliseconds(1));
215 commandHandler1.
Stop();
221 commandHandler1.
Start(testProfilingConnectionBadAckPacket);
222 commandHandler1.
Stop();
229 commandHandler1.
Start(testProfilingConnectionTimeOutError);
232 for (
int i = 0; i < 10; i++)
238 std::this_thread::sleep_for(std::chrono::milliseconds(2));
240 commandHandler1.
Stop();
246 CommandHandler commandHandler2(1,
false, commandHandlerRegistry, packetVersionResolver);
248 commandHandler2.Start(testProfilingConnectionArmnnError);
251 for (
int i = 0; i < 10; i++)
257 std::this_thread::sleep_for(std::chrono::milliseconds(2));
260 BOOST_CHECK(commandHandler2.IsRunning());
261 commandHandler2.Stop();
266 arm::pipe::Version version1(12);
268 BOOST_CHECK(version1.GetMajor() == 0);
269 BOOST_CHECK(version1.GetMinor() == 0);
270 BOOST_CHECK(version1.GetPatch() == 12);
272 arm::pipe::Version version2(4108);
274 BOOST_CHECK(version2.GetMajor() == 0);
275 BOOST_CHECK(version2.GetMinor() == 1);
276 BOOST_CHECK(version2.GetPatch() == 12);
278 arm::pipe::Version version3(4198412);
280 BOOST_CHECK(version3.GetMajor() == 1);
281 BOOST_CHECK(version3.GetMinor() == 1);
282 BOOST_CHECK(version3.GetPatch() == 12);
284 arm::pipe::Version version4(0);
286 BOOST_CHECK(version4.GetMajor() == 0);
287 BOOST_CHECK(version4.GetMinor() == 0);
288 BOOST_CHECK(version4.GetPatch() == 0);
290 arm::pipe::Version version5(1, 0, 0);
291 BOOST_CHECK(version5.GetEncodedValue() == 4194304);
297 std::unique_ptr<unsigned char[]> packetData0 = std::make_unique<unsigned char[]>(length);
298 std::unique_ptr<unsigned char[]> packetData1 = std::make_unique<unsigned char[]>(0);
299 std::unique_ptr<unsigned char[]> nullPacketData;
301 arm::pipe::Packet packetTest0(472580096, length, packetData0);
303 BOOST_CHECK(packetTest0.GetHeader() == 472580096);
304 BOOST_CHECK(packetTest0.GetPacketFamily() == 7);
305 BOOST_CHECK(packetTest0.GetPacketId() == 43);
306 BOOST_CHECK(packetTest0.GetLength() == length);
307 BOOST_CHECK(packetTest0.GetPacketType() == 3);
308 BOOST_CHECK(packetTest0.GetPacketClass() == 5);
310 BOOST_CHECK_THROW(arm::pipe::Packet packetTest1(472580096, 0, packetData1), arm::pipe::InvalidArgumentException);
311 BOOST_CHECK_NO_THROW(arm::pipe::Packet packetTest2(472580096, 0, nullPacketData));
313 arm::pipe::Packet packetTest3(472580096, 0, nullPacketData);
314 BOOST_CHECK(packetTest3.GetLength() == 0);
315 BOOST_CHECK(packetTest3.GetData() ==
nullptr);
317 const unsigned char* packetTest0Data = packetTest0.GetData();
318 arm::pipe::Packet packetTest4(std::move(packetTest0));
320 BOOST_CHECK(packetTest0.GetData() ==
nullptr);
321 BOOST_CHECK(packetTest4.GetData() == packetTest0Data);
323 BOOST_CHECK(packetTest4.GetHeader() == 472580096);
324 BOOST_CHECK(packetTest4.GetPacketFamily() == 7);
325 BOOST_CHECK(packetTest4.GetPacketId() == 43);
326 BOOST_CHECK(packetTest4.GetLength() == length);
327 BOOST_CHECK(packetTest4.GetPacketType() == 3);
328 BOOST_CHECK(packetTest4.GetPacketClass() == 5);
334 uint32_t version = 1;
340 arm::pipe::CommandHandlerKey keyA(
341 testFunctorA.GetFamilyId(), testFunctorA.GetPacketId(), testFunctorA.GetVersion());
342 arm::pipe::CommandHandlerKey keyB(
343 testFunctorB.GetFamilyId(), testFunctorB.GetPacketId(), testFunctorB.GetVersion());
344 arm::pipe::CommandHandlerKey keyC(
345 testFunctorC.GetFamilyId(), testFunctorC.GetPacketId(), testFunctorC.GetVersion());
348 std::map<arm::pipe::CommandHandlerKey, arm::pipe::CommandHandlerFunctor*> registry;
350 registry.insert(std::make_pair(keyB, &testFunctorB));
351 registry.insert(std::make_pair(keyA, &testFunctorA));
352 registry.insert(std::make_pair(keyC, &testFunctorC));
355 auto it = registry.begin();
356 BOOST_CHECK(it->first == keyC);
358 BOOST_CHECK(it->first == keyA);
360 BOOST_CHECK(it->first == keyB);
362 std::unique_ptr<unsigned char[]> packetDataA;
363 std::unique_ptr<unsigned char[]> packetDataB;
364 std::unique_ptr<unsigned char[]> packetDataC;
366 arm::pipe::Packet packetA(500000000, 0, packetDataA);
367 arm::pipe::Packet packetB(600000000, 0, packetDataB);
368 arm::pipe::Packet packetC(400000000, 0, packetDataC);
371 registry.at(arm::pipe::CommandHandlerKey(
372 packetA.GetPacketFamily(), packetA.GetPacketId(), version))->operator()(packetA);
373 BOOST_CHECK(testFunctorA.
GetCount() == 1);
374 BOOST_CHECK(testFunctorB.
GetCount() == 0);
375 BOOST_CHECK(testFunctorC.
GetCount() == 0);
377 registry.at(arm::pipe::CommandHandlerKey(
378 packetB.GetPacketFamily(), packetB.GetPacketId(), version))->operator()(packetB);
379 BOOST_CHECK(testFunctorA.
GetCount() == 1);
380 BOOST_CHECK(testFunctorB.
GetCount() == 1);
381 BOOST_CHECK(testFunctorC.
GetCount() == 0);
383 registry.at(arm::pipe::CommandHandlerKey(
384 packetC.GetPacketFamily(), packetC.GetPacketId(), version))->operator()(packetC);
385 BOOST_CHECK(testFunctorA.
GetCount() == 1);
386 BOOST_CHECK(testFunctorB.
GetCount() == 1);
387 BOOST_CHECK(testFunctorC.
GetCount() == 1);
393 uint32_t version = 1;
400 arm::pipe::CommandHandlerRegistry registry;
403 registry.RegisterFunctor(&testFunctorA);
404 registry.RegisterFunctor(&testFunctorB);
405 registry.RegisterFunctor(&testFunctorC);
407 std::unique_ptr<unsigned char[]> packetDataA;
408 std::unique_ptr<unsigned char[]> packetDataB;
409 std::unique_ptr<unsigned char[]> packetDataC;
411 arm::pipe::Packet packetA(500000000, 0, packetDataA);
412 arm::pipe::Packet packetB(600000000, 0, packetDataB);
413 arm::pipe::Packet packetC(400000000, 0, packetDataC);
416 registry.GetFunctor(packetA.GetPacketFamily(), packetA.GetPacketId(), version)->
operator()(packetA);
417 BOOST_CHECK(testFunctorA.
GetCount() == 1);
418 BOOST_CHECK(testFunctorB.
GetCount() == 0);
419 BOOST_CHECK(testFunctorC.
GetCount() == 0);
421 registry.GetFunctor(packetB.GetPacketFamily(), packetB.GetPacketId(), version)->
operator()(packetB);
422 BOOST_CHECK(testFunctorA.
GetCount() == 1);
423 BOOST_CHECK(testFunctorB.
GetCount() == 1);
424 BOOST_CHECK(testFunctorC.
GetCount() == 0);
426 registry.GetFunctor(packetC.GetPacketFamily(), packetC.GetPacketId(), version)->
operator()(packetC);
427 BOOST_CHECK(testFunctorA.
GetCount() == 1);
428 BOOST_CHECK(testFunctorB.
GetCount() == 1);
429 BOOST_CHECK(testFunctorC.
GetCount() == 1);
432 registry.RegisterFunctor(&testFunctorC, testFunctorA.GetFamilyId(), testFunctorA.GetPacketId(), version);
433 registry.GetFunctor(packetA.GetPacketFamily(), packetA.GetPacketId(), version)->
operator()(packetC);
434 BOOST_CHECK(testFunctorA.
GetCount() == 1);
435 BOOST_CHECK(testFunctorB.
GetCount() == 1);
436 BOOST_CHECK(testFunctorC.
GetCount() == 2);
439 BOOST_CHECK_THROW(registry.GetFunctor(0, 0, 0), arm::pipe::ProfilingException);
445 std::random_device device;
446 std::mt19937 generator(device());
447 std::uniform_int_distribution<uint32_t> distribution(std::numeric_limits<uint32_t>::min(),
448 std::numeric_limits<uint32_t>::max());
451 const arm::pipe::Version expectedVersion(1, 0, 0);
453 arm::pipe::PacketVersionResolver packetVersionResolver;
455 constexpr
unsigned int numTests = 10u;
457 for (
unsigned int i = 0u; i < numTests; ++i)
459 const uint32_t familyId = distribution(generator);
460 const uint32_t packetId = distribution(generator);
461 arm::pipe::Version resolvedVersion = packetVersionResolver.ResolvePacketVersion(familyId, packetId);
463 BOOST_TEST(resolvedVersion == expectedVersion);
562 std::map<uint32_t, std::vector<uint16_t>> periodIdMap;
563 std::vector<uint16_t> counterIds;
564 uint32_t numThreads = 10;
565 for (uint32_t i = 0; i < numThreads; ++i)
567 counterIds.emplace_back(i);
568 periodIdMap.insert(std::make_pair(i, counterIds));
581 BOOST_CHECK((holder.
GetCaptureData()).GetCounterIds() == periodIdMap[2]);
591 BOOST_CHECK(captureData.GetCapturePeriod() == 2);
592 BOOST_CHECK(captureData.GetCounterIds() == periodIdMap[2]);
594 std::map<uint32_t, CaptureData> captureDataIdMap;
595 for (uint32_t i = 0; i < numThreads; ++i)
598 captureDataIdMap.insert(std::make_pair(i, perThreadCaptureData));
601 std::vector<std::thread> threadsVect;
602 std::vector<std::thread> readThreadsVect;
603 for (uint32_t i = 0; i < numThreads; ++i)
605 threadsVect.emplace_back(
609 BOOST_CHECK(captureDataIdMap.at(i).GetCapturePeriod() == 0);
610 BOOST_CHECK(captureDataIdMap.at(i).GetCounterIds().empty());
611 readThreadsVect.emplace_back(
615 for (uint32_t i = 0; i < numThreads; ++i)
617 threadsVect[i].join();
618 readThreadsVect[i].join();
623 for (uint32_t i = 0; i < numThreads; ++i)
625 CaptureData perThreadCaptureData = captureDataIdMap.at(i);
633 std::vector<uint16_t> counterIds = { 42, 29, 13 };
645 secondCaptureData = captureData;
646 BOOST_CHECK(secondCaptureData.GetCapturePeriod() == 150);
647 BOOST_CHECK(secondCaptureData.GetCounterIds() == counterIds);
650 CaptureData copyConstructedCaptureData(captureData);
652 BOOST_CHECK(copyConstructedCaptureData.GetCapturePeriod() == 150);
653 BOOST_CHECK(copyConstructedCaptureData.GetCounterIds() == counterIds);
662 profilingService.
Update();
674 profilingService.
Update();
682 profilingService.
Update();
696 profilingService.
Update();
699 BOOST_CHECK(!counters.empty());
701 std::vector<std::thread> writers;
703 BOOST_CHECK(!counters.empty());
706 for (
int i = 0; i < 4; ++i)
709 writers.push_back(std::thread([&profilingService]()
711 for (
int i = 0; i < 250; ++i)
717 writers.push_back(std::thread([&profilingService]()
719 for (
int i = 0; i < 200; ++i)
725 writers.push_back(std::thread([&profilingService]()
727 for (
int i = 0; i < 200; ++i)
734 std::for_each(writers.begin(), writers.end(), mem_fn(&std::thread::join));
736 uint32_t absoluteCounterValue = 0;
739 BOOST_CHECK(absoluteCounterValue = 5000);
742 BOOST_CHECK_NO_THROW(profilingService.
SetCounterValue(INFERENCES_RUN, 0));
744 BOOST_CHECK(absoluteCounterValue == 0);
748 uint32_t deltaCounterValue = 0;
750 std::thread reader([&profilingService](uint32_t& deltaCounterValue)
752 for (
int i = 0; i < 300; ++i)
756 }, std::ref(deltaCounterValue));
758 for (
int i = 0; i < 4; ++i)
761 writers.push_back(std::thread([&profilingService]()
763 for (
int i = 0; i < 250; ++i)
769 writers.push_back(std::thread([&profilingService]()
771 for (
int i = 0; i < 200; ++i)
777 writers.push_back(std::thread([&profilingService]()
779 for (
int i = 0; i < 200; ++i)
786 std::for_each(writers.begin(), writers.end(), mem_fn(&std::thread::join));
791 BOOST_CHECK(deltaCounterValue == 5000);
802 BOOST_CHECK(uid >= 1);
804 uint16_t nextUid = 0;
806 BOOST_CHECK(nextUid > uid);
808 std::vector<uint16_t> counterUids;
810 BOOST_CHECK(counterUids.size() == 1);
812 std::vector<uint16_t> nextCounterUids;
814 BOOST_CHECK(nextCounterUids.size() == 2);
815 BOOST_CHECK(nextCounterUids[0] > counterUids[0]);
817 std::vector<uint16_t> counterUidsMultiCore;
818 uint16_t thirdUid = 4;
819 uint16_t numberOfCores = 13;
820 BOOST_CHECK_NO_THROW(counterUidsMultiCore =
GetNextCounterUids(thirdUid, numberOfCores));
821 BOOST_CHECK(counterUidsMultiCore.size() == numberOfCores);
822 BOOST_CHECK(counterUidsMultiCore.front() >= nextCounterUids[0]);
823 for (
size_t i = 1; i < numberOfCores; i++)
825 BOOST_CHECK(counterUidsMultiCore[i] == counterUidsMultiCore[i - 1] + 1);
827 BOOST_CHECK(counterUidsMultiCore.back() == counterUidsMultiCore.front() + numberOfCores - 1);
839 const Category* noCategory =
nullptr;
842 BOOST_CHECK(!noCategory);
845 BOOST_CHECK_THROW(noCategory = counterDirectory.
RegisterCategory(
"invalid category"),
848 BOOST_CHECK(!noCategory);
851 const std::string categoryName =
"some_category";
853 BOOST_CHECK_NO_THROW(category = counterDirectory.
RegisterCategory(categoryName));
855 BOOST_CHECK(category);
856 BOOST_CHECK(category->
m_Name == categoryName);
862 BOOST_CHECK(registeredCategory);
863 BOOST_CHECK(registeredCategory == category);
866 const Category* notRegisteredCategory = counterDirectory.
GetCategory(
"not_registered_category");
868 BOOST_CHECK(!notRegisteredCategory);
871 const Category* anotherCategory =
nullptr;
872 BOOST_CHECK_THROW(anotherCategory = counterDirectory.
RegisterCategory(categoryName),
875 BOOST_CHECK(!anotherCategory);
878 const std::string deviceName =
"some_device";
879 const Device* device =
nullptr;
880 BOOST_CHECK_NO_THROW(device = counterDirectory.
RegisterDevice(deviceName));
883 BOOST_CHECK(device->
m_Uid >= 1);
884 BOOST_CHECK(device->
m_Name == deviceName);
885 BOOST_CHECK(device->
m_Cores == 0);
888 const std::string categoryWoDeviceName =
"some_category_without_device";
889 const Category* categoryWoDevice =
nullptr;
890 BOOST_CHECK_NO_THROW(categoryWoDevice = counterDirectory.
RegisterCategory(categoryWoDeviceName));
892 BOOST_CHECK(categoryWoDevice);
893 BOOST_CHECK(categoryWoDevice->
m_Name == categoryWoDeviceName);
894 BOOST_CHECK(categoryWoDevice->
m_Counters.empty());
897 const Category* categoryInvalidDeviceName =
nullptr;
898 BOOST_CHECK_THROW(categoryInvalidDeviceName =
902 BOOST_CHECK(!categoryInvalidDeviceName);
905 const std::string categoryWValidDeviceName =
"some_category_with_valid_device";
906 const Category* categoryWValidDevice =
nullptr;
907 BOOST_CHECK_NO_THROW(categoryWValidDevice =
910 BOOST_CHECK(categoryWValidDevice);
911 BOOST_CHECK(categoryWValidDevice != category);
912 BOOST_CHECK(categoryWValidDevice->
m_Name == categoryWValidDeviceName);
915 const std::string counterSetName =
"some_counter_set";
917 BOOST_CHECK_NO_THROW(counterSet = counterDirectory.
RegisterCounterSet(counterSetName));
919 BOOST_CHECK(counterSet);
920 BOOST_CHECK(counterSet->
m_Uid >= 1);
921 BOOST_CHECK(counterSet->
m_Name == counterSetName);
922 BOOST_CHECK(counterSet->
m_Count == 0);
925 const std::string categoryWoCounterSetName =
"some_category_without_counter_set";
926 const Category* categoryWoCounterSet =
nullptr;
927 BOOST_CHECK_NO_THROW(categoryWoCounterSet =
930 BOOST_CHECK(categoryWoCounterSet);
931 BOOST_CHECK(categoryWoCounterSet->
m_Name == categoryWoCounterSetName);
934 const std::string categoryWValidCounterSetName =
"some_category_with_valid_counter_set";
935 const Category* categoryWValidCounterSet =
nullptr;
936 BOOST_CHECK_NO_THROW(categoryWValidCounterSet = counterDirectory.
RegisterCategory(categoryWValidCounterSetName));
938 BOOST_CHECK(categoryWValidCounterSet);
939 BOOST_CHECK(categoryWValidCounterSet != category);
940 BOOST_CHECK(categoryWValidCounterSet->
m_Name == categoryWValidCounterSetName);
943 const std::string categoryWValidDeviceAndValidCounterSetName =
"some_category_with_valid_device_and_counter_set";
944 const Category* categoryWValidDeviceAndValidCounterSet =
nullptr;
945 BOOST_CHECK_NO_THROW(categoryWValidDeviceAndValidCounterSet = counterDirectory.
RegisterCategory(
946 categoryWValidDeviceAndValidCounterSetName));
948 BOOST_CHECK(categoryWValidDeviceAndValidCounterSet);
949 BOOST_CHECK(categoryWValidDeviceAndValidCounterSet != category);
950 BOOST_CHECK(categoryWValidDeviceAndValidCounterSet->
m_Name == categoryWValidDeviceAndValidCounterSetName);
962 const Device* noDevice =
nullptr;
965 BOOST_CHECK(!noDevice);
970 BOOST_CHECK(!noDevice);
973 const std::string deviceName =
"some_device";
974 const Device* device =
nullptr;
975 BOOST_CHECK_NO_THROW(device = counterDirectory.
RegisterDevice(deviceName));
978 BOOST_CHECK(device->
m_Name == deviceName);
979 BOOST_CHECK(device->
m_Uid >= 1);
980 BOOST_CHECK(device->
m_Cores == 0);
984 BOOST_CHECK(!unregisteredDevice);
989 BOOST_CHECK(registeredDevice);
990 BOOST_CHECK(registeredDevice == device);
993 const Device* deviceSameName =
nullptr;
996 BOOST_CHECK(!deviceSameName);
999 const std::string deviceWCoresName =
"some_device_with_cores";
1000 const Device* deviceWCores =
nullptr;
1001 BOOST_CHECK_NO_THROW(deviceWCores = counterDirectory.
RegisterDevice(deviceWCoresName, 2));
1003 BOOST_CHECK(deviceWCores);
1004 BOOST_CHECK(deviceWCores->
m_Name == deviceWCoresName);
1005 BOOST_CHECK(deviceWCores->
m_Uid >= 1);
1006 BOOST_CHECK(deviceWCores->
m_Uid > device->
m_Uid);
1007 BOOST_CHECK(deviceWCores->
m_Cores == 2);
1012 BOOST_CHECK(registeredDeviceWCores);
1013 BOOST_CHECK(registeredDeviceWCores == deviceWCores);
1014 BOOST_CHECK(registeredDeviceWCores != device);
1017 const std::string deviceWCoresWInvalidParentCategoryName =
"some_device_with_cores_with_invalid_parent_category";
1018 const Device* deviceWCoresWInvalidParentCategory =
nullptr;
1019 BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory =
1020 counterDirectory.
RegisterDevice(deviceWCoresWInvalidParentCategoryName, 3, std::string(
"")),
1023 BOOST_CHECK(!deviceWCoresWInvalidParentCategory);
1026 const std::string deviceWCoresWInvalidParentCategoryName2 =
"some_device_with_cores_with_invalid_parent_category2";
1027 const Device* deviceWCoresWInvalidParentCategory2 =
nullptr;
1028 BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory2 = counterDirectory.
RegisterDevice(
1029 deviceWCoresWInvalidParentCategoryName2, 3, std::string(
"invalid_parent_category")),
1032 BOOST_CHECK(!deviceWCoresWInvalidParentCategory2);
1035 const std::string categoryName =
"some_category";
1036 const Category* category =
nullptr;
1037 BOOST_CHECK_NO_THROW(category = counterDirectory.
RegisterCategory(categoryName));
1039 BOOST_CHECK(category);
1040 BOOST_CHECK(category->
m_Name == categoryName);
1044 const std::string deviceWCoresWValidParentCategoryName =
"some_device_with_cores_with_valid_parent_category";
1045 const Device* deviceWCoresWValidParentCategory =
nullptr;
1046 BOOST_CHECK_NO_THROW(deviceWCoresWValidParentCategory =
1047 counterDirectory.
RegisterDevice(deviceWCoresWValidParentCategoryName, 4, categoryName));
1049 BOOST_CHECK(deviceWCoresWValidParentCategory);
1050 BOOST_CHECK(deviceWCoresWValidParentCategory->
m_Name == deviceWCoresWValidParentCategoryName);
1051 BOOST_CHECK(deviceWCoresWValidParentCategory->
m_Uid >= 1);
1052 BOOST_CHECK(deviceWCoresWValidParentCategory->
m_Uid > device->
m_Uid);
1053 BOOST_CHECK(deviceWCoresWValidParentCategory->
m_Uid > deviceWCores->
m_Uid);
1054 BOOST_CHECK(deviceWCoresWValidParentCategory->
m_Cores == 4);
1069 BOOST_CHECK(!noCounterSet);
1072 BOOST_CHECK_THROW(noCounterSet = counterDirectory.
RegisterCounterSet(
"invalid name"),
1075 BOOST_CHECK(!noCounterSet);
1078 const std::string counterSetName =
"some_counter_set";
1080 BOOST_CHECK_NO_THROW(counterSet = counterDirectory.
RegisterCounterSet(counterSetName));
1082 BOOST_CHECK(counterSet);
1083 BOOST_CHECK(counterSet->
m_Name == counterSetName);
1084 BOOST_CHECK(counterSet->
m_Uid >= 1);
1085 BOOST_CHECK(counterSet->
m_Count == 0);
1089 BOOST_CHECK(!unregisteredCounterSet);
1094 BOOST_CHECK(registeredCounterSet);
1095 BOOST_CHECK(registeredCounterSet == counterSet);
1098 const CounterSet* counterSetSameName =
nullptr;
1099 BOOST_CHECK_THROW(counterSetSameName = counterDirectory.
RegisterCounterSet(counterSetName),
1102 BOOST_CHECK(!counterSetSameName);
1105 const std::string counterSetWCountName =
"some_counter_set_with_count";
1106 const CounterSet* counterSetWCount =
nullptr;
1107 BOOST_CHECK_NO_THROW(counterSetWCount = counterDirectory.
RegisterCounterSet(counterSetWCountName, 37));
1109 BOOST_CHECK(counterSetWCount);
1110 BOOST_CHECK(counterSetWCount->
m_Name == counterSetWCountName);
1111 BOOST_CHECK(counterSetWCount->
m_Uid >= 1);
1112 BOOST_CHECK(counterSetWCount->
m_Uid > counterSet->
m_Uid);
1113 BOOST_CHECK(counterSetWCount->
m_Count == 37);
1118 BOOST_CHECK(registeredCounterSetWCount);
1119 BOOST_CHECK(registeredCounterSetWCount == counterSetWCount);
1120 BOOST_CHECK(registeredCounterSetWCount != counterSet);
1123 const std::string counterSetWCountWInvalidParentCategoryName =
"some_counter_set_with_count_" 1124 "with_invalid_parent_category";
1125 const CounterSet* counterSetWCountWInvalidParentCategory =
nullptr;
1126 BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory = counterDirectory.
RegisterCounterSet(
1127 counterSetWCountWInvalidParentCategoryName, 42, std::string(
"")),
1130 BOOST_CHECK(!counterSetWCountWInvalidParentCategory);
1133 const std::string counterSetWCountWInvalidParentCategoryName2 =
"some_counter_set_with_count_" 1134 "with_invalid_parent_category2";
1135 const CounterSet* counterSetWCountWInvalidParentCategory2 =
nullptr;
1136 BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory2 = counterDirectory.
RegisterCounterSet(
1137 counterSetWCountWInvalidParentCategoryName2, 42, std::string(
"invalid_parent_category")),
1140 BOOST_CHECK(!counterSetWCountWInvalidParentCategory2);
1143 const std::string categoryName =
"some_category";
1144 const Category* category =
nullptr;
1145 BOOST_CHECK_NO_THROW(category = counterDirectory.
RegisterCategory(categoryName));
1147 BOOST_CHECK(category);
1148 BOOST_CHECK(category->
m_Name == categoryName);
1152 const std::string counterSetWCountWValidParentCategoryName =
"some_counter_set_with_count_" 1153 "with_valid_parent_category";
1154 const CounterSet* counterSetWCountWValidParentCategory =
nullptr;
1155 BOOST_CHECK_NO_THROW(counterSetWCountWValidParentCategory = counterDirectory.
RegisterCounterSet(
1156 counterSetWCountWValidParentCategoryName, 42, categoryName));
1158 BOOST_CHECK(counterSetWCountWValidParentCategory);
1159 BOOST_CHECK(counterSetWCountWValidParentCategory->
m_Name == counterSetWCountWValidParentCategoryName);
1160 BOOST_CHECK(counterSetWCountWValidParentCategory->
m_Uid >= 1);
1161 BOOST_CHECK(counterSetWCountWValidParentCategory->
m_Uid > counterSet->
m_Uid);
1162 BOOST_CHECK(counterSetWCountWValidParentCategory->
m_Uid > counterSetWCount->
m_Uid);
1163 BOOST_CHECK(counterSetWCountWValidParentCategory->
m_Count == 42);
1166 const std::string counterSetSameCategoryName =
"some_counter_set_with_invalid_parent_category";
1167 const std::string invalidCategoryName =
"";
1168 const CounterSet* counterSetSameCategory =
nullptr;
1169 BOOST_CHECK_THROW(counterSetSameCategory =
1170 counterDirectory.
RegisterCounterSet(counterSetSameCategoryName, 0, invalidCategoryName),
1173 BOOST_CHECK(!counterSetSameCategory);
1185 const Counter* noCounter =
nullptr;
1186 BOOST_CHECK_THROW(noCounter =
1197 BOOST_CHECK(!noCounter);
1200 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1202 "invalid parent category",
1207 "valid description"),
1210 BOOST_CHECK(!noCounter);
1213 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1215 "valid_parent_category",
1221 "valid description"),
1224 BOOST_CHECK(!noCounter);
1227 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1229 "valid_parent_category",
1235 "valid description"),
1238 BOOST_CHECK(!noCounter);
1241 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1243 "valid_parent_category",
1249 "valid description"),
1252 BOOST_CHECK(!noCounter);
1256 noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1258 "valid_parent_category",
1263 "valid description"),
1266 BOOST_CHECK(!noCounter);
1269 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1271 "valid_parent_category",
1276 "valid description"),
1279 BOOST_CHECK(!noCounter);
1282 BOOST_CHECK_THROW(noCounter =
1285 "valid_parent_category",
1293 BOOST_CHECK(!noCounter);
1296 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1298 "valid_parent_category",
1304 "inv@lid description"),
1307 BOOST_CHECK(!noCounter);
1310 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1312 "valid_parent_category",
1317 "valid description",
1318 std::string(
"Mb/s2")),
1321 BOOST_CHECK(!noCounter);
1324 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1326 "invalid_parent_category",
1331 "valid description"),
1334 BOOST_CHECK(!noCounter);
1338 BOOST_CHECK(!unregisteredCounter);
1341 const std::string categoryName =
"some_category";
1342 const Category* category =
nullptr;
1343 BOOST_CHECK_NO_THROW(category = counterDirectory.
RegisterCategory(categoryName));
1345 BOOST_CHECK(category);
1346 BOOST_CHECK(category->
m_Name == categoryName);
1350 const Counter* counter =
nullptr;
1351 BOOST_CHECK_NO_THROW(
1352 counter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1359 "valid description"));
1361 BOOST_CHECK(counter);
1362 BOOST_CHECK(counter->m_MaxCounterUid == counter->m_Uid);
1363 BOOST_CHECK(counter->m_Class == 0);
1364 BOOST_CHECK(counter->m_Interpolation == 1);
1365 BOOST_CHECK(counter->m_Multiplier == 123.45f);
1366 BOOST_CHECK(counter->m_Name ==
"valid name");
1367 BOOST_CHECK(counter->m_Description ==
"valid description");
1368 BOOST_CHECK(counter->m_Units ==
"");
1369 BOOST_CHECK(counter->m_DeviceUid == 0);
1370 BOOST_CHECK(counter->m_CounterSetUid == 0);
1371 BOOST_CHECK(category->
m_Counters.size() == 1);
1372 BOOST_CHECK(category->
m_Counters.back() == counter->m_Uid);
1375 const Counter* counterSameName =
nullptr;
1376 BOOST_CHECK_THROW(counterSameName =
1384 "valid description",
1385 std::string(
"description")),
1388 BOOST_CHECK(!counterSameName);
1391 const Counter* counterWUnits =
nullptr;
1392 BOOST_CHECK_NO_THROW(counterWUnits = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1399 "valid description",
1400 std::string(
"Mnnsq2")));
1402 BOOST_CHECK(counterWUnits);
1403 BOOST_CHECK(counterWUnits->
m_Uid > counter->m_Uid);
1405 BOOST_CHECK(counterWUnits->
m_Class == 0);
1408 BOOST_CHECK(counterWUnits->
m_Name ==
"valid name 2");
1409 BOOST_CHECK(counterWUnits->
m_Description ==
"valid description");
1410 BOOST_CHECK(counterWUnits->
m_Units ==
"Mnnsq2");
1413 BOOST_CHECK(category->
m_Counters.size() == 2);
1417 const Counter* counterWoDevice =
nullptr;
1418 BOOST_CHECK_NO_THROW(counterWoDevice = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1425 "valid description",
1430 BOOST_CHECK(counterWoDevice);
1431 BOOST_CHECK(counterWoDevice->m_Uid > counter->m_Uid);
1432 BOOST_CHECK(counterWoDevice->m_MaxCounterUid == counterWoDevice->m_Uid);
1433 BOOST_CHECK(counterWoDevice->m_Class == 0);
1434 BOOST_CHECK(counterWoDevice->m_Interpolation == 1);
1435 BOOST_CHECK(counterWoDevice->m_Multiplier == 123.45f);
1436 BOOST_CHECK(counterWoDevice->m_Name ==
"valid name 3");
1437 BOOST_CHECK(counterWoDevice->m_Description ==
"valid description");
1438 BOOST_CHECK(counterWoDevice->m_Units ==
"");
1439 BOOST_CHECK(counterWoDevice->m_DeviceUid == 0);
1440 BOOST_CHECK(counterWoDevice->m_CounterSetUid == 0);
1441 BOOST_CHECK(category->
m_Counters.size() == 3);
1442 BOOST_CHECK(category->
m_Counters.back() == counterWoDevice->m_Uid);
1445 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1452 "valid description",
1458 BOOST_CHECK(!noCounter);
1461 const std::string deviceName =
"some_device";
1462 const Device* device =
nullptr;
1463 BOOST_CHECK_NO_THROW(device = counterDirectory.
RegisterDevice(deviceName));
1465 BOOST_CHECK(device);
1466 BOOST_CHECK(device->
m_Name == deviceName);
1467 BOOST_CHECK(device->
m_Uid >= 1);
1468 BOOST_CHECK(device->
m_Cores == 0);
1471 const Counter* counterWDevice =
nullptr;
1472 BOOST_CHECK_NO_THROW(counterWDevice = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1479 std::string(
"valid description"),
1484 BOOST_CHECK(counterWDevice);
1485 BOOST_CHECK(counterWDevice->
m_Uid > counter->m_Uid);
1487 BOOST_CHECK(counterWDevice->
m_Class == 0);
1490 BOOST_CHECK(counterWDevice->
m_Name ==
"valid name 5");
1491 BOOST_CHECK(counterWDevice->
m_Description ==
"valid description");
1492 BOOST_CHECK(counterWDevice->
m_Units ==
"");
1495 BOOST_CHECK(category->
m_Counters.size() == 4);
1499 const Counter* counterWoCounterSet =
nullptr;
1500 BOOST_CHECK_NO_THROW(counterWoCounterSet = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1507 "valid description",
1513 BOOST_CHECK(counterWoCounterSet);
1514 BOOST_CHECK(counterWoCounterSet->m_Uid > counter->m_Uid);
1515 BOOST_CHECK(counterWoCounterSet->m_MaxCounterUid == counterWoCounterSet->m_Uid);
1516 BOOST_CHECK(counterWoCounterSet->m_Class == 0);
1517 BOOST_CHECK(counterWoCounterSet->m_Interpolation == 1);
1518 BOOST_CHECK(counterWoCounterSet->m_Multiplier == 123.45f);
1519 BOOST_CHECK(counterWoCounterSet->m_Name ==
"valid name 6");
1520 BOOST_CHECK(counterWoCounterSet->m_Description ==
"valid description");
1521 BOOST_CHECK(counterWoCounterSet->m_Units ==
"");
1522 BOOST_CHECK(counterWoCounterSet->m_DeviceUid == 0);
1523 BOOST_CHECK(counterWoCounterSet->m_CounterSetUid == 0);
1524 BOOST_CHECK(category->
m_Counters.size() == 5);
1525 BOOST_CHECK(category->
m_Counters.back() == counterWoCounterSet->m_Uid);
1528 BOOST_CHECK_THROW(noCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID,
1536 std::string(
"valid description"),
1542 BOOST_CHECK(!noCounter);
1545 const Counter* counterWNumberOfCores =
nullptr;
1546 uint16_t numberOfCores = 15;
1547 BOOST_CHECK_NO_THROW(counterWNumberOfCores = counterDirectory.
RegisterCounter(
1548 armnn::profiling::BACKEND_ID, 50,
1549 categoryName, 0, 1, 123.45f,
"valid name 8",
"valid description",
1555 BOOST_CHECK(counterWNumberOfCores);
1556 BOOST_CHECK(counterWNumberOfCores->
m_Uid > counter->m_Uid);
1557 BOOST_CHECK(counterWNumberOfCores->
m_MaxCounterUid == counterWNumberOfCores->
m_Uid + numberOfCores - 1);
1558 BOOST_CHECK(counterWNumberOfCores->
m_Class == 0);
1560 BOOST_CHECK(counterWNumberOfCores->
m_Multiplier == 123.45f);
1561 BOOST_CHECK(counterWNumberOfCores->
m_Name ==
"valid name 8");
1562 BOOST_CHECK(counterWNumberOfCores->
m_Description ==
"valid description");
1563 BOOST_CHECK(counterWNumberOfCores->
m_Units ==
"");
1564 BOOST_CHECK(counterWNumberOfCores->
m_DeviceUid == 0);
1566 BOOST_CHECK(category->
m_Counters.size() == 20);
1567 for (
size_t i = 0; i < numberOfCores; i++)
1570 counterWNumberOfCores->
m_Uid + i);
1574 const std::string multiCoreDeviceName =
"some_multi_core_device";
1575 const Device* multiCoreDevice =
nullptr;
1576 BOOST_CHECK_NO_THROW(multiCoreDevice = counterDirectory.
RegisterDevice(multiCoreDeviceName, 4));
1578 BOOST_CHECK(multiCoreDevice);
1579 BOOST_CHECK(multiCoreDevice->
m_Name == multiCoreDeviceName);
1580 BOOST_CHECK(multiCoreDevice->
m_Uid >= 1);
1581 BOOST_CHECK(multiCoreDevice->
m_Cores == 4);
1584 const Counter* counterWMultiCoreDevice =
nullptr;
1585 BOOST_CHECK_NO_THROW(counterWMultiCoreDevice = counterDirectory.
RegisterCounter(
1586 armnn::profiling::BACKEND_ID, 19, categoryName, 0, 1,
1587 123.45f,
"valid name 9",
"valid description",
1590 multiCoreDevice->
m_Uid,
1593 BOOST_CHECK(counterWMultiCoreDevice);
1594 BOOST_CHECK(counterWMultiCoreDevice->
m_Uid > counter->m_Uid);
1596 counterWMultiCoreDevice->
m_Uid + multiCoreDevice->
m_Cores - 1);
1597 BOOST_CHECK(counterWMultiCoreDevice->
m_Class == 0);
1599 BOOST_CHECK(counterWMultiCoreDevice->
m_Multiplier == 123.45f);
1600 BOOST_CHECK(counterWMultiCoreDevice->
m_Name ==
"valid name 9");
1601 BOOST_CHECK(counterWMultiCoreDevice->
m_Description ==
"valid description");
1602 BOOST_CHECK(counterWMultiCoreDevice->
m_Units ==
"");
1603 BOOST_CHECK(counterWMultiCoreDevice->
m_DeviceUid == multiCoreDevice->
m_Uid);
1605 BOOST_CHECK(category->
m_Counters.size() == 24);
1606 for (
size_t i = 0; i < 4; i++)
1612 const std::string multiCoreDeviceNameWParentCategory =
"some_multi_core_device_with_parent_category";
1613 const Device* multiCoreDeviceWParentCategory =
nullptr;
1614 BOOST_CHECK_NO_THROW(multiCoreDeviceWParentCategory =
1615 counterDirectory.
RegisterDevice(multiCoreDeviceNameWParentCategory, 2, categoryName));
1617 BOOST_CHECK(multiCoreDeviceWParentCategory);
1618 BOOST_CHECK(multiCoreDeviceWParentCategory->
m_Name == multiCoreDeviceNameWParentCategory);
1619 BOOST_CHECK(multiCoreDeviceWParentCategory->
m_Uid >= 1);
1620 BOOST_CHECK(multiCoreDeviceWParentCategory->
m_Cores == 2);
1624 const Counter* counterWMultiCoreDeviceWParentCategory =
nullptr;
1625 uint16_t numberOfCourse = multiCoreDeviceWParentCategory->
m_Cores;
1626 BOOST_CHECK_NO_THROW(counterWMultiCoreDeviceWParentCategory =
1628 armnn::profiling::BACKEND_ID,
1635 "valid description",
1641 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory);
1642 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->
m_Uid > counter->m_Uid);
1643 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->
m_MaxCounterUid ==
1644 counterWMultiCoreDeviceWParentCategory->
m_Uid + multiCoreDeviceWParentCategory->
m_Cores - 1);
1645 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->
m_Class == 0);
1646 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->
m_Interpolation == 1);
1647 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->
m_Multiplier == 123.45f);
1648 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->
m_Name ==
"valid name 10");
1649 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->
m_Description ==
"valid description");
1650 BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->
m_Units ==
"");
1651 BOOST_CHECK(category->
m_Counters.size() == 26);
1652 for (
size_t i = 0; i < 2; i++)
1655 counterWMultiCoreDeviceWParentCategory->
m_Uid + i);
1659 const std::string counterSetName =
"some_counter_set";
1661 BOOST_CHECK_NO_THROW(counterSet = counterDirectory.
RegisterCounterSet(counterSetName));
1663 BOOST_CHECK(counterSet);
1664 BOOST_CHECK(counterSet->
m_Name == counterSetName);
1665 BOOST_CHECK(counterSet->
m_Uid >= 1);
1666 BOOST_CHECK(counterSet->
m_Count == 0);
1669 const Counter* counterWCounterSet =
nullptr;
1670 BOOST_CHECK_NO_THROW(counterWCounterSet = counterDirectory.
RegisterCounter(
1671 armnn::profiling::BACKEND_ID, 300,
1672 categoryName, 0, 1, 123.45f,
"valid name 11",
"valid description",
1676 counterSet->
m_Uid));
1678 BOOST_CHECK(counterWCounterSet);
1679 BOOST_CHECK(counterWCounterSet->
m_Uid > counter->m_Uid);
1681 BOOST_CHECK(counterWCounterSet->
m_Class == 0);
1683 BOOST_CHECK(counterWCounterSet->
m_Multiplier == 123.45f);
1684 BOOST_CHECK(counterWCounterSet->
m_Name ==
"valid name 11");
1685 BOOST_CHECK(counterWCounterSet->
m_Description ==
"valid description");
1686 BOOST_CHECK(counterWCounterSet->
m_Units ==
"");
1687 BOOST_CHECK(counterWCounterSet->
m_DeviceUid == 0);
1689 BOOST_CHECK(category->
m_Counters.size() == 27);
1690 BOOST_CHECK(category->
m_Counters.back() == counterWCounterSet->
m_Uid);
1693 const Counter* counterWDeviceWCounterSet =
nullptr;
1694 BOOST_CHECK_NO_THROW(counterWDeviceWCounterSet = counterDirectory.
RegisterCounter(
1695 armnn::profiling::BACKEND_ID, 23,
1696 categoryName, 0, 1, 123.45f,
"valid name 12",
"valid description",
1700 counterSet->
m_Uid));
1702 BOOST_CHECK(counterWDeviceWCounterSet);
1703 BOOST_CHECK(counterWDeviceWCounterSet->m_Uid > counter->m_Uid);
1704 BOOST_CHECK(counterWDeviceWCounterSet->m_MaxCounterUid == counterWDeviceWCounterSet->m_Uid);
1705 BOOST_CHECK(counterWDeviceWCounterSet->m_Class == 0);
1706 BOOST_CHECK(counterWDeviceWCounterSet->m_Interpolation == 1);
1707 BOOST_CHECK(counterWDeviceWCounterSet->m_Multiplier == 123.45f);
1708 BOOST_CHECK(counterWDeviceWCounterSet->m_Name ==
"valid name 12");
1709 BOOST_CHECK(counterWDeviceWCounterSet->m_Description ==
"valid description");
1710 BOOST_CHECK(counterWDeviceWCounterSet->m_Units ==
"");
1711 BOOST_CHECK(counterWDeviceWCounterSet->m_DeviceUid == device->
m_Uid);
1712 BOOST_CHECK(counterWDeviceWCounterSet->m_CounterSetUid == counterSet->
m_Uid);
1713 BOOST_CHECK(category->
m_Counters.size() == 28);
1714 BOOST_CHECK(category->
m_Counters.back() == counterWDeviceWCounterSet->m_Uid);
1717 const std::string anotherCategoryName =
"some_other_category";
1718 const Category* anotherCategory =
nullptr;
1719 BOOST_CHECK_NO_THROW(anotherCategory = counterDirectory.
RegisterCategory(anotherCategoryName));
1721 BOOST_CHECK(anotherCategory);
1722 BOOST_CHECK(anotherCategory != category);
1723 BOOST_CHECK(anotherCategory->
m_Name == anotherCategoryName);
1724 BOOST_CHECK(anotherCategory->
m_Counters.empty());
1727 const Counter* anotherCounter =
nullptr;
1728 BOOST_CHECK_NO_THROW(anotherCounter = counterDirectory.
RegisterCounter(armnn::profiling::BACKEND_ID, 24,
1729 anotherCategoryName, 1, 0, .00043f,
1730 "valid name",
"valid description",
1734 counterSet->
m_Uid));
1736 BOOST_CHECK(anotherCounter);
1737 BOOST_CHECK(anotherCounter->m_MaxCounterUid == anotherCounter->m_Uid);
1738 BOOST_CHECK(anotherCounter->m_Class == 1);
1739 BOOST_CHECK(anotherCounter->m_Interpolation == 0);
1740 BOOST_CHECK(anotherCounter->m_Multiplier == .00043f);
1741 BOOST_CHECK(anotherCounter->m_Name ==
"valid name");
1742 BOOST_CHECK(anotherCounter->m_Description ==
"valid description");
1743 BOOST_CHECK(anotherCounter->m_Units ==
"");
1744 BOOST_CHECK(anotherCounter->m_DeviceUid == device->
m_Uid);
1745 BOOST_CHECK(anotherCounter->m_CounterSetUid == counterSet->
m_Uid);
1746 BOOST_CHECK(anotherCategory->
m_Counters.size() == 1);
1747 BOOST_CHECK(anotherCategory->
m_Counters.back() == anotherCounter->m_Uid);
1756 void Start()
override 1758 void Stop()
override 1764 bool IsCounterRegistered(uint16_t counterUid)
const override 1769 uint16_t GetCounterCount()
const override 1773 uint32_t GetAbsoluteCounterValue(uint16_t counterUid)
const override 1778 uint32_t GetDeltaCounterValue(uint16_t counterUid)
override 1784 const uint32_t familyId = 0;
1785 const uint32_t packetId = 0x40000;
1787 uint32_t version = 1;
1789 std::shared_ptr<armnn::profiling::IBackendProfilingContext>> backendProfilingContext;
1792 TestCaptureThread captureThread;
1793 TestReadCounterValues readCounterValues;
1796 SendThread sendThread(profilingStateMachine, mockBuffer, sendCounterPacket);
1803 uint32_t dataLength1 = 8;
1804 uint32_t offset = 0;
1806 std::unique_ptr<unsigned char[]> uniqueData1 = std::make_unique<unsigned char[]>(dataLength1);
1807 unsigned char* data1 =
reinterpret_cast<unsigned char*
>(uniqueData1.get());
1810 offset += sizeOfUint32;
1812 offset += sizeOfUint16;
1815 arm::pipe::Packet packetA(packetId, dataLength1, uniqueData1);
1818 counterIdMap, holder, 10000u, captureThread,
1819 readCounterValues, sendCounterPacket, profilingStateMachine);
1828 BOOST_CHECK_NO_THROW(commandHandler(packetA));
1833 BOOST_TEST(counterIdsA.size() == 2);
1834 BOOST_TEST(counterIdsA[0] == 4000);
1835 BOOST_TEST(counterIdsA[1] == 5000);
1841 uint32_t headerWord0 =
ReadUint32(readBuffer, offset);
1842 offset += sizeOfUint32;
1843 uint32_t headerWord1 =
ReadUint32(readBuffer, offset);
1844 offset += sizeOfUint32;
1845 uint32_t period =
ReadUint32(readBuffer, offset);
1847 BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);
1848 BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4);
1849 BOOST_TEST(headerWord1 == 8);
1852 uint16_t counterId = 0;
1853 offset += sizeOfUint32;
1855 BOOST_TEST(counterId == 4000);
1856 offset += sizeOfUint16;
1858 BOOST_TEST(counterId == 5000);
1863 uint32_t period2 = 9000;
1864 uint32_t dataLength2 = 4;
1866 std::unique_ptr<unsigned char[]> uniqueData2 = std::make_unique<unsigned char[]>(dataLength2);
1868 WriteUint32(reinterpret_cast<unsigned char*>(uniqueData2.get()), 0, period2);
1870 arm::pipe::Packet packetB(packetId, dataLength2, uniqueData2);
1872 commandHandler(packetB);
1878 BOOST_TEST(counterIdsB.size() == 0);
1884 headerWord0 =
ReadUint32(readBuffer, offset);
1885 offset += sizeOfUint32;
1886 headerWord1 =
ReadUint32(readBuffer, offset);
1887 offset += sizeOfUint32;
1890 BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);
1891 BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4);
1892 BOOST_TEST(headerWord1 == 4);
1901 virtual void ReportStructure()
override 1903 m_ReportStructureCalled =
true;
1906 bool m_ReportStructureCalled =
false;
1912 TestNotifyBackends() : m_timelineReporting(
false) {}
1913 virtual void NotifyBackendsForTimelineReporting()
override 1915 m_TestNotifyBackendsCalled = m_timelineReporting.load();
1918 bool m_TestNotifyBackendsCalled =
false;
1919 std::atomic<bool> m_timelineReporting;
1922 arm::pipe::PacketVersionResolver packetVersionResolver;
1927 TestReportStructure testReportStructure;
1928 TestNotifyBackends testNotifyBackends;
1932 packetVersionResolver.ResolvePacketVersion(0, 6)
1936 testReportStructure,
1937 testNotifyBackends.m_timelineReporting,
1938 testNotifyBackends);
1942 const uint32_t packetFamily1 = 0;
1943 const uint32_t packetId1 = 6;
1947 arm::pipe::Packet ActivateTimelineReportingPacket(packetHeader1);
1950 activateTimelineReportingCommandHandler.operator()(ActivateTimelineReportingPacket),
armnn::Exception);
1954 activateTimelineReportingCommandHandler.operator()(ActivateTimelineReportingPacket),
armnn::Exception);
1958 activateTimelineReportingCommandHandler.operator()(ActivateTimelineReportingPacket),
armnn::Exception);
1961 activateTimelineReportingCommandHandler.operator()(ActivateTimelineReportingPacket);
1963 BOOST_CHECK(testReportStructure.m_ReportStructureCalled);
1964 BOOST_CHECK(testNotifyBackends.m_TestNotifyBackendsCalled);
1965 BOOST_CHECK(testNotifyBackends.m_timelineReporting.load());
1969 packetVersionResolver.ResolvePacketVersion(0, 7).GetEncodedValue(),
1970 testNotifyBackends.m_timelineReporting,
1972 testNotifyBackends);
1974 const uint32_t packetFamily2 = 0;
1975 const uint32_t packetId2 = 7;
1979 arm::pipe::Packet deactivateTimelineReportingPacket(packetHeader2);
1981 stateMachine.Reset();
1983 deactivateTimelineReportingCommandHandler.operator()(deactivateTimelineReportingPacket),
armnn::Exception);
1987 deactivateTimelineReportingCommandHandler.operator()(deactivateTimelineReportingPacket),
armnn::Exception);
1991 deactivateTimelineReportingCommandHandler.operator()(deactivateTimelineReportingPacket),
armnn::Exception);
1994 deactivateTimelineReportingCommandHandler.operator()(deactivateTimelineReportingPacket);
1996 BOOST_CHECK(!testNotifyBackends.m_TestNotifyBackendsCalled);
1997 BOOST_CHECK(!testNotifyBackends.m_timelineReporting.load());
2002 using namespace armnn;
2019 BOOST_CHECK(readableBuffer ==
nullptr);
2024 const uint32_t packetFamilyId = 0;
2025 const uint32_t connectionPacketId = 0x10000;
2026 const uint32_t version = 1;
2032 uint32_t period1 = 10;
2033 uint32_t dataLength1 = 8;
2034 uint32_t offset = 0;
2036 std::unique_ptr<unsigned char[]> uniqueData1 = std::make_unique<unsigned char[]>(dataLength1);
2037 unsigned char* data1 =
reinterpret_cast<unsigned char*
>(uniqueData1.get());
2040 offset += sizeOfUint32;
2042 offset += sizeOfUint16;
2045 arm::pipe::Packet packetA(connectionPacketId, dataLength1, uniqueData1);
2052 SendThread sendThread(profilingState, mockBuffer, sendCounterPacket);
2063 mockProfilingServiceStatus);
2076 BOOST_CHECK_NO_THROW(commandHandler(packetA));
2080 BOOST_CHECK_NO_THROW(commandHandler(packetA));
2084 const uint32_t differentPacketId = 0x40000;
2085 arm::pipe::Packet packetB(differentPacketId, dataLength1, uniqueData1);
2095 mockProfilingServiceStatus);
2111 catch (
const arm::pipe::SocketConnectionException& ex)
2113 BOOST_CHECK(ex.GetSocketFd() == 0);
2114 BOOST_CHECK(ex.GetErrorNo() == ECONNREFUSED);
2115 BOOST_CHECK(ex.what()
2116 == std::string(
"SocketProfilingConnection: Cannot connect to stream socket: Connection refused"));
2123 for (
unsigned char c = 0; c < 128; c++)
2125 BOOST_CHECK(arm::pipe::SwTraceCharPolicy::IsValidChar(c));
2129 for (
unsigned char c = 255; c >= 128; c++)
2131 BOOST_CHECK(!arm::pipe::SwTraceCharPolicy::IsValidChar(c));
2138 const unsigned char validChars[] =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
2139 for (
unsigned char i = 0; i <
sizeof(validChars) /
sizeof(validChars[0]) - 1; i++)
2141 BOOST_CHECK(arm::pipe::SwTraceNameCharPolicy::IsValidChar(validChars[i]));
2145 for (
unsigned char c = 0; c < 48; c++)
2147 BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
2149 for (
unsigned char c = 58; c < 65; c++)
2151 BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
2153 for (
unsigned char c = 91; c < 95; c++)
2155 BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
2157 for (
unsigned char c = 96; c < 97; c++)
2159 BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
2161 for (
unsigned char c = 123; c < 128; c++)
2163 BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
2167 for (
unsigned char c = 255; c >= 128; c++)
2169 BOOST_CHECK(!arm::pipe::SwTraceNameCharPolicy::IsValidChar(c));
2176 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
""));
2177 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"_"));
2178 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"0123"));
2179 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"valid_string"));
2180 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"VALID_string_456"));
2181 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
" "));
2182 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"valid string"));
2183 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"!$%"));
2184 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"valid|\\~string#123"));
2187 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"€£"));
2188 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"invalid‡string"));
2189 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceCharPolicy>(
"12Ž34"));
2195 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
""));
2196 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"_"));
2197 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"0123"));
2198 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"valid_string"));
2199 BOOST_CHECK(arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"VALID_string_456"));
2202 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
" "));
2203 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"invalid string"));
2204 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"!$%"));
2205 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"invalid|\\~string#123"));
2206 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"€£"));
2207 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"invalid‡string"));
2208 BOOST_CHECK(!arm::pipe::IsValidSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"12Ž34"));
2211 template <
typename SwTracePolicy>
2215 BOOST_CHECK(arm::pipe::StringToSwTraceString<SwTracePolicy>(testString, buffer));
2218 BOOST_CHECK(!buffer.empty());
2221 BOOST_CHECK(buffer.size() == expectedSize);
2224 BOOST_CHECK(buffer[0] == testString.size() + 1);
2227 BOOST_CHECK(std::memcmp(testString.data(), buffer.data() + 1, testString.size()) == 0);
2230 size_t nullTerminatorIndex =
sizeof(uint32_t) + testString.size();
2231 BOOST_CHECK(reinterpret_cast<unsigned char*>(buffer.data())[nullTerminatorIndex] ==
'\0');
2236 std::vector<uint32_t> buffer;
2239 StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>(
"", buffer, 2);
2240 StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>(
"_", buffer, 2);
2241 StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>(
"0123", buffer, 3);
2242 StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>(
"valid_string", buffer, 5);
2243 StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>(
"VALID_string_456", buffer, 6);
2244 StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>(
" ", buffer, 2);
2245 StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>(
"valid string", buffer, 5);
2246 StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>(
"!$%", buffer, 2);
2247 StringToSwTraceStringTestHelper<arm::pipe::SwTraceCharPolicy>(
"valid|\\~string#123", buffer, 6);
2250 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>(
"€£", buffer));
2251 BOOST_CHECK(buffer.empty());
2252 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>(
"invalid‡string", buffer));
2253 BOOST_CHECK(buffer.empty());
2254 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceCharPolicy>(
"12Ž34", buffer));
2255 BOOST_CHECK(buffer.empty());
2260 std::vector<uint32_t> buffer;
2263 StringToSwTraceStringTestHelper<arm::pipe::SwTraceNameCharPolicy>(
"", buffer, 2);
2264 StringToSwTraceStringTestHelper<arm::pipe::SwTraceNameCharPolicy>(
"_", buffer, 2);
2265 StringToSwTraceStringTestHelper<arm::pipe::SwTraceNameCharPolicy>(
"0123", buffer, 3);
2266 StringToSwTraceStringTestHelper<arm::pipe::SwTraceNameCharPolicy>(
"valid_string", buffer, 5);
2267 StringToSwTraceStringTestHelper<arm::pipe::SwTraceNameCharPolicy>(
"VALID_string_456", buffer, 6);
2270 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
" ", buffer));
2271 BOOST_CHECK(buffer.empty());
2272 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"invalid string", buffer));
2273 BOOST_CHECK(buffer.empty());
2274 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"!$%", buffer));
2275 BOOST_CHECK(buffer.empty());
2276 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"invalid|\\~string#123", buffer));
2277 BOOST_CHECK(buffer.empty());
2278 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"€£", buffer));
2279 BOOST_CHECK(buffer.empty());
2280 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"invalid‡string", buffer));
2281 BOOST_CHECK(buffer.empty());
2282 BOOST_CHECK(!arm::pipe::StringToSwTraceString<arm::pipe::SwTraceNameCharPolicy>(
"12Ž34", buffer));
2283 BOOST_CHECK(buffer.empty());
2291 CaptureReader(uint16_t counterSize)
2293 for (uint16_t i = 0; i < counterSize; ++i)
2297 m_CounterSize = counterSize;
2300 bool IsCounterRegistered(uint16_t counterUid)
const override 2306 uint16_t GetCounterCount()
const override 2308 return m_CounterSize;
2311 uint32_t GetAbsoluteCounterValue(uint16_t counterUid)
const override 2313 if (counterUid > m_CounterSize)
2315 BOOST_FAIL(
"Invalid counter Uid");
2317 return m_Data.at(counterUid).load();
2320 uint32_t GetDeltaCounterValue(uint16_t counterUid)
override 2322 if (counterUid > m_CounterSize)
2324 BOOST_FAIL(
"Invalid counter Uid");
2326 return m_Data.at(counterUid).load();
2329 void SetCounterValue(uint16_t counterUid, uint32_t value)
2331 if (counterUid > m_CounterSize)
2333 BOOST_FAIL(
"Invalid counter Uid");
2335 m_Data.at(counterUid).store(value);
2339 std::unordered_map<uint16_t, std::atomic<uint32_t>> m_Data;
2340 uint16_t m_CounterSize;
2346 std::shared_ptr<armnn::profiling::IBackendProfilingContext>> backendProfilingContext;
2349 std::vector<uint16_t> captureIds1 = { 0, 1 };
2350 std::vector<uint16_t> captureIds2;
2354 SendThread sendThread(profilingStateMachine, mockBuffer, sendCounterPacket);
2356 std::vector<uint16_t> counterIds;
2357 CaptureReader captureReader(2);
2359 unsigned int valueA = 10;
2360 unsigned int valueB = 15;
2361 unsigned int numSteps = 5;
2363 PeriodicCounterCapture periodicCounterCapture(std::ref(data), std::ref(sendCounterPacket), captureReader,
2364 counterIdMap, backendProfilingContext);
2366 for (
unsigned int i = 0; i < numSteps; ++i)
2369 captureReader.SetCounterValue(0, valueA * (i + 1));
2370 captureReader.SetCounterValue(1, valueB * (i + 1));
2372 periodicCounterCapture.
Start();
2373 periodicCounterCapture.
Stop();
2378 uint32_t headerWord0 =
ReadUint32(buffer, 0);
2379 uint32_t headerWord1 =
ReadUint32(buffer, 4);
2381 BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 3);
2382 BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0);
2383 BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0);
2384 BOOST_TEST(headerWord1 == 20);
2386 uint32_t offset = 16;
2387 uint16_t readIndex =
ReadUint16(buffer, offset);
2388 BOOST_TEST(0 == readIndex);
2391 uint32_t readValue =
ReadUint32(buffer, offset);
2392 BOOST_TEST((valueA * numSteps) == readValue);
2396 BOOST_TEST(1 == readIndex);
2400 BOOST_TEST((valueB * numSteps) == readValue);
2405 const uint32_t familyId = 0;
2406 const uint32_t packetId = 3;
2407 const uint32_t version = 1;
2412 SendThread sendThread(profilingStateMachine, mockBuffer1, sendCounterPacket);
2416 sendCounterPacket, sendTimelinePacket, profilingStateMachine);
2418 const uint32_t wrongPacketId = 47;
2419 const uint32_t wrongHeader = (wrongPacketId & 0x000003FF) << 16;
2421 arm::pipe::Packet wrongPacket(wrongHeader);
2432 const uint32_t rightHeader = (packetId & 0x000003FF) << 16;
2434 arm::pipe::Packet rightPacket(rightHeader);
2436 BOOST_CHECK_NO_THROW(commandHandler(rightPacket));
2440 uint32_t header1Word0 =
ReadUint32(readBuffer1, 0);
2441 uint32_t header1Word1 =
ReadUint32(readBuffer1, 4);
2444 BOOST_TEST(((header1Word0 >> 26) & 0x0000003F) == 0);
2445 BOOST_TEST(((header1Word0 >> 16) & 0x000003FF) == 2);
2446 BOOST_TEST(header1Word1 == 24);
2448 uint32_t bodyHeader1Word0 =
ReadUint32(readBuffer1, 8);
2450 BOOST_TEST(deviceRecordCount == 0);
2454 uint32_t header2Word0 =
ReadUint32(readBuffer2, 0);
2455 uint32_t header2Word1 =
ReadUint32(readBuffer2, 4);
2458 BOOST_TEST(((header2Word0 >> 26) & 0x0000003F) == 1);
2459 BOOST_TEST(((header2Word0 >> 16) & 0x000003FF) == 0);
2460 BOOST_TEST(header2Word1 == 443);
2465 const uint32_t familyId = 0;
2466 const uint32_t packetId = 3;
2467 const uint32_t version = 1;
2472 SendThread sendThread(profilingStateMachine, mockBuffer1, sendCounterPacket);
2476 sendCounterPacket, sendTimelinePacket, profilingStateMachine);
2477 const uint32_t header = (packetId & 0x000003FF) << 16;
2478 const arm::pipe::Packet packet(header);
2481 BOOST_CHECK(device !=
nullptr);
2483 BOOST_CHECK(counterSet !=
nullptr);
2486 "categoryA", 0, 1, 2.0f,
"counterA",
"descA");
2488 "categoryA", 1, 1, 3.0f,
"counterB",
"descB");
2497 BOOST_CHECK_NO_THROW(commandHandler(packet));
2501 const uint32_t header1Word0 =
ReadUint32(readBuffer1, 0);
2502 const uint32_t header1Word1 =
ReadUint32(readBuffer1, 4);
2504 BOOST_TEST(((header1Word0 >> 26) & 0x0000003F) == 0);
2505 BOOST_TEST(((header1Word0 >> 16) & 0x000003FF) == 2);
2506 BOOST_TEST(header1Word1 == 236);
2508 const uint32_t bodyHeaderSizeBytes = bodyHeaderSize *
sizeof(uint32_t);
2510 const uint32_t bodyHeader1Word0 =
ReadUint32(readBuffer1, 8);
2511 const uint32_t bodyHeader1Word1 =
ReadUint32(readBuffer1, 12);
2512 const uint32_t bodyHeader1Word2 =
ReadUint32(readBuffer1, 16);
2513 const uint32_t bodyHeader1Word3 =
ReadUint32(readBuffer1, 20);
2514 const uint32_t bodyHeader1Word4 =
ReadUint32(readBuffer1, 24);
2515 const uint32_t bodyHeader1Word5 =
ReadUint32(readBuffer1, 28);
2517 const uint16_t counterSetRecordCount =
armnn::numeric_cast<uint16_t>(bodyHeader1Word2 >> 16);
2518 const uint16_t categoryRecordCount =
armnn::numeric_cast<uint16_t>(bodyHeader1Word4 >> 16);
2519 BOOST_TEST(deviceRecordCount == 1);
2520 BOOST_TEST(bodyHeader1Word1 == 0 + bodyHeaderSizeBytes);
2521 BOOST_TEST(counterSetRecordCount == 1);
2522 BOOST_TEST(bodyHeader1Word3 == 4 + bodyHeaderSizeBytes);
2523 BOOST_TEST(categoryRecordCount == 1);
2524 BOOST_TEST(bodyHeader1Word5 == 8 + bodyHeaderSizeBytes);
2526 const uint32_t deviceRecordOffset =
ReadUint32(readBuffer1, 32);
2527 BOOST_TEST(deviceRecordOffset == 12);
2529 const uint32_t counterSetRecordOffset =
ReadUint32(readBuffer1, 36);
2530 BOOST_TEST(counterSetRecordOffset == 28);
2532 const uint32_t categoryRecordOffset =
ReadUint32(readBuffer1, 40);
2533 BOOST_TEST(categoryRecordOffset == 48);
2537 const uint32_t header2Word0 =
ReadUint32(readBuffer2, 0);
2538 const uint32_t header2Word1 =
ReadUint32(readBuffer2, 4);
2541 BOOST_TEST(((header2Word0 >> 26) & 0x0000003F) == 1);
2542 BOOST_TEST(((header2Word0 >> 16) & 0x000003FF) == 0);
2543 BOOST_TEST(header2Word1 == 443);
2561 profilingService.
Update();
2563 profilingService.
Update();
2567 BOOST_CHECK(mockProfilingConnection);
2570 mockProfilingConnection->
Clear();
2573 profilingService.
Update();
2577 mockProfilingConnection, PacketType::StreamMetaData, streamMetadataPacketsize) >= 1);
2587 uint32_t packetFamily = 0;
2588 uint32_t packetId = 1;
2589 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2592 arm::pipe::Packet connectionAcknowledgedPacket(header);
2595 mockProfilingConnection->
WritePacket(std::move(connectionAcknowledgedPacket));
2598 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::CounterDirectory) == 1);
2621 profilingService.
Update();
2623 profilingService.
Update();
2625 profilingService.
Update();
2629 BOOST_CHECK(mockProfilingConnection);
2643 uint32_t packetFamily = 0;
2644 uint32_t packetId = 3;
2645 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2648 arm::pipe::Packet requestCounterDirectoryPacket(header);
2651 mockProfilingConnection->
WritePacket(std::move(requestCounterDirectoryPacket));
2655 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::CounterDirectory, 652) == 1);
2656 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::TimelineMessageDirectory, 451) == 1);
2679 profilingService.
Update();
2681 profilingService.
Update();
2683 profilingService.
Update();
2687 BOOST_CHECK(mockProfilingConnection);
2694 mockProfilingConnection->
Clear();
2704 uint32_t packetFamily = 0;
2705 uint32_t packetId = 4;
2706 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2708 uint32_t capturePeriod = 123456;
2713 BOOST_CHECK(counters.size() > 1);
2714 uint16_t counterUidA = counters.begin()->first;
2715 uint16_t counterUidB = 9999;
2717 uint32_t length = 8;
2719 auto data = std::make_unique<unsigned char[]>(length);
2726 arm::pipe::Packet periodicCounterSelectionPacket(header, length, data);
2730 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
2734 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 14) == 1);
2735 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 22) >= 1);
2758 profilingService.
Update();
2760 profilingService.
Update();
2762 profilingService.
Update();
2766 BOOST_CHECK(mockProfilingConnection);
2784 uint32_t packetFamily = 0;
2785 uint32_t packetId = 4;
2786 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2790 arm::pipe::Packet periodicCounterSelectionPacket(header);
2793 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
2797 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 12) == 1);
2803 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 0, 0) == 0);
2823 profilingService.
Update();
2825 profilingService.
Update();
2827 profilingService.
Update();
2831 BOOST_CHECK(mockProfilingConnection);
2849 uint32_t packetFamily = 0;
2850 uint32_t packetId = 4;
2851 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2853 uint32_t capturePeriod = 123456;
2858 BOOST_CHECK(!counters.empty());
2859 uint16_t counterUid = counters.begin()->first;
2861 uint32_t length = 6;
2863 auto data = std::make_unique<unsigned char[]>(length);
2869 arm::pipe::Packet periodicCounterSelectionPacket(header, length, data);
2872 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
2876 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 14) == 1);
2877 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 22) >= 1);
2900 profilingService.
Update();
2902 profilingService.
Update();
2904 profilingService.
Update();
2908 BOOST_CHECK(mockProfilingConnection);
2926 uint32_t packetFamily = 0;
2927 uint32_t packetId = 4;
2928 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
2930 uint32_t capturePeriod = 123456;
2935 BOOST_CHECK(counters.size() > 1);
2936 uint16_t counterUidA = counters.begin()->first;
2937 uint16_t counterUidB = (counters.begin()++)->first;
2939 uint32_t length = 8;
2941 auto data = std::make_unique<unsigned char[]>(length);
2948 arm::pipe::Packet periodicCounterSelectionPacket(header, length, data);
2951 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
2955 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterSelection, 16) == 1);
2956 BOOST_CHECK(helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::PeriodicCounterCapture, 28) >= 1);
2983 profilingService.
Update();
2989 profilingService.
Update();
2995 profilingService.
Update();
2999 BOOST_CHECK(mockProfilingConnection);
3010 BOOST_CHECK(mockProfilingConnection->
IsOpen());
3017 BOOST_CHECK(mockProfilingConnection ==
nullptr);
3037 profilingService.
Update();
3039 profilingService.
Update();
3041 profilingService.
Update();
3045 BOOST_CHECK(mockProfilingConnection);
3063 uint32_t packetFamily = 0;
3064 uint32_t packetId = 5;
3065 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
3069 arm::pipe::Packet periodicCounterSelectionPacket(header);
3072 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
3076 std::this_thread::sleep_for(std::chrono::milliseconds(5));
3083 const auto StreamMetaDataSize =
static_cast<unsigned long>(
3084 helper.
WaitForPacketsSent(mockProfilingConnection, PacketType::StreamMetaData, 0, 0));
3128 profilingService.
Update();
3132 std::stringstream ss;
3134 profilingService.
Update();
3140 streamRedirector.CancelRedirect();
3143 if (ss.str().find(
"Cannot connect to stream socket: Connection refused") == std::string::npos)
3145 std::cout << ss.str();
3146 BOOST_FAIL(
"Expected string not found.");
3158 profilingService.
Update();
3163 profilingService.
Update();
3167 std::stringstream ss;
3169 profilingService.
Update();
3175 streamRedirector.CancelRedirect();
3178 if (ss.str().find(
"Cannot connect to stream socket: Connection refused") == std::string::npos)
3180 std::cout << ss.str();
3181 BOOST_FAIL(
"Expected string not found.");
3192 std::stringstream ss;
3206 profilingService.
Update();
3208 profilingService.
Update();
3212 BOOST_CHECK(mockProfilingConnection);
3221 uint32_t packetFamily = 0;
3222 uint32_t packetId = 37;
3223 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
3226 arm::pipe::Packet connectionAcknowledgedPacket(header);
3229 mockProfilingConnection->
WritePacket(std::move(connectionAcknowledgedPacket));
3232 profilingService.
Update();
3235 options.m_EnableProfiling =
false;
3238 streamRedirector.CancelRedirect();
3241 if (ss.str().find(
"Functor with requested PacketId=37 and Version=4194304 does not exist") == std::string::npos)
3243 std::cout << ss.str();
3244 BOOST_FAIL(
"Expected string not found.");
3254 std::stringstream ss;
3270 profilingService.
Update();
3275 BOOST_CHECK(mockProfilingConnection);
3285 uint32_t packetFamily = 0;
3286 uint32_t packetId = 123;
3287 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
3290 arm::pipe::Packet requestCounterDirectoryPacket(header);
3293 mockProfilingConnection->WritePacket(std::move(requestCounterDirectoryPacket));
3296 profilingService.
Update();
3299 options.m_EnableProfiling =
false;
3302 streamRedirector.CancelRedirect();
3305 if (ss.str().find(
"Functor with requested PacketId=123 and Version=4194304 does not exist") == std::string::npos)
3307 std::cout << ss.str();
3308 BOOST_FAIL(
"Expected string not found.");
3318 std::stringstream ss;
3332 profilingService.
Update();
3334 profilingService.
Update();
3336 profilingService.
Update();
3340 BOOST_CHECK(mockProfilingConnection);
3350 uint32_t packetFamily = 0;
3351 uint32_t packetId = 999;
3352 uint32_t header = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
3356 arm::pipe::Packet periodicCounterSelectionPacket(header);
3359 mockProfilingConnection->
WritePacket(std::move(periodicCounterSelectionPacket));
3360 profilingService.
Update();
3363 options.m_EnableProfiling =
false;
3367 streamRedirector.CancelRedirect();
3370 if (ss.str().find(
"Functor with requested PacketId=999 and Version=4194304 does not exist") == std::string::npos)
3372 std::cout << ss.str();
3373 BOOST_FAIL(
"Expected string not found.");
3383 uint16_t globalCounterIds = 0;
3388 std::vector<uint16_t> cpuRefCounters = {0, 1, 2, 3};
3389 std::vector<uint16_t> cpuAccCounters = {0, 1};
3391 for (uint16_t backendCounterId : cpuRefCounters)
3393 counterIdMap.
RegisterMapping(globalCounterIds, backendCounterId, cpuRefId);
3396 for (uint16_t backendCounterId : cpuAccCounters)
3398 counterIdMap.
RegisterMapping(globalCounterIds, backendCounterId, cpuAccId);
3402 BOOST_CHECK(counterIdMap.
GetBackendId(0) == (std::pair<uint16_t, armnn::BackendId>(0, cpuRefId)));
3403 BOOST_CHECK(counterIdMap.
GetBackendId(1) == (std::pair<uint16_t, armnn::BackendId>(1, cpuRefId)));
3404 BOOST_CHECK(counterIdMap.
GetBackendId(2) == (std::pair<uint16_t, armnn::BackendId>(2, cpuRefId)));
3405 BOOST_CHECK(counterIdMap.
GetBackendId(3) == (std::pair<uint16_t, armnn::BackendId>(3, cpuRefId)));
3406 BOOST_CHECK(counterIdMap.
GetBackendId(4) == (std::pair<uint16_t, armnn::BackendId>(0, cpuAccId)));
3407 BOOST_CHECK(counterIdMap.
GetBackendId(5) == (std::pair<uint16_t, armnn::BackendId>(1, cpuAccId)));
3409 BOOST_CHECK(counterIdMap.
GetGlobalId(0, cpuRefId) == 0);
3410 BOOST_CHECK(counterIdMap.
GetGlobalId(1, cpuRefId) == 1);
3411 BOOST_CHECK(counterIdMap.
GetGlobalId(2, cpuRefId) == 2);
3412 BOOST_CHECK(counterIdMap.
GetGlobalId(3, cpuRefId) == 3);
3413 BOOST_CHECK(counterIdMap.
GetGlobalId(0, cpuAccId) == 4);
3414 BOOST_CHECK(counterIdMap.
GetGlobalId(1, cpuAccId) == 5);
3419 uint16_t globalCounterIds = armnn::profiling::INFERENCES_RUN;
3435 BOOST_CHECK(categoryOnePtr);
3438 globalCounterIds = registerBackendCounters.
RegisterDevice(
"deviceOne");
3440 BOOST_CHECK(deviceOnePtr);
3441 BOOST_CHECK(deviceOnePtr->m_Name ==
"deviceOne");
3446 BOOST_CHECK(counterSetOnePtr);
3447 BOOST_CHECK(counterSetOnePtr->m_Name ==
"counterSetOne");
3449 uint16_t newGlobalCounterId = registerBackendCounters.
RegisterCounter(0,
3455 "first test counter");
3456 BOOST_CHECK(newGlobalCounterId = armnn::profiling::INFERENCES_RUN + 1);
3458 BOOST_CHECK(mappedGlobalId == newGlobalCounterId);
3460 BOOST_CHECK(backendMapping.first == 0);
3461 BOOST_CHECK(backendMapping.second == cpuRefId);
3481 BackendProfiling backendProfilingCpuRef(options, profilingService, cpuRefId);
3482 BackendProfiling backendProfilingCpuAcc(options, profilingService, cpuAccId);
3484 uint16_t initialNumGlobalCounterIds = armnn::profiling::INFERENCES_RUN;
3487 RegisterBackendCounters registerBackendCountersCpuRef(initialNumGlobalCounterIds, cpuRefId, profilingService);
3493 BOOST_CHECK(categoryOnePtr);
3501 std::vector<uint16_t> cpuRefCounters = {0, 1};
3502 std::vector<uint16_t> cpuAccCounters = {0};
3505 uint16_t currentNumGlobalCounterIds = registerBackendCountersCpuRef.
RegisterCounter(
3506 0,
"testCategory", 0, 0, 1.f,
"CpuRefCounter0",
"Zeroth CpuRef Counter");
3507 BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 1);
3509 BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
3511 BOOST_CHECK(backendMapping.first == 0);
3512 BOOST_CHECK(backendMapping.second == cpuRefId);
3514 currentNumGlobalCounterIds = registerBackendCountersCpuRef.
RegisterCounter(
3515 1,
"testCategory", 0, 0, 1.f,
"CpuRefCounter1",
"First CpuRef Counter");
3516 BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 2);
3518 BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
3520 BOOST_CHECK(backendMapping.first == 1);
3521 BOOST_CHECK(backendMapping.second == cpuRefId);
3524 RegisterBackendCounters registerBackendCountersCpuAcc(currentNumGlobalCounterIds, cpuAccId, profilingService);
3527 currentNumGlobalCounterIds = registerBackendCountersCpuAcc.
RegisterCounter(
3528 0,
"testCategory", 0, 0, 1.f,
"CpuAccCounter0",
"Zeroth CpuAcc Counter");
3529 BOOST_CHECK(currentNumGlobalCounterIds == initialNumGlobalCounterIds + 3);
3531 BOOST_CHECK(mappedGlobalId == currentNumGlobalCounterIds);
3533 BOOST_CHECK(backendMapping.first == 0);
3534 BOOST_CHECK(backendMapping.second == cpuAccId);
3537 const std::vector<uint16_t> activeGlobalCounterIds = {5};
3538 const std::vector<uint16_t> newActiveGlobalCounterIds = {6, 7};
3540 const uint32_t capturePeriod = 200;
3541 const uint32_t newCapturePeriod = 100;
3544 profilingService.
SetCaptureData(capturePeriod, activeGlobalCounterIds, {});
3547 std::vector<CounterStatus> cpuRefCounterStatus = backendProfilingCpuRef.
GetActiveCounters();
3548 std::vector<CounterStatus> cpuAccCounterStatus = backendProfilingCpuAcc.
GetActiveCounters();
3549 BOOST_CHECK_EQUAL(cpuRefCounterStatus.size(), 1);
3550 BOOST_CHECK_EQUAL(cpuAccCounterStatus.size(), 0);
3553 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_GlobalCounterId, activeGlobalCounterIds[0]);
3554 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[0]);
3555 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, capturePeriod);
3556 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_Enabled,
true);
3563 BOOST_CHECK_EQUAL(inactiveCpuRefCounter.
m_Enabled,
false);
3570 BOOST_CHECK_EQUAL(inactiveCpuAccCounter.
m_Enabled,
false);
3573 profilingService.
SetCaptureData(newCapturePeriod, newActiveGlobalCounterIds, {});
3578 BOOST_CHECK_EQUAL(cpuRefCounterStatus.size(), 1);
3579 BOOST_CHECK_EQUAL(cpuAccCounterStatus.size(), 1);
3582 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[0]);
3583 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_BackendCounterId, cpuRefCounters[1]);
3584 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
3585 BOOST_CHECK_EQUAL(cpuRefCounterStatus[0].m_Enabled,
true);
3588 BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_GlobalCounterId, newActiveGlobalCounterIds[1]);
3589 BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_BackendCounterId, cpuAccCounters[0]);
3590 BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_SamplingRateInMicroseconds, newCapturePeriod);
3591 BOOST_CHECK_EQUAL(cpuAccCounterStatus[0].m_Enabled,
true);
3594 inactiveCpuRefCounter = backendProfilingCpuRef.
GetCounterStatus(cpuRefCounters[0]);
3598 BOOST_CHECK_EQUAL(inactiveCpuRefCounter.
m_Enabled,
false);
3620 mockProfilingService,
3627 std::vector<armnn::profiling::Timestamp> timestamps;
3628 timestamps.push_back(timestamp);
3633 uint32_t headerWord0 =
ReadUint32(readBuffer, 0);
3634 uint32_t headerWord1 =
ReadUint32(readBuffer, 4);
3635 uint64_t readTimestamp =
ReadUint64(readBuffer, 8);
3637 BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 3);
3638 BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0);
3639 BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0);
3640 BOOST_TEST(headerWord1 == 20);
3641 BOOST_TEST(1000998 == readTimestamp);
3643 uint32_t offset = 16;
3645 uint16_t readIndex =
ReadUint16(readBuffer, offset);
3646 BOOST_TEST(6 == readIndex);
3650 uint32_t readValue =
ReadUint32(readBuffer, offset);
3651 BOOST_TEST(700 == readValue);
3656 BOOST_TEST(8 == readIndex);
3661 BOOST_TEST(93 == readValue);
3680 profilingService.
Update();
3684 std::stringstream ss;
3689 profilingService.
Update();
3691 streamRedirector.CancelRedirect();
3694 if (ss.str().find(
"Unsupported profiling file format, only binary is supported") == std::string::npos)
3696 std::cout << ss.str();
3697 BOOST_FAIL(
"Expected string not found.");
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
profiling::ProfilingService & GetProfilingService(armnn::RuntimeImpl *runtime)
ProfilingState GetCurrentState() const
const Category * RegisterCategory(const std::string &categoryName) override
void ProfilingCurrentStateThreadImpl(ProfilingStateMachine &states)
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
void StringToSwTraceStringTestHelper(const std::string &testString, std::vector< uint32_t > buffer, size_t expectedSize)
uint32_t GetAbsoluteCounterValue(uint16_t counterUid) const override
uint16_t GetGlobalId(uint16_t backendCounterId, const armnn::BackendId &backendId) const override
std::vector< CounterStatus > GetActiveCounters() override
CPU Execution: Reference C++ kernels.
long WaitForPacketsSent(MockProfilingConnection *mockProfilingConnection, MockProfilingConnection::PacketType packetType, uint32_t length=0, uint32_t timeout=1000)
ProfilingState GetCurrentState() const
void Start(IProfilingConnection &profilingConnection)
void WriteUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint16_t value)
const std::vector< uint16_t > & GetCounterIds() const
void WriteUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint32_t value)
uint64_t ReadUint64(const IPacketBufferPtr &packetBuffer, unsigned int offset)
void ForceTransitionToState(ProfilingState newState)
uint32_t m_SamplingRateInMicroseconds
std::unordered_map< uint16_t, CounterPtr > Counters
virtual const Category * GetCategory(const std::string &name) const =0
uint16_t RegisterDevice(const std::string &deviceName, uint16_t cores=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
uint32_t GetStreamMetaDataPacketSize()
void ForceTransitionToState(ProfilingState newState)
void ReportCounters(const std::vector< Timestamp > &) override
const Device * GetDevice(uint16_t uid) const override
virtual uint16_t GetCounterCount() const =0
uint16_t ReadUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset)
uint16_t GetCounterSetCount() const override
virtual const Device * GetDevice(uint16_t uid) const =0
unsigned long GetWrittenDataSize()
Copyright (c) 2021 ARM Limited and Contributors.
void IgnoreUnused(Ts &&...)
virtual const CounterSets & GetCounterSets() const =0
void RegisterMapping(uint16_t globalCounterId, uint16_t backendCounterId, const armnn::BackendId &backendId) override
uint32_t IncrementCounterValue(uint16_t counterUid) override
void CaptureDataReadThreadImpl(const Holder &holder, CaptureData &captureData)
virtual const Categories & GetCategories() const =0
uint16_t GetNextUid(bool peekOnly)
uint16_t GetDeviceCount() const override
uint32_t GetDeltaCounterValue(uint16_t counterUid) override
uint32_t SubtractCounterValue(uint16_t counterUid, uint32_t value) override
CounterStatus GetCounterStatus(uint16_t backendCounterId) override
virtual const Devices & GetDevices() const =0
void MarkRead(IPacketBufferPtr &packetBuffer) override
void SetCapturePeriod(uint32_t capturePeriod)
uint32_t GetCapturePeriod() const
virtual const CounterSet * GetCounterSet(uint16_t uid) const =0
CaptureData GetCaptureData() const
void SetCaptureData(uint32_t capturePeriod, const std::vector< uint16_t > &counterIds, const std::set< BackendId > &activeBackends)
void SetCaptureData(uint32_t capturePeriod, const std::vector< uint16_t > &counterIds, const std::set< armnn::BackendId > &activeBackends)
std::vector< uint16_t > GetNextCounterUids(uint16_t firstUid, uint16_t cores)
const std::pair< uint16_t, armnn::BackendId > & GetBackendId(uint16_t globalCounterId) const override
uint16_t RegisterCounterSet(const std::string &counterSetName, uint16_t count=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
IPacketBufferPtr GetReadableBuffer() override
const ICounterMappings & GetCounterMappings() const override
void ResetExternalProfilingOptions(const ExternalProfilingOptions &options, bool resetProfilingService=false)
uint32_t ConstructHeader(uint32_t packetFamily, uint32_t packetId)
uint32_t AddCounterValue(uint16_t counterUid, uint32_t value) override
uint16_t GetCategoryCount() const override
constexpr unsigned int LOWEST_CAPTURE_PERIOD
The lowest performance data capture interval we support is 10 miliseconds.
BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
std::vector< CounterValue > counterValues
IPacketBufferPtr GetReadableBuffer() override
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
uint16_t m_GlobalCounterId
uint32_t ReadUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset)
MockProfilingConnection * GetMockProfilingConnection()
std::vector< uint16_t > m_Counters
void SetCounterValue(uint16_t counterUid, uint32_t value) override
const Counter * GetCounter(uint16_t uid) const override
BOOST_AUTO_TEST_SUITE_END()
void RegisterCategory(const std::string &categoryName) override
const Category * GetCategory(const std::string &name) const override
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
std::string m_Description
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
Base class for all ArmNN exceptions so that users can filter to just those.
CPU Execution: NEON: ArmCompute.
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
BufferManager & GetProfilingBufferManager()
void SetCounterIds(const std::vector< uint16_t > &counterIds)
bool WritePacket(const unsigned char *buffer, uint32_t length) override
uint16_t GetCounterCount() const override
void TransitionToState(ProfilingState newState)
virtual const Counters & GetCounters() const =0
const CounterSet * RegisterCounterSet(const std::string &counterSetName, uint16_t count=0, const Optional< std::string > &parentCategoryName=EmptyOptional()) override
bool IsOpen() const override
virtual const std::pair< uint16_t, armnn::BackendId > & GetBackendId(uint16_t globalCounterId) const =0
void SetStopAfterTimeout(bool stopAfterTimeout)
const CounterSet * GetCounterSet(uint16_t uid) const override
ExternalProfilingOptions m_ProfilingOptions
const ICounterDirectory & GetCounterDirectory() const
ProfilingState ConfigureProfilingService(const ExternalProfilingOptions &options, bool resetProfilingService=false)
uint16_t m_BackendCounterId
void RegisterMapping(uint16_t globalCounterId, uint16_t backendCounterId, const armnn::BackendId &backendId)
virtual uint16_t GetGlobalId(uint16_t backendCounterId, const armnn::BackendId &backendId) const =0