23 #include <boost/test/unit_test.hpp> 24 #include <boost/filesystem.hpp> 25 #include <boost/dll.hpp> 27 static std::string g_TestBaseDir =
"src/backends/backendsCommon/test/";
29 static std::string g_TestSharedObjectSubDir =
"testSharedObject/";
30 static std::string g_TestDynamicBackendSubDir =
"testDynamicBackend/";
32 static std::string g_TestSharedObjectFileName =
"libTestSharedObject.so";
33 static std::string g_TestNoSharedObjectFileName =
"libNoSharedObject.txt";
35 static std::string g_TestValidTestDynamicBackendFileName =
"libValidTestDynamicBackend.so";
36 static std::string g_TestInvalidTestDynamicBackend1FileName =
"libInvalidTestDynamicBackend1.so";
37 static std::string g_TestInvalidTestDynamicBackend2FileName =
"libInvalidTestDynamicBackend2.so";
38 static std::string g_TestInvalidTestDynamicBackend3FileName =
"libInvalidTestDynamicBackend3.so";
39 static std::string g_TestInvalidTestDynamicBackend4FileName =
"libInvalidTestDynamicBackend4.so";
40 static std::string g_TestInvalidTestDynamicBackend5FileName =
"libInvalidTestDynamicBackend5.so";
41 static std::string g_TestInvalidTestDynamicBackend6FileName =
"libInvalidTestDynamicBackend6.so";
42 static std::string g_TestInvalidTestDynamicBackend7FileName =
"libInvalidTestDynamicBackend7.so";
44 static std::string g_TestValidBackend2FileName =
"Arm_TestValid2_backend.so";
45 static std::string g_TestValidBackend3FileName =
"Arm_TestValid3_backend.so";
46 static std::string g_TestValidBackend4FileName =
"Arm_TestValid4_backend.so";
47 static std::string g_TestValidBackend5FileName =
"Arm_TestValid5_backend.so";
48 static std::string g_TestInvalidBackend8FileName =
"Arm_TestInvalid8_backend.so";
49 static std::string g_TestInvalidBackend9FileName =
"Arm_TestInvalid9_backend.so";
50 static std::string g_TestInvalidBackend10FileName =
"Arm_TestInvalid10_backend.so";
51 static std::string g_TestInvalidBackend11FileName =
"Arm_TestInvalid11_backend.so";
53 static std::string g_TestDynamicBackendsSubDir1 =
"backendsTestPath1/";
54 static std::string g_TestDynamicBackendsSubDir2 =
"backendsTestPath2/";
55 static std::string g_TestDynamicBackendsSubDir3 =
"backendsTestPath3/";
56 static std::string g_TestDynamicBackendsSubDir4 =
"backendsTestPath4/";
57 static std::string g_TestDynamicBackendsSubDir5 =
"backendsTestPath5/";
58 static std::string g_TestDynamicBackendsSubDir6 =
"backendsTestPath6/";
59 static std::string g_TestDynamicBackendsSubDir7 =
"backendsTestPath7/";
60 static std::string g_TestDynamicBackendsSubDir8 =
"backendsTestPath8/";
61 static std::string g_TestDynamicBackendsSubDir9 =
"backendsTestPath9/";
63 static std::string g_DynamicBackendsBaseDir =
"src/backends/dynamic";
64 static std::string g_ReferenceDynamicBackendSubDir =
"reference/";
65 static std::string g_ReferenceBackendFileName =
"Arm_CpuRef_backend.so";
84 const std::vector<armnn::DynamicBackendPtr>& dynamicBackends)
110 using namespace boost::filesystem;
112 path programLocation = boost::dll::program_location().parent_path();
113 path sharedObjectPath = programLocation.append(basePath);
116 return sharedObjectPath.string();
131 using namespace boost::filesystem;
134 path testDynamicBackendsBasePath(testDynamicBackendsBaseDir);
135 path testDynamicBackendsSubDir = testDynamicBackendsBasePath.append(subdir);
138 return testDynamicBackendsSubDir.string();
143 using namespace boost::filesystem;
145 path testDynamicBackendsBasePath(basePath);
146 path testDynamicBackendsSubDir = testDynamicBackendsBasePath.append(subdir);
149 return testDynamicBackendsSubDir.string();
152 std::string
GetTestFilePath(
const std::string& directory,
const std::string& fileName)
154 using namespace boost::filesystem;
156 path directoryPath(directory);
157 path fileNamePath = directoryPath.append(fileName);
160 return fileNamePath.string();
165 using namespace armnn;
168 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
170 void* sharedObjectHandle =
nullptr;
171 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
172 BOOST_TEST((sharedObjectHandle !=
nullptr));
174 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
179 using namespace armnn;
182 DynamicBackendUtils::CloseHandle(
nullptr);
187 using namespace armnn;
189 void* sharedObjectHandle =
nullptr;
190 BOOST_CHECK_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(
""),
RuntimeException);
191 BOOST_TEST((sharedObjectHandle ==
nullptr));
196 using namespace armnn;
198 void* sharedObjectHandle =
nullptr;
199 BOOST_CHECK_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(
"NotExistingFileName"),
RuntimeException);
200 BOOST_TEST((sharedObjectHandle ==
nullptr));
205 using namespace armnn;
208 std::string notSharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestNoSharedObjectFileName);
210 void* sharedObjectHandle =
nullptr;
211 BOOST_CHECK_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(notSharedObjectFilePath),
RuntimeException);
212 BOOST_TEST((sharedObjectHandle ==
nullptr));
217 using namespace armnn;
220 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
222 void* sharedObjectHandle =
nullptr;
223 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
224 BOOST_TEST((sharedObjectHandle !=
nullptr));
226 using TestFunctionType = int(*)(int);
227 TestFunctionType testFunctionPointer =
nullptr;
228 BOOST_CHECK_NO_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
230 BOOST_TEST((testFunctionPointer !=
nullptr));
231 BOOST_TEST(testFunctionPointer(7) == 7);
233 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
238 using namespace armnn;
241 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
243 void* sharedObjectHandle =
nullptr;
244 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
245 BOOST_TEST((sharedObjectHandle !=
nullptr));
247 using TestFunctionType = int(*)(int);
248 TestFunctionType testFunctionPointer =
nullptr;
249 BOOST_CHECK_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
252 BOOST_TEST((testFunctionPointer ==
nullptr));
254 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
259 using namespace armnn;
262 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
264 void* sharedObjectHandle =
nullptr;
265 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
266 BOOST_TEST((sharedObjectHandle !=
nullptr));
268 using TestFunctionType = int(*)(int);
269 TestFunctionType testFunctionPointer =
nullptr;
270 BOOST_CHECK_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
273 BOOST_TEST((testFunctionPointer ==
nullptr));
275 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
280 using namespace armnn;
283 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
285 void* sharedObjectHandle =
nullptr;
286 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
287 BOOST_TEST((sharedObjectHandle !=
nullptr));
289 using TestFunctionType = int(*)(int);
290 TestFunctionType testFunctionPointer =
nullptr;
291 BOOST_CHECK_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
294 BOOST_TEST((testFunctionPointer ==
nullptr));
296 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
301 using namespace armnn;
308 BOOST_TEST(sameBackendVersion == backendApiVersion);
309 BOOST_TEST(sameBackendVersion <= backendApiVersion);
315 BOOST_TEST(!(laterMajorBackendVersion == backendApiVersion));
316 BOOST_TEST(!(laterMajorBackendVersion <= backendApiVersion));
320 BOOST_TEST(!(earlierMajorBackendVersion == backendApiVersion));
321 BOOST_TEST(earlierMajorBackendVersion <= backendApiVersion);
323 earlierMajorBackendVersion) ==
false);
328 BOOST_TEST(!(laterMinorBackendVersion == backendApiVersion));
329 BOOST_TEST(!(laterMinorBackendVersion <= backendApiVersion));
335 BOOST_TEST(!(earlierMinorBackendVersion == backendApiVersion));
336 BOOST_TEST(earlierMinorBackendVersion <= backendApiVersion);
347 using namespace armnn;
350 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestValidTestDynamicBackendFileName);
352 void* sharedObjectHandle =
nullptr;
353 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
354 BOOST_TEST((sharedObjectHandle !=
nullptr));
357 BOOST_CHECK_NO_THROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
358 BOOST_TEST((dynamicBackend !=
nullptr));
361 BOOST_CHECK_NO_THROW(dynamicBackendId = dynamicBackend->GetBackendId());
362 BOOST_TEST((dynamicBackendId ==
"ValidTestDynamicBackend"));
365 BOOST_CHECK_NO_THROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
366 BOOST_TEST((dynamicBackendVersion == IBackendInternal::GetApiVersion()));
369 BOOST_CHECK_NO_THROW(dynamicBackendInstance1 = dynamicBackend->GetBackend());
370 BOOST_TEST((dynamicBackendInstance1 !=
nullptr));
373 BOOST_CHECK_NO_THROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
374 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
377 BOOST_CHECK_NO_THROW(dynamicBackendInstance2 = dynamicBackendFactoryFunction());
378 BOOST_TEST((dynamicBackendInstance2 !=
nullptr));
380 BOOST_TEST((dynamicBackendInstance1->GetId() ==
"ValidTestDynamicBackend"));
381 BOOST_TEST((dynamicBackendInstance2->GetId() ==
"ValidTestDynamicBackend"));
388 using namespace armnn;
390 void* sharedObjectHandle =
nullptr;
393 BOOST_TEST((dynamicBackend ==
nullptr));
401 using namespace armnn;
404 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend1FileName);
406 void* sharedObjectHandle =
nullptr;
407 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
408 BOOST_TEST((sharedObjectHandle !=
nullptr));
412 BOOST_TEST((dynamicBackend ==
nullptr));
421 using namespace armnn;
424 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend2FileName);
426 void* sharedObjectHandle =
nullptr;
427 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
428 BOOST_TEST((sharedObjectHandle !=
nullptr));
432 BOOST_TEST((dynamicBackend ==
nullptr));
441 using namespace armnn;
444 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend3FileName);
446 void* sharedObjectHandle =
nullptr;
447 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
448 BOOST_TEST((sharedObjectHandle !=
nullptr));
452 BOOST_TEST((dynamicBackend ==
nullptr));
461 using namespace armnn;
464 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend4FileName);
466 void* sharedObjectHandle =
nullptr;
467 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
468 BOOST_TEST((sharedObjectHandle !=
nullptr));
472 BOOST_TEST((dynamicBackend ==
nullptr));
482 using namespace armnn;
485 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend5FileName);
487 void* sharedObjectHandle =
nullptr;
488 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
489 BOOST_TEST((sharedObjectHandle !=
nullptr));
493 BOOST_TEST((dynamicBackend ==
nullptr));
503 using namespace armnn;
506 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend6FileName);
508 void* sharedObjectHandle =
nullptr;
509 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
510 BOOST_TEST((sharedObjectHandle !=
nullptr));
513 BOOST_CHECK_NO_THROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
514 BOOST_TEST((dynamicBackend !=
nullptr));
517 BOOST_CHECK_NO_THROW(dynamicBackendId = dynamicBackend->GetBackendId());
518 BOOST_TEST((dynamicBackendId ==
"InvalidTestDynamicBackend"));
521 BOOST_CHECK_NO_THROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
525 BOOST_CHECK_THROW(dynamicBackendInstance1 = dynamicBackend->GetBackend(),
RuntimeException);
526 BOOST_TEST((dynamicBackendInstance1 ==
nullptr));
529 BOOST_CHECK_NO_THROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
530 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
533 BOOST_CHECK_THROW(dynamicBackendInstance2 = dynamicBackendFactoryFunction(),
RuntimeException);
534 BOOST_TEST((dynamicBackendInstance2 ==
nullptr));
544 using namespace armnn;
547 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend7FileName);
549 void* sharedObjectHandle =
nullptr;
550 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
551 BOOST_TEST((sharedObjectHandle !=
nullptr));
555 BOOST_TEST((dynamicBackend ==
nullptr));
560 using namespace armnn;
561 using namespace boost::filesystem;
584 std::string malformedDir(subDir1 +
"/" + subDir1);
589 BOOST_TEST(DynamicBackendPaths2.size() == 1);
590 BOOST_TEST(DynamicBackendPaths2[0] == subDir1);
593 std::string multipleEqualDirs(subDir1 +
":" + subDir1);
595 BOOST_TEST(DynamicBackendPaths3.size() == 1);
596 BOOST_TEST(DynamicBackendPaths3[0] == subDir1);
602 std::string multipleValidPaths(subDir1 +
":" + subDir2 +
":" + subDir3);
603 std::vector<std::string> DynamicBackendPaths5 =
605 BOOST_TEST(DynamicBackendPaths5.size() == 3);
606 BOOST_TEST(DynamicBackendPaths5[0] == subDir1);
607 BOOST_TEST(DynamicBackendPaths5[1] == subDir2);
608 BOOST_TEST(DynamicBackendPaths5[2] == subDir3);
611 std::string validAmongEmptyDirs(
"::" + subDir1 +
":");
612 std::vector<std::string> DynamicBackendPaths6 =
614 BOOST_TEST(DynamicBackendPaths6.size() == 1);
615 BOOST_TEST(DynamicBackendPaths6[0] == subDir1);
618 std::string invalidAmongEmptyDirs(
":" + subDir4 +
"::");
622 std::string validInvalidEmptyDirs(subDir1 +
":" + subDir4 +
":");
623 std::vector<std::string> DynamicBackendPaths8 =
625 BOOST_TEST(DynamicBackendPaths8.size() == 1);
626 BOOST_TEST(DynamicBackendPaths8[0] == subDir1);
629 std::string duplicateValidInvalidEmptyDirs(validInvalidEmptyDirs +
":" + validInvalidEmptyDirs +
":" +
630 subDir2 +
":" + subDir2);
631 std::vector<std::string> DynamicBackendPaths9 =
633 BOOST_TEST(DynamicBackendPaths9.size() == 2);
634 BOOST_TEST(DynamicBackendPaths9[0] == subDir1);
635 BOOST_TEST(DynamicBackendPaths9[1] == subDir2);
640 using namespace armnn;
641 using namespace boost::filesystem;
650 std::vector<std::string> validResult = DynamicBackendUtils::GetBackendPaths(subDir1);
651 BOOST_TEST(validResult.size() == 1);
652 BOOST_TEST(validResult[0] == subDir1);
655 std::vector<std::string> invalidResult = DynamicBackendUtils::GetBackendPaths(subDir4);
656 BOOST_TEST(invalidResult.empty());
661 using namespace armnn;
662 using namespace boost::filesystem;
708 std::string testDynamicBackendsSubDir1 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir1);
709 std::string testDynamicBackendsSubDir2 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir2);
710 std::string testDynamicBackendsSubDir3 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir3);
711 std::string testDynamicBackendsSubDir4 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir4);
717 std::vector<std::string> backendPaths
719 testDynamicBackendsSubDir1,
720 testDynamicBackendsSubDir2,
721 testDynamicBackendsSubDir3,
722 testDynamicBackendsSubDir4
724 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
725 std::vector<std::string> expectedSharedObjects
727 testDynamicBackendsSubDir1 +
"Arm123_GpuAcc_backend.so",
728 testDynamicBackendsSubDir1 +
"Arm_GpuAcc456_backend.so",
729 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so",
730 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1",
731 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2",
732 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2.3",
733 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.10.1.27",
734 testDynamicBackendsSubDir2 +
"Arm_CpuAcc_backend.so",
735 testDynamicBackendsSubDir2 +
"Arm_GpuAcc_backend.so" 738 BOOST_TEST(sharedObjects.size() == expectedSharedObjects.size());
739 BOOST_TEST(sharedObjects[0] == expectedSharedObjects[0]);
740 BOOST_TEST(sharedObjects[1] == expectedSharedObjects[1]);
741 BOOST_TEST(sharedObjects[2] == expectedSharedObjects[2]);
742 BOOST_TEST(sharedObjects[3] == expectedSharedObjects[3]);
743 BOOST_TEST(sharedObjects[4] == expectedSharedObjects[4]);
744 BOOST_TEST(sharedObjects[5] == expectedSharedObjects[5]);
745 BOOST_TEST(sharedObjects[6] == expectedSharedObjects[6]);
746 BOOST_TEST(sharedObjects[7] == expectedSharedObjects[7]);
747 BOOST_TEST(sharedObjects[8] == expectedSharedObjects[8]);
752 using namespace armnn;
753 using namespace boost::filesystem;
779 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
780 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
781 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
782 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
788 std::vector<std::string> backendPaths
790 testDynamicBackendsSubDir5,
791 testDynamicBackendsSubDir6,
792 testDynamicBackendsSubDir7,
793 testDynamicBackendsSubDir8
795 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
796 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
798 BOOST_TEST(dynamicBackends.size() == 5);
799 BOOST_TEST((dynamicBackends[0] !=
nullptr));
800 BOOST_TEST((dynamicBackends[1] !=
nullptr));
801 BOOST_TEST((dynamicBackends[2] !=
nullptr));
802 BOOST_TEST((dynamicBackends[3] !=
nullptr));
803 BOOST_TEST((dynamicBackends[4] !=
nullptr));
806 BOOST_TEST((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
807 BOOST_TEST((dynamicBackends[1]->
GetBackendId() ==
"TestValid3"));
808 BOOST_TEST((dynamicBackends[2]->
GetBackendId() ==
"TestValid2"));
809 BOOST_TEST((dynamicBackends[3]->
GetBackendId() ==
"TestValid2"));
810 BOOST_TEST((dynamicBackends[4]->
GetBackendId() ==
"TestValid5"));
815 using namespace armnn;
817 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends({});
819 BOOST_TEST(dynamicBackends.empty());
824 using namespace armnn;
826 std::vector<std::string> sharedObjects
828 "InvalidSharedObject1",
829 "InvalidSharedObject2",
830 "InvalidSharedObject3",
832 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
834 BOOST_TEST(dynamicBackends.empty());
839 using namespace armnn;
840 using namespace boost::filesystem;
842 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
843 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
847 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
848 g_TestValidBackend2FileName);
849 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
850 g_TestInvalidBackend8FileName);
851 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
852 g_TestInvalidBackend9FileName);
857 std::vector<std::string> sharedObjects
859 testValidBackend2FilePath,
860 testInvalidBackend8FilePath,
861 testInvalidBackend9FilePath,
862 "InvalidSharedObject",
864 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
866 BOOST_TEST(dynamicBackends.size() == 1);
867 BOOST_TEST((dynamicBackends[0] !=
nullptr));
868 BOOST_TEST((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
873 using namespace armnn;
874 using namespace boost::filesystem;
880 BOOST_TEST(backendRegistry.
Size() == 0);
882 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
885 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
888 std::vector<std::string> sharedObjects{ testValidBackend2FilePath };
891 BOOST_TEST(dynamicBackends.size() == 1);
892 BOOST_TEST((dynamicBackends[0] !=
nullptr));
894 BackendId dynamicBackendId = dynamicBackends[0]->GetBackendId();
895 BOOST_TEST((dynamicBackendId ==
"TestValid2"));
897 BackendVersion dynamicBackendVersion = dynamicBackends[0]->GetBackendVersion();
902 BOOST_TEST(backendRegistry.
Size() == 1);
903 BOOST_TEST(registeredBackendIds.size() == 1);
906 BOOST_TEST(backendIds.size() == 1);
907 BOOST_TEST((backendIds.find(dynamicBackendId) != backendIds.end()));
908 BOOST_TEST((registeredBackendIds.find(dynamicBackendId) != registeredBackendIds.end()));
910 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(dynamicBackendId);
911 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
914 BOOST_TEST((dynamicBackend !=
nullptr));
915 BOOST_TEST((dynamicBackend->GetId() == dynamicBackendId));
920 using namespace armnn;
921 using namespace boost::filesystem;
925 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
926 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
930 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
931 std::string testValidBackend3FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend3FileName);
932 std::string testValidBackend5FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend5FileName);
937 std::vector<std::string> sharedObjects
939 testValidBackend2FilePath,
940 testValidBackend3FilePath,
941 testValidBackend5FilePath
945 BOOST_TEST(dynamicBackends.size() == 3);
946 BOOST_TEST((dynamicBackends[0] !=
nullptr));
947 BOOST_TEST((dynamicBackends[1] !=
nullptr));
948 BOOST_TEST((dynamicBackends[2] !=
nullptr));
950 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
951 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
952 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
953 BOOST_TEST((dynamicBackendId1 ==
"TestValid2"));
954 BOOST_TEST((dynamicBackendId2 ==
"TestValid3"));
955 BOOST_TEST((dynamicBackendId3 ==
"TestValid5"));
957 for (
size_t i = 0; i < dynamicBackends.size(); i++)
959 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
965 BOOST_TEST(backendRegistry.
Size() == 0);
969 BOOST_TEST(backendRegistry.
Size() == 3);
970 BOOST_TEST(registeredBackendIds.size() == 3);
973 BOOST_TEST(backendIds.size() == 3);
974 BOOST_TEST((backendIds.find(dynamicBackendId1) != backendIds.end()));
975 BOOST_TEST((backendIds.find(dynamicBackendId2) != backendIds.end()));
976 BOOST_TEST((backendIds.find(dynamicBackendId3) != backendIds.end()));
977 BOOST_TEST((registeredBackendIds.find(dynamicBackendId1) != registeredBackendIds.end()));
978 BOOST_TEST((registeredBackendIds.find(dynamicBackendId2) != registeredBackendIds.end()));
979 BOOST_TEST((registeredBackendIds.find(dynamicBackendId3) != registeredBackendIds.end()));
981 for (
size_t i = 0; i < dynamicBackends.size(); i++)
983 BackendId dynamicBackendId = dynamicBackends[i]->GetBackendId();
985 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(dynamicBackendId);
986 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
989 BOOST_TEST((dynamicBackend !=
nullptr));
990 BOOST_TEST((dynamicBackend->GetId() == dynamicBackendId));
996 using namespace armnn;
997 using namespace boost::filesystem;
1010 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1013 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1014 g_TestInvalidBackend10FileName);
1015 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1016 g_TestInvalidBackend11FileName);
1017 BOOST_CHECK(exists(testInvalidBackend10FilePath));
1018 BOOST_CHECK(exists(testInvalidBackend11FilePath));
1020 std::vector<std::string> sharedObjects
1022 testInvalidBackend10FilePath,
1023 testInvalidBackend11FilePath,
1024 "InvalidSharedObject" 1028 BOOST_TEST(dynamicBackends.size() == 2);
1029 BOOST_TEST((dynamicBackends[0] !=
nullptr));
1030 BOOST_TEST((dynamicBackends[1] !=
nullptr));
1032 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1033 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1034 BOOST_TEST((dynamicBackendId1 ==
""));
1035 BOOST_TEST((dynamicBackendId2 ==
"Unknown"));
1037 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1039 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1045 BOOST_TEST(backendRegistry.
Size() == 0);
1050 BOOST_TEST(backendRegistry.
Size() == 0);
1051 BOOST_TEST(registeredBackendIds.empty());
1056 using namespace armnn;
1057 using namespace boost::filesystem;
1089 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1090 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1091 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
1092 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
1093 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1100 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
1101 std::string testValidBackend3FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend3FileName);
1102 std::string testValidBackend2DupFilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend2FileName);
1103 std::string testValidBackend4FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend4FileName);
1104 std::string testValidBackend5FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend5FileName);
1105 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
1106 g_TestInvalidBackend8FileName);
1107 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
1108 g_TestInvalidBackend9FileName);
1109 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1110 g_TestInvalidBackend10FileName);
1111 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1112 g_TestInvalidBackend11FileName);
1115 BOOST_CHECK(exists(testValidBackend2DupFilePath));
1120 BOOST_CHECK(exists(testInvalidBackend10FilePath));
1121 BOOST_CHECK(exists(testInvalidBackend11FilePath));
1123 std::vector<std::string> sharedObjects
1125 testValidBackend2FilePath,
1126 testValidBackend3FilePath,
1127 testValidBackend2DupFilePath,
1128 testValidBackend4FilePath,
1129 testValidBackend5FilePath,
1130 testInvalidBackend8FilePath,
1131 testInvalidBackend9FilePath,
1132 testInvalidBackend10FilePath,
1133 testInvalidBackend11FilePath,
1134 "InvalidSharedObject" 1138 BOOST_TEST(dynamicBackends.size() == 7);
1139 BOOST_TEST((dynamicBackends[0] !=
nullptr));
1140 BOOST_TEST((dynamicBackends[1] !=
nullptr));
1141 BOOST_TEST((dynamicBackends[2] !=
nullptr));
1142 BOOST_TEST((dynamicBackends[3] !=
nullptr));
1143 BOOST_TEST((dynamicBackends[4] !=
nullptr));
1144 BOOST_TEST((dynamicBackends[5] !=
nullptr));
1145 BOOST_TEST((dynamicBackends[6] !=
nullptr));
1147 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1148 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1149 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
1150 BackendId dynamicBackendId4 = dynamicBackends[3]->GetBackendId();
1151 BackendId dynamicBackendId5 = dynamicBackends[4]->GetBackendId();
1152 BackendId dynamicBackendId6 = dynamicBackends[5]->GetBackendId();
1153 BackendId dynamicBackendId7 = dynamicBackends[6]->GetBackendId();
1154 BOOST_TEST((dynamicBackendId1 ==
"TestValid2"));
1155 BOOST_TEST((dynamicBackendId2 ==
"TestValid3"));
1156 BOOST_TEST((dynamicBackendId3 ==
"TestValid2"));
1157 BOOST_TEST((dynamicBackendId4 ==
"TestValid2"));
1158 BOOST_TEST((dynamicBackendId5 ==
"TestValid5"));
1159 BOOST_TEST((dynamicBackendId6 ==
""));
1160 BOOST_TEST((dynamicBackendId7 ==
"Unknown"));
1162 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1164 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1170 BOOST_TEST(backendRegistry.
Size() == 0);
1172 std::vector<BackendId> expectedRegisteredbackendIds
1181 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1182 BOOST_TEST(registeredBackendIds.size() == expectedRegisteredbackendIds.size());
1185 BOOST_TEST(backendIds.size() == expectedRegisteredbackendIds.size());
1186 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1188 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1189 BOOST_TEST((registeredBackendIds.find(expectedRegisteredbackendId) != registeredBackendIds.end()));
1191 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(expectedRegisteredbackendId);
1192 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
1195 BOOST_TEST((dynamicBackend !=
nullptr));
1196 BOOST_TEST((dynamicBackend->GetId() == expectedRegisteredbackendId));
1200 #if !defined(ARMNN_DYNAMIC_BACKEND_ENABLED) 1204 using namespace armnn;
1210 BOOST_TEST(backendRegistry.
Size() == 0);
1213 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1215 const DeviceSpec& deviceSpec = *boost::polymorphic_downcast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1217 BOOST_TEST(supportedBackendIds.empty());
1219 BOOST_TEST(backendRegistry.
Size() == 0);
1226 using namespace armnn;
1227 using namespace boost::filesystem;
1233 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1239 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1241 std::vector<BackendId> expectedRegisteredbackendIds
1248 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1251 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1253 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1256 const DeviceSpec& deviceSpec = *boost::polymorphic_downcast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1258 BOOST_TEST(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1259 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1261 BOOST_TEST((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1267 using namespace armnn;
1268 using namespace boost::filesystem;
1274 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1280 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1282 std::vector<BackendId> expectedRegisteredbackendIds
1289 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1292 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1294 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1297 const DeviceSpec& deviceSpec = *boost::polymorphic_downcast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1299 BOOST_TEST(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1300 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1302 BOOST_TEST((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1308 using namespace armnn;
1309 using namespace boost::filesystem;
1315 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1321 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1324 BOOST_TEST(backendRegistry.
Size() == 0);
1326 const DeviceSpec& deviceSpec = *boost::polymorphic_downcast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1328 BOOST_TEST(supportedBackendIds.empty());
1333 using namespace armnn;
1341 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1344 BOOST_TEST(backendRegistry.
Size() == 0);
1346 const DeviceSpec& deviceSpec = *boost::polymorphic_downcast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1348 BOOST_TEST(supportedBackendIds.empty());
1351 #if defined(ARMNNREF_ENABLED) 1355 void CreateReferenceDynamicBackendTestImpl()
1357 using namespace armnn;
1358 using namespace boost::filesystem;
1366 g_ReferenceDynamicBackendSubDir);
1367 BOOST_CHECK(exists(referenceDynamicBackendSubDir));
1370 std::string referenceBackendFilePath =
GetTestFilePath(referenceDynamicBackendSubDir,
1371 g_ReferenceBackendFileName);
1377 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1380 BOOST_TEST(backendRegistry.
Size() == 1);
1383 BOOST_TEST((backendIds.find(
"CpuRef") != backendIds.end()));
1385 const DeviceSpec& deviceSpec = *boost::polymorphic_downcast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1387 BOOST_TEST(supportedBackendIds.size() == 1);
1388 BOOST_TEST((supportedBackendIds.find(
"CpuRef") != supportedBackendIds.end()));
1391 auto referenceDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"CpuRef");
1392 BOOST_TEST((referenceDynamicBackendFactoryFunction !=
nullptr));
1396 BOOST_TEST((referenceDynamicBackend !=
nullptr));
1397 BOOST_TEST((referenceDynamicBackend->GetId() ==
"CpuRef"));
1401 BOOST_TEST((referenceLayerSupport !=
nullptr));
1406 TensorInfo inputInfo (inputShape, DataType::Float32);
1407 TensorInfo outputInfo(outputShape, DataType::Float32);
1408 TensorInfo weightInfo(weightShape, DataType::Float32);
1410 bool referenceConvolution2dSupported =
1411 referenceLayerSupport->IsConvolution2dSupported(inputInfo,
1413 convolution2dDescriptor,
1416 BOOST_TEST(referenceConvolution2dSupported);
1420 BOOST_TEST((referenceWorkloadFactory !=
nullptr));
1429 convolution2dQueueDescriptor.
m_Inputs.push_back(
nullptr);
1430 auto weights = std::make_unique<ScopedCpuTensorHandle>(weightInfo);
1431 convolution2dQueueDescriptor.
m_Weight = weights.get();
1434 auto workload = referenceWorkloadFactory->CreateConvolution2d(convolution2dQueueDescriptor, workloadInfo);
1435 BOOST_TEST((workload !=
nullptr));
1436 BOOST_TEST(workload.get() == boost::polymorphic_downcast<RefConvolution2dWorkload*>(workload.get()));
1441 #if defined(SAMPLE_DYNAMIC_BACKEND_ENABLED) 1442 void CreateSampleDynamicBackendTestImpl()
1444 using namespace armnn;
1448 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1451 BOOST_TEST(backendRegistry.
Size() >= 1);
1454 BOOST_TEST((backendIds.find(
"SampleDynamic") != backendIds.end()));
1456 const DeviceSpec& deviceSpec = *boost::polymorphic_downcast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1458 BOOST_TEST(supportedBackendIds.size()>= 1);
1459 BOOST_TEST((supportedBackendIds.find(
"SampleDynamic") != supportedBackendIds.end()));
1462 auto sampleDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"SampleDynamic");
1463 BOOST_TEST((sampleDynamicBackendFactoryFunction !=
nullptr));
1467 BOOST_TEST((sampleDynamicBackend !=
nullptr));
1468 BOOST_TEST((sampleDynamicBackend->GetId() ==
"SampleDynamic"));
1472 BOOST_TEST((sampleLayerSupport !=
nullptr));
1477 TensorInfo inputInfo (inputShape, DataType::Float32);
1478 TensorInfo outputInfo(outputShape, DataType::Float32);
1479 TensorInfo weightInfo(weightShape, DataType::Float32);
1481 bool sampleConvolution2dSupported =
1482 sampleLayerSupport->IsConvolution2dSupported(inputInfo,
1484 convolution2dDescriptor,
1487 BOOST_TEST(!sampleConvolution2dSupported);
1491 BOOST_TEST((sampleWorkloadFactory !=
nullptr));
1497 { inputInfo, inputInfo },
1502 auto workload = sampleWorkloadFactory->CreateAddition(additionQueueDescriptor, workloadInfo);
1503 BOOST_TEST((workload !=
nullptr));
1506 void SampleDynamicBackendEndToEndTestImpl()
1508 using namespace armnn;
1509 using namespace boost::filesystem;
1536 runtime->LoadNetwork(netId, std::move(optNet));
1538 std::vector<float> input0Data{ 5.0f, 3.0f };
1539 std::vector<float> input1Data{ 10.0f, 8.0f };
1540 std::vector<float> expectedOutputData{ 15.0f, 11.0f };
1541 std::vector<float> outputData(2);
1550 {0,
armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
1554 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
1557 BOOST_TEST(outputData == expectedOutputData);
std::unique_ptr< IBackendInternal > IBackendInternalUniquePtr
void BackendVersioningTestImpl()
std::unique_ptr< IWorkloadFactory > IWorkloadFactoryPtr
std::function< PointerType()> FactoryFunction
void CloseInvalidHandleTestImpl()
void RuntimeEmptyTestImpl()
FactoryFunction GetFactory(const BackendId &id) const
static bool IsBackendCompatibleTest(const armnn::BackendVersion &backendApiVersion, const armnn::BackendVersion &backendVersion)
virtual const IInputSlot & GetInputSlot(unsigned int index) const =0
std::unordered_map< BackendId, FactoryFunction > FactoryStorage
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
void GetBackendPathsTestImpl()
void CreateDynamicBackendObjectInvalidInterface1TestImpl()
void CreateDynamicBackendsTestImpl()
std::vector< std::pair< LayerBindingId, class Tensor > > OutputTensors
IOptimizedNetworkPtr Optimize(const INetwork &network, const std::vector< BackendId > &backendPreferences, const IDeviceSpec &deviceSpec, const OptimizerOptions &options=OptimizerOptions(), Optional< std::vector< std::string > &> messages=EmptyOptional())
void CreateDynamicBackendObjectInvalidInterface7TestImpl()
void GetNotExistingEntryPointTestImpl()
void RegisterMixedDynamicBackendsTestImpl()
void RuntimeInvalidDynamicBackendsTestImpl()
std::string GetBasePath(const std::string &basePath)
void CreateDynamicBackendObjectInvalidInterface5TestImpl()
void RegisterSingleDynamicBackendTestImpl()
void RuntimeInvalidOverridePathTestImpl()
static BackendIdSet RegisterDynamicBackendsImpl(BackendRegistry &backendRegistry, const std::vector< DynamicBackendPtr > &dynamicBackends)
void CreateDynamicBackendObjectInvalidInterface3TestImpl()
virtual const BackendIdSet & GetSupportedBackends() const override
const ConstCpuTensorHandle * m_Weight
virtual void SetTensorInfo(const TensorInfo &tensorInfo)=0
void RegisterMultipleInvalidDynamicBackendsTestImpl()
static std::vector< DynamicBackendPtr > CreateDynamicBackends(const std::vector< std::string > &sharedObjects)
BackendRegistry & BackendRegistryInstance()
BackendIdSet GetBackendIds() const
std::string GetTestFilePath(const std::string &directory, const std::string &fileName)
void OpenEmptyFileNameTestImpl()
A tensor defined by a TensorInfo (shape and data type) and a mutable backing store.
void OpenCloseHandleTestImpl()
void CreateDynamicBackendsNoPathsTestImpl()
std::vector< std::pair< LayerBindingId, class ConstTensor > > InputTensors
void OpenNotSharedObjectTestImpl()
void RegisterMultipleDynamicBackendsTestImpl()
std::unique_ptr< DynamicBackend > DynamicBackendPtr
void CreateDynamicBackendObjectInvalidInterface6TestImpl()
void CreateDynamicBackendsAllInvalidTestImpl()
void GetBackendPathsOverrideTestImpl()
std::string GetTestSubDirectory(const std::string &subdir)
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
static std::vector< std::string > GetBackendPathsImpl(const std::string &backendPaths)
void CreateDynamicBackendObjectInvalidInterface2TestImpl()
static std::vector< std::string > GetBackendPathsImplTest(const std::string &path)
void GetNameMangledEntryPointTestImpl()
std::string GetTestDirectoryBasePath()
void CreateDynamicBackendObjectInvalidInterface4TestImpl()
std::unique_ptr< INetwork, void(*)(INetwork *network)> INetworkPtr
static bool IsBackendCompatibleImpl(const BackendVersion &backendApiVersion, const BackendVersion &backendVersion)
Protected methods for testing purposes.
void CreateDynamicBackendObjectInvalidHandleTestImpl()
void RuntimeDynamicBackendsTestImpl()
void RuntimeDuplicateDynamicBackendsTestImpl()
void OpenNotExistingFileTestImpl()
static armnn::BackendIdSet RegisterDynamicBackendsImplTest(armnn::BackendRegistry &backendRegistry, const std::vector< armnn::DynamicBackendPtr > &dynamicBackends)
std::string m_DynamicBackendsPath
std::unordered_set< BackendId > BackendIdSet
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
std::shared_ptr< ILayerSupport > ILayerSupportSharedPtr
std::unique_ptr< IOptimizedNetwork, void(*)(IOptimizedNetwork *network)> IOptimizedNetworkPtr
std::vector< ITensorHandle * > m_Inputs
void CreateValidDynamicBackendObjectTestImpl()
void GetValidEntryPointTestImpl()
A Convolution2dDescriptor for the Convolution2dLayer.
std::string GetDynamicBackendsBasePath()
virtual int Connect(IInputSlot &destination)=0
armnn::Runtime::CreationOptions::ExternalProfilingOptions options
static bool IsBackendCompatible(const BackendVersion &backendVersion)
std::unique_ptr< IRuntime, void(*)(IRuntime *runtime)> IRuntimePtr
void GetNoExternEntryPointTestImpl()
void CreateDynamicBackendsMixedTypesTestImpl()
void GetSharedObjectsTestImpl()
virtual const IOutputSlot & GetOutputSlot(unsigned int index) const =0
const char * GetBackendId()