20 #include <boost/test/unit_test.hpp> 21 #include <boost/filesystem.hpp> 22 #include <boost/dll.hpp> 24 static std::string g_TestBaseDir =
"src/backends/backendsCommon/test/";
26 static std::string g_TestSharedObjectSubDir =
"testSharedObject/";
27 static std::string g_TestDynamicBackendSubDir =
"testDynamicBackend/";
29 static std::string g_TestSharedObjectFileName =
"libTestSharedObject.so";
30 static std::string g_TestNoSharedObjectFileName =
"libNoSharedObject.txt";
32 static std::string g_TestValidTestDynamicBackendFileName =
"libValidTestDynamicBackend.so";
33 static std::string g_TestInvalidTestDynamicBackend1FileName =
"libInvalidTestDynamicBackend1.so";
34 static std::string g_TestInvalidTestDynamicBackend2FileName =
"libInvalidTestDynamicBackend2.so";
35 static std::string g_TestInvalidTestDynamicBackend3FileName =
"libInvalidTestDynamicBackend3.so";
36 static std::string g_TestInvalidTestDynamicBackend4FileName =
"libInvalidTestDynamicBackend4.so";
37 static std::string g_TestInvalidTestDynamicBackend5FileName =
"libInvalidTestDynamicBackend5.so";
38 static std::string g_TestInvalidTestDynamicBackend6FileName =
"libInvalidTestDynamicBackend6.so";
39 static std::string g_TestInvalidTestDynamicBackend7FileName =
"libInvalidTestDynamicBackend7.so";
41 static std::string g_TestValidBackend2FileName =
"Arm_TestValid2_backend.so";
42 static std::string g_TestValidBackend3FileName =
"Arm_TestValid3_backend.so";
43 static std::string g_TestValidBackend4FileName =
"Arm_TestValid4_backend.so";
44 static std::string g_TestValidBackend5FileName =
"Arm_TestValid5_backend.so";
45 static std::string g_TestInvalidBackend8FileName =
"Arm_TestInvalid8_backend.so";
46 static std::string g_TestInvalidBackend9FileName =
"Arm_TestInvalid9_backend.so";
47 static std::string g_TestInvalidBackend10FileName =
"Arm_TestInvalid10_backend.so";
48 static std::string g_TestInvalidBackend11FileName =
"Arm_TestInvalid11_backend.so";
50 static std::string g_TestDynamicBackendsSubDir1 =
"backendsTestPath1/";
51 static std::string g_TestDynamicBackendsSubDir2 =
"backendsTestPath2/";
52 static std::string g_TestDynamicBackendsSubDir3 =
"backendsTestPath3/";
53 static std::string g_TestDynamicBackendsSubDir4 =
"backendsTestPath4/";
54 static std::string g_TestDynamicBackendsSubDir5 =
"backendsTestPath5/";
55 static std::string g_TestDynamicBackendsSubDir6 =
"backendsTestPath6/";
56 static std::string g_TestDynamicBackendsSubDir7 =
"backendsTestPath7/";
57 static std::string g_TestDynamicBackendsSubDir8 =
"backendsTestPath8/";
58 static std::string g_TestDynamicBackendsSubDir9 =
"backendsTestPath9/";
60 static std::string g_DynamicBackendsBaseDir =
"src/backends/dynamic";
61 static std::string g_ReferenceDynamicBackendSubDir =
"reference/";
62 static std::string g_ReferenceBackendFileName =
"Arm_CpuRef_backend.so";
81 const std::vector<armnn::DynamicBackendPtr>& dynamicBackends)
107 using namespace boost::filesystem;
109 path programLocation = boost::dll::program_location().parent_path();
110 path sharedObjectPath = programLocation.append(basePath);
113 return sharedObjectPath.string();
128 using namespace boost::filesystem;
131 path testDynamicBackendsBasePath(testDynamicBackendsBaseDir);
132 path testDynamicBackendsSubDir = testDynamicBackendsBasePath.append(subdir);
135 return testDynamicBackendsSubDir.string();
140 using namespace boost::filesystem;
142 path testDynamicBackendsBasePath(basePath);
143 path testDynamicBackendsSubDir = testDynamicBackendsBasePath.append(subdir);
146 return testDynamicBackendsSubDir.string();
149 std::string
GetTestFilePath(
const std::string& directory,
const std::string& fileName)
151 using namespace boost::filesystem;
153 path directoryPath(directory);
154 path fileNamePath = directoryPath.append(fileName);
157 return fileNamePath.string();
162 using namespace armnn;
165 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
167 void* sharedObjectHandle =
nullptr;
168 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
169 BOOST_TEST((sharedObjectHandle !=
nullptr));
171 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
176 using namespace armnn;
179 DynamicBackendUtils::CloseHandle(
nullptr);
184 using namespace armnn;
186 void* sharedObjectHandle =
nullptr;
187 BOOST_CHECK_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(
""),
RuntimeException);
188 BOOST_TEST((sharedObjectHandle ==
nullptr));
193 using namespace armnn;
195 void* sharedObjectHandle =
nullptr;
196 BOOST_CHECK_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(
"NotExistingFileName"),
RuntimeException);
197 BOOST_TEST((sharedObjectHandle ==
nullptr));
202 using namespace armnn;
205 std::string notSharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestNoSharedObjectFileName);
207 void* sharedObjectHandle =
nullptr;
208 BOOST_CHECK_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(notSharedObjectFilePath),
RuntimeException);
209 BOOST_TEST((sharedObjectHandle ==
nullptr));
214 using namespace armnn;
217 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
219 void* sharedObjectHandle =
nullptr;
220 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
221 BOOST_TEST((sharedObjectHandle !=
nullptr));
223 using TestFunctionType = int(*)(int);
224 TestFunctionType testFunctionPointer =
nullptr;
225 BOOST_CHECK_NO_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
227 BOOST_TEST((testFunctionPointer !=
nullptr));
228 BOOST_TEST(testFunctionPointer(7) == 7);
230 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
235 using namespace armnn;
238 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
240 void* sharedObjectHandle =
nullptr;
241 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
242 BOOST_TEST((sharedObjectHandle !=
nullptr));
244 using TestFunctionType = int(*)(int);
245 TestFunctionType testFunctionPointer =
nullptr;
246 BOOST_CHECK_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
249 BOOST_TEST((testFunctionPointer ==
nullptr));
251 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
256 using namespace armnn;
259 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
261 void* sharedObjectHandle =
nullptr;
262 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
263 BOOST_TEST((sharedObjectHandle !=
nullptr));
265 using TestFunctionType = int(*)(int);
266 TestFunctionType testFunctionPointer =
nullptr;
267 BOOST_CHECK_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
270 BOOST_TEST((testFunctionPointer ==
nullptr));
272 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
277 using namespace armnn;
280 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
282 void* sharedObjectHandle =
nullptr;
283 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
284 BOOST_TEST((sharedObjectHandle !=
nullptr));
286 using TestFunctionType = int(*)(int);
287 TestFunctionType testFunctionPointer =
nullptr;
288 BOOST_CHECK_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
291 BOOST_TEST((testFunctionPointer ==
nullptr));
293 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
298 using namespace armnn;
305 BOOST_TEST(sameBackendVersion == backendApiVersion);
306 BOOST_TEST(sameBackendVersion <= backendApiVersion);
312 BOOST_TEST(!(laterMajorBackendVersion == backendApiVersion));
313 BOOST_TEST(!(laterMajorBackendVersion <= backendApiVersion));
317 BOOST_TEST(!(earlierMajorBackendVersion == backendApiVersion));
318 BOOST_TEST(earlierMajorBackendVersion <= backendApiVersion);
320 earlierMajorBackendVersion) ==
false);
325 BOOST_TEST(!(laterMinorBackendVersion == backendApiVersion));
326 BOOST_TEST(!(laterMinorBackendVersion <= backendApiVersion));
332 BOOST_TEST(!(earlierMinorBackendVersion == backendApiVersion));
333 BOOST_TEST(earlierMinorBackendVersion <= backendApiVersion);
344 using namespace armnn;
347 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestValidTestDynamicBackendFileName);
349 void* sharedObjectHandle =
nullptr;
350 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
351 BOOST_TEST((sharedObjectHandle !=
nullptr));
354 BOOST_CHECK_NO_THROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
355 BOOST_TEST((dynamicBackend !=
nullptr));
358 BOOST_CHECK_NO_THROW(dynamicBackendId = dynamicBackend->GetBackendId());
359 BOOST_TEST((dynamicBackendId ==
"ValidTestDynamicBackend"));
362 BOOST_CHECK_NO_THROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
363 BOOST_TEST((dynamicBackendVersion == IBackendInternal::GetApiVersion()));
366 BOOST_CHECK_NO_THROW(dynamicBackendInstance1 = dynamicBackend->GetBackend());
367 BOOST_TEST((dynamicBackendInstance1 !=
nullptr));
370 BOOST_CHECK_NO_THROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
371 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
374 BOOST_CHECK_NO_THROW(dynamicBackendInstance2 = dynamicBackendFactoryFunction());
375 BOOST_TEST((dynamicBackendInstance2 !=
nullptr));
377 BOOST_TEST((dynamicBackendInstance1->GetId() ==
"ValidTestDynamicBackend"));
378 BOOST_TEST((dynamicBackendInstance2->GetId() ==
"ValidTestDynamicBackend"));
385 using namespace armnn;
387 void* sharedObjectHandle =
nullptr;
390 BOOST_TEST((dynamicBackend ==
nullptr));
398 using namespace armnn;
401 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend1FileName);
403 void* sharedObjectHandle =
nullptr;
404 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
405 BOOST_TEST((sharedObjectHandle !=
nullptr));
409 BOOST_TEST((dynamicBackend ==
nullptr));
418 using namespace armnn;
421 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend2FileName);
423 void* sharedObjectHandle =
nullptr;
424 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
425 BOOST_TEST((sharedObjectHandle !=
nullptr));
429 BOOST_TEST((dynamicBackend ==
nullptr));
438 using namespace armnn;
441 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend3FileName);
443 void* sharedObjectHandle =
nullptr;
444 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
445 BOOST_TEST((sharedObjectHandle !=
nullptr));
449 BOOST_TEST((dynamicBackend ==
nullptr));
458 using namespace armnn;
461 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend4FileName);
463 void* sharedObjectHandle =
nullptr;
464 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
465 BOOST_TEST((sharedObjectHandle !=
nullptr));
469 BOOST_TEST((dynamicBackend ==
nullptr));
479 using namespace armnn;
482 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend5FileName);
484 void* sharedObjectHandle =
nullptr;
485 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
486 BOOST_TEST((sharedObjectHandle !=
nullptr));
490 BOOST_TEST((dynamicBackend ==
nullptr));
500 using namespace armnn;
503 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend6FileName);
505 void* sharedObjectHandle =
nullptr;
506 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
507 BOOST_TEST((sharedObjectHandle !=
nullptr));
510 BOOST_CHECK_NO_THROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
511 BOOST_TEST((dynamicBackend !=
nullptr));
514 BOOST_CHECK_NO_THROW(dynamicBackendId = dynamicBackend->GetBackendId());
515 BOOST_TEST((dynamicBackendId ==
"InvalidTestDynamicBackend"));
518 BOOST_CHECK_NO_THROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
522 BOOST_CHECK_THROW(dynamicBackendInstance1 = dynamicBackend->GetBackend(),
RuntimeException);
523 BOOST_TEST((dynamicBackendInstance1 ==
nullptr));
526 BOOST_CHECK_NO_THROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
527 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
530 BOOST_CHECK_THROW(dynamicBackendInstance2 = dynamicBackendFactoryFunction(),
RuntimeException);
531 BOOST_TEST((dynamicBackendInstance2 ==
nullptr));
541 using namespace armnn;
544 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend7FileName);
546 void* sharedObjectHandle =
nullptr;
547 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
548 BOOST_TEST((sharedObjectHandle !=
nullptr));
552 BOOST_TEST((dynamicBackend ==
nullptr));
557 using namespace armnn;
558 using namespace boost::filesystem;
581 std::string malformedDir(subDir1 +
"/" + subDir1);
586 BOOST_TEST(DynamicBackendPaths2.size() == 1);
587 BOOST_TEST(DynamicBackendPaths2[0] == subDir1);
590 std::string multipleEqualDirs(subDir1 +
":" + subDir1);
592 BOOST_TEST(DynamicBackendPaths3.size() == 1);
593 BOOST_TEST(DynamicBackendPaths3[0] == subDir1);
599 std::string multipleValidPaths(subDir1 +
":" + subDir2 +
":" + subDir3);
600 std::vector<std::string> DynamicBackendPaths5 =
602 BOOST_TEST(DynamicBackendPaths5.size() == 3);
603 BOOST_TEST(DynamicBackendPaths5[0] == subDir1);
604 BOOST_TEST(DynamicBackendPaths5[1] == subDir2);
605 BOOST_TEST(DynamicBackendPaths5[2] == subDir3);
608 std::string validAmongEmptyDirs(
"::" + subDir1 +
":");
609 std::vector<std::string> DynamicBackendPaths6 =
611 BOOST_TEST(DynamicBackendPaths6.size() == 1);
612 BOOST_TEST(DynamicBackendPaths6[0] == subDir1);
615 std::string invalidAmongEmptyDirs(
":" + subDir4 +
"::");
619 std::string validInvalidEmptyDirs(subDir1 +
":" + subDir4 +
":");
620 std::vector<std::string> DynamicBackendPaths8 =
622 BOOST_TEST(DynamicBackendPaths8.size() == 1);
623 BOOST_TEST(DynamicBackendPaths8[0] == subDir1);
626 std::string duplicateValidInvalidEmptyDirs(validInvalidEmptyDirs +
":" + validInvalidEmptyDirs +
":" +
627 subDir2 +
":" + subDir2);
628 std::vector<std::string> DynamicBackendPaths9 =
630 BOOST_TEST(DynamicBackendPaths9.size() == 2);
631 BOOST_TEST(DynamicBackendPaths9[0] == subDir1);
632 BOOST_TEST(DynamicBackendPaths9[1] == subDir2);
637 using namespace armnn;
638 using namespace boost::filesystem;
647 std::vector<std::string> validResult = DynamicBackendUtils::GetBackendPaths(subDir1);
648 BOOST_TEST(validResult.size() == 1);
649 BOOST_TEST(validResult[0] == subDir1);
652 std::vector<std::string> invalidResult = DynamicBackendUtils::GetBackendPaths(subDir4);
653 BOOST_TEST(invalidResult.empty());
658 using namespace armnn;
659 using namespace boost::filesystem;
705 std::string testDynamicBackendsSubDir1 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir1);
706 std::string testDynamicBackendsSubDir2 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir2);
707 std::string testDynamicBackendsSubDir3 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir3);
708 std::string testDynamicBackendsSubDir4 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir4);
714 std::vector<std::string> backendPaths
716 testDynamicBackendsSubDir1,
717 testDynamicBackendsSubDir2,
718 testDynamicBackendsSubDir3,
719 testDynamicBackendsSubDir4
721 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
722 std::vector<std::string> expectedSharedObjects
724 testDynamicBackendsSubDir1 +
"Arm123_GpuAcc_backend.so",
725 testDynamicBackendsSubDir1 +
"Arm_GpuAcc456_backend.so",
726 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so",
727 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1",
728 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2",
729 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2.3",
730 testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.10.1.27",
731 testDynamicBackendsSubDir2 +
"Arm_CpuAcc_backend.so",
732 testDynamicBackendsSubDir2 +
"Arm_GpuAcc_backend.so" 735 BOOST_TEST(sharedObjects.size() == expectedSharedObjects.size());
736 BOOST_TEST(sharedObjects[0] == expectedSharedObjects[0]);
737 BOOST_TEST(sharedObjects[1] == expectedSharedObjects[1]);
738 BOOST_TEST(sharedObjects[2] == expectedSharedObjects[2]);
739 BOOST_TEST(sharedObjects[3] == expectedSharedObjects[3]);
740 BOOST_TEST(sharedObjects[4] == expectedSharedObjects[4]);
741 BOOST_TEST(sharedObjects[5] == expectedSharedObjects[5]);
742 BOOST_TEST(sharedObjects[6] == expectedSharedObjects[6]);
743 BOOST_TEST(sharedObjects[7] == expectedSharedObjects[7]);
744 BOOST_TEST(sharedObjects[8] == expectedSharedObjects[8]);
749 using namespace armnn;
750 using namespace boost::filesystem;
776 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
777 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
778 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
779 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
785 std::vector<std::string> backendPaths
787 testDynamicBackendsSubDir5,
788 testDynamicBackendsSubDir6,
789 testDynamicBackendsSubDir7,
790 testDynamicBackendsSubDir8
792 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
793 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
795 BOOST_TEST(dynamicBackends.size() == 5);
796 BOOST_TEST((dynamicBackends[0] !=
nullptr));
797 BOOST_TEST((dynamicBackends[1] !=
nullptr));
798 BOOST_TEST((dynamicBackends[2] !=
nullptr));
799 BOOST_TEST((dynamicBackends[3] !=
nullptr));
800 BOOST_TEST((dynamicBackends[4] !=
nullptr));
803 BOOST_TEST((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
804 BOOST_TEST((dynamicBackends[1]->
GetBackendId() ==
"TestValid3"));
805 BOOST_TEST((dynamicBackends[2]->
GetBackendId() ==
"TestValid2"));
806 BOOST_TEST((dynamicBackends[3]->
GetBackendId() ==
"TestValid2"));
807 BOOST_TEST((dynamicBackends[4]->
GetBackendId() ==
"TestValid5"));
812 using namespace armnn;
814 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends({});
816 BOOST_TEST(dynamicBackends.empty());
821 using namespace armnn;
823 std::vector<std::string> sharedObjects
825 "InvalidSharedObject1",
826 "InvalidSharedObject2",
827 "InvalidSharedObject3",
829 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
831 BOOST_TEST(dynamicBackends.empty());
836 using namespace armnn;
837 using namespace boost::filesystem;
839 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
840 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
844 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
845 g_TestValidBackend2FileName);
846 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
847 g_TestInvalidBackend8FileName);
848 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
849 g_TestInvalidBackend9FileName);
854 std::vector<std::string> sharedObjects
856 testValidBackend2FilePath,
857 testInvalidBackend8FilePath,
858 testInvalidBackend9FilePath,
859 "InvalidSharedObject",
861 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
863 BOOST_TEST(dynamicBackends.size() == 1);
864 BOOST_TEST((dynamicBackends[0] !=
nullptr));
865 BOOST_TEST((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
870 using namespace armnn;
871 using namespace boost::filesystem;
877 BOOST_TEST(backendRegistry.
Size() == 0);
879 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
882 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
885 std::vector<std::string> sharedObjects{ testValidBackend2FilePath };
888 BOOST_TEST(dynamicBackends.size() == 1);
889 BOOST_TEST((dynamicBackends[0] !=
nullptr));
891 BackendId dynamicBackendId = dynamicBackends[0]->GetBackendId();
892 BOOST_TEST((dynamicBackendId ==
"TestValid2"));
894 BackendVersion dynamicBackendVersion = dynamicBackends[0]->GetBackendVersion();
899 BOOST_TEST(backendRegistry.
Size() == 1);
900 BOOST_TEST(registeredBackendIds.size() == 1);
903 BOOST_TEST(backendIds.size() == 1);
904 BOOST_TEST((backendIds.find(dynamicBackendId) != backendIds.end()));
905 BOOST_TEST((registeredBackendIds.find(dynamicBackendId) != registeredBackendIds.end()));
907 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(dynamicBackendId);
908 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
911 BOOST_TEST((dynamicBackend !=
nullptr));
912 BOOST_TEST((dynamicBackend->GetId() == dynamicBackendId));
917 using namespace armnn;
918 using namespace boost::filesystem;
922 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
923 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
927 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
928 std::string testValidBackend3FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend3FileName);
929 std::string testValidBackend5FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend5FileName);
934 std::vector<std::string> sharedObjects
936 testValidBackend2FilePath,
937 testValidBackend3FilePath,
938 testValidBackend5FilePath
942 BOOST_TEST(dynamicBackends.size() == 3);
943 BOOST_TEST((dynamicBackends[0] !=
nullptr));
944 BOOST_TEST((dynamicBackends[1] !=
nullptr));
945 BOOST_TEST((dynamicBackends[2] !=
nullptr));
947 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
948 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
949 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
950 BOOST_TEST((dynamicBackendId1 ==
"TestValid2"));
951 BOOST_TEST((dynamicBackendId2 ==
"TestValid3"));
952 BOOST_TEST((dynamicBackendId3 ==
"TestValid5"));
954 for (
size_t i = 0; i < dynamicBackends.size(); i++)
956 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
962 BOOST_TEST(backendRegistry.
Size() == 0);
966 BOOST_TEST(backendRegistry.
Size() == 3);
967 BOOST_TEST(registeredBackendIds.size() == 3);
970 BOOST_TEST(backendIds.size() == 3);
971 BOOST_TEST((backendIds.find(dynamicBackendId1) != backendIds.end()));
972 BOOST_TEST((backendIds.find(dynamicBackendId2) != backendIds.end()));
973 BOOST_TEST((backendIds.find(dynamicBackendId3) != backendIds.end()));
974 BOOST_TEST((registeredBackendIds.find(dynamicBackendId1) != registeredBackendIds.end()));
975 BOOST_TEST((registeredBackendIds.find(dynamicBackendId2) != registeredBackendIds.end()));
976 BOOST_TEST((registeredBackendIds.find(dynamicBackendId3) != registeredBackendIds.end()));
978 for (
size_t i = 0; i < dynamicBackends.size(); i++)
980 BackendId dynamicBackendId = dynamicBackends[i]->GetBackendId();
982 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(dynamicBackendId);
983 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
986 BOOST_TEST((dynamicBackend !=
nullptr));
987 BOOST_TEST((dynamicBackend->GetId() == dynamicBackendId));
993 using namespace armnn;
994 using namespace boost::filesystem;
1007 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1010 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1011 g_TestInvalidBackend10FileName);
1012 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1013 g_TestInvalidBackend11FileName);
1014 BOOST_CHECK(exists(testInvalidBackend10FilePath));
1015 BOOST_CHECK(exists(testInvalidBackend11FilePath));
1017 std::vector<std::string> sharedObjects
1019 testInvalidBackend10FilePath,
1020 testInvalidBackend11FilePath,
1021 "InvalidSharedObject" 1025 BOOST_TEST(dynamicBackends.size() == 2);
1026 BOOST_TEST((dynamicBackends[0] !=
nullptr));
1027 BOOST_TEST((dynamicBackends[1] !=
nullptr));
1029 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1030 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1031 BOOST_TEST((dynamicBackendId1 ==
""));
1032 BOOST_TEST((dynamicBackendId2 ==
"Unknown"));
1034 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1036 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1042 BOOST_TEST(backendRegistry.
Size() == 0);
1047 BOOST_TEST(backendRegistry.
Size() == 0);
1048 BOOST_TEST(registeredBackendIds.empty());
1053 using namespace armnn;
1054 using namespace boost::filesystem;
1086 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1087 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1088 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
1089 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
1090 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1097 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
1098 std::string testValidBackend3FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend3FileName);
1099 std::string testValidBackend2DupFilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend2FileName);
1100 std::string testValidBackend4FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend4FileName);
1101 std::string testValidBackend5FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend5FileName);
1102 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
1103 g_TestInvalidBackend8FileName);
1104 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
1105 g_TestInvalidBackend9FileName);
1106 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1107 g_TestInvalidBackend10FileName);
1108 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1109 g_TestInvalidBackend11FileName);
1112 BOOST_CHECK(exists(testValidBackend2DupFilePath));
1117 BOOST_CHECK(exists(testInvalidBackend10FilePath));
1118 BOOST_CHECK(exists(testInvalidBackend11FilePath));
1120 std::vector<std::string> sharedObjects
1122 testValidBackend2FilePath,
1123 testValidBackend3FilePath,
1124 testValidBackend2DupFilePath,
1125 testValidBackend4FilePath,
1126 testValidBackend5FilePath,
1127 testInvalidBackend8FilePath,
1128 testInvalidBackend9FilePath,
1129 testInvalidBackend10FilePath,
1130 testInvalidBackend11FilePath,
1131 "InvalidSharedObject" 1135 BOOST_TEST(dynamicBackends.size() == 7);
1136 BOOST_TEST((dynamicBackends[0] !=
nullptr));
1137 BOOST_TEST((dynamicBackends[1] !=
nullptr));
1138 BOOST_TEST((dynamicBackends[2] !=
nullptr));
1139 BOOST_TEST((dynamicBackends[3] !=
nullptr));
1140 BOOST_TEST((dynamicBackends[4] !=
nullptr));
1141 BOOST_TEST((dynamicBackends[5] !=
nullptr));
1142 BOOST_TEST((dynamicBackends[6] !=
nullptr));
1144 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1145 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1146 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
1147 BackendId dynamicBackendId4 = dynamicBackends[3]->GetBackendId();
1148 BackendId dynamicBackendId5 = dynamicBackends[4]->GetBackendId();
1149 BackendId dynamicBackendId6 = dynamicBackends[5]->GetBackendId();
1150 BackendId dynamicBackendId7 = dynamicBackends[6]->GetBackendId();
1151 BOOST_TEST((dynamicBackendId1 ==
"TestValid2"));
1152 BOOST_TEST((dynamicBackendId2 ==
"TestValid3"));
1153 BOOST_TEST((dynamicBackendId3 ==
"TestValid2"));
1154 BOOST_TEST((dynamicBackendId4 ==
"TestValid2"));
1155 BOOST_TEST((dynamicBackendId5 ==
"TestValid5"));
1156 BOOST_TEST((dynamicBackendId6 ==
""));
1157 BOOST_TEST((dynamicBackendId7 ==
"Unknown"));
1159 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1161 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1167 BOOST_TEST(backendRegistry.
Size() == 0);
1169 std::vector<BackendId> expectedRegisteredbackendIds
1178 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1179 BOOST_TEST(registeredBackendIds.size() == expectedRegisteredbackendIds.size());
1182 BOOST_TEST(backendIds.size() == expectedRegisteredbackendIds.size());
1183 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1185 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1186 BOOST_TEST((registeredBackendIds.find(expectedRegisteredbackendId) != registeredBackendIds.end()));
1188 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(expectedRegisteredbackendId);
1189 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
1192 BOOST_TEST((dynamicBackend !=
nullptr));
1193 BOOST_TEST((dynamicBackend->GetId() == expectedRegisteredbackendId));
1197 #if !defined(ARMNN_DYNAMIC_BACKEND_ENABLED) 1201 using namespace armnn;
1207 BOOST_TEST(backendRegistry.
Size() == 0);
1210 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1212 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1214 BOOST_TEST(supportedBackendIds.empty());
1216 BOOST_TEST(backendRegistry.
Size() == 0);
1223 using namespace armnn;
1224 using namespace boost::filesystem;
1230 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1236 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1238 std::vector<BackendId> expectedRegisteredbackendIds
1245 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1248 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1250 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1253 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1255 BOOST_TEST(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1256 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1258 BOOST_TEST((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1264 using namespace armnn;
1265 using namespace boost::filesystem;
1271 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1277 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1279 std::vector<BackendId> expectedRegisteredbackendIds
1286 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1289 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1291 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1294 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1296 BOOST_TEST(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1297 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1299 BOOST_TEST((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1305 using namespace armnn;
1306 using namespace boost::filesystem;
1312 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1318 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1321 BOOST_TEST(backendRegistry.
Size() == 0);
1323 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1325 BOOST_TEST(supportedBackendIds.empty());
1330 using namespace armnn;
1338 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1341 BOOST_TEST(backendRegistry.
Size() == 0);
1343 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1345 BOOST_TEST(supportedBackendIds.empty());
1348 #if defined(ARMNNREF_ENABLED) 1352 void CreateReferenceDynamicBackendTestImpl()
1354 using namespace armnn;
1355 using namespace boost::filesystem;
1363 g_ReferenceDynamicBackendSubDir);
1364 BOOST_CHECK(exists(referenceDynamicBackendSubDir));
1367 std::string referenceBackendFilePath =
GetTestFilePath(referenceDynamicBackendSubDir,
1368 g_ReferenceBackendFileName);
1374 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1377 BOOST_TEST(backendRegistry.
Size() == 1);
1380 BOOST_TEST((backendIds.find(
"CpuRef") != backendIds.end()));
1382 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1384 BOOST_TEST(supportedBackendIds.size() == 1);
1385 BOOST_TEST((supportedBackendIds.find(
"CpuRef") != supportedBackendIds.end()));
1388 auto referenceDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"CpuRef");
1389 BOOST_TEST((referenceDynamicBackendFactoryFunction !=
nullptr));
1393 BOOST_TEST((referenceDynamicBackend !=
nullptr));
1394 BOOST_TEST((referenceDynamicBackend->GetId() ==
"CpuRef"));
1398 BOOST_TEST((referenceLayerSupport !=
nullptr));
1403 TensorInfo inputInfo (inputShape, DataType::Float32);
1404 TensorInfo outputInfo(outputShape, DataType::Float32);
1405 TensorInfo weightInfo(weightShape, DataType::Float32);
1407 bool referenceConvolution2dSupported =
1408 referenceLayerSupport->IsConvolution2dSupported(inputInfo,
1410 convolution2dDescriptor,
1413 BOOST_TEST(referenceConvolution2dSupported);
1417 BOOST_TEST((referenceWorkloadFactory !=
nullptr));
1426 convolution2dQueueDescriptor.
m_Inputs.push_back(
nullptr);
1427 auto weights = std::make_unique<ScopedCpuTensorHandle>(weightInfo);
1428 convolution2dQueueDescriptor.
m_Weight = weights.get();
1431 auto workload = referenceWorkloadFactory->CreateConvolution2d(convolution2dQueueDescriptor, workloadInfo);
1432 BOOST_TEST((workload !=
nullptr));
1433 BOOST_TEST(workload.get() == PolymorphicDowncast<RefConvolution2dWorkload*>(workload.get()));
1438 #if defined(SAMPLE_DYNAMIC_BACKEND_ENABLED) 1439 void CreateSampleDynamicBackendTestImpl()
1441 using namespace armnn;
1445 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1448 BOOST_TEST(backendRegistry.
Size() >= 1);
1451 BOOST_TEST((backendIds.find(
"SampleDynamic") != backendIds.end()));
1453 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1455 BOOST_TEST(supportedBackendIds.size()>= 1);
1456 BOOST_TEST((supportedBackendIds.find(
"SampleDynamic") != supportedBackendIds.end()));
1459 auto sampleDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"SampleDynamic");
1460 BOOST_TEST((sampleDynamicBackendFactoryFunction !=
nullptr));
1464 BOOST_TEST((sampleDynamicBackend !=
nullptr));
1465 BOOST_TEST((sampleDynamicBackend->GetId() ==
"SampleDynamic"));
1469 BOOST_TEST((sampleLayerSupport !=
nullptr));
1474 TensorInfo inputInfo (inputShape, DataType::Float32);
1475 TensorInfo outputInfo(outputShape, DataType::Float32);
1476 TensorInfo weightInfo(weightShape, DataType::Float32);
1478 bool sampleConvolution2dSupported =
1479 sampleLayerSupport->IsConvolution2dSupported(inputInfo,
1481 convolution2dDescriptor,
1484 BOOST_TEST(!sampleConvolution2dSupported);
1488 BOOST_TEST((sampleWorkloadFactory !=
nullptr));
1494 { inputInfo, inputInfo },
1499 auto workload = sampleWorkloadFactory->CreateAddition(additionQueueDescriptor, workloadInfo);
1500 BOOST_TEST((workload !=
nullptr));
1503 void SampleDynamicBackendEndToEndTestImpl()
1505 using namespace armnn;
1506 using namespace boost::filesystem;
1533 runtime->LoadNetwork(netId, std::move(optNet));
1535 std::vector<float> input0Data{ 5.0f, 3.0f };
1536 std::vector<float> input1Data{ 10.0f, 8.0f };
1537 std::vector<float> expectedOutputData{ 15.0f, 11.0f };
1538 std::vector<float> outputData(2);
1547 {0,
armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
1551 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
1554 BOOST_TEST(outputData == expectedOutputData);
void GetNameMangledEntryPointTestImpl()
void GetNoExternEntryPointTestImpl()
void GetSharedObjectsTestImpl()
void CreateDynamicBackendsNoPathsTestImpl()
static armnn::BackendIdSet RegisterDynamicBackendsImplTest(armnn::BackendRegistry &backendRegistry, const std::vector< armnn::DynamicBackendPtr > &dynamicBackends)
FactoryFunction GetFactory(const BackendId &id) const
std::unique_ptr< IWorkloadFactory > IWorkloadFactoryPtr
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
BackendIdSet GetBackendIds() const
void CreateDynamicBackendObjectInvalidInterface3TestImpl()
std::function< PointerType()> FactoryFunction
std::string GetTestSubDirectory(const std::string &subdir)
std::unordered_set< BackendId > BackendIdSet
void CreateDynamicBackendsAllInvalidTestImpl()
static bool IsBackendCompatible(const BackendVersion &backendVersion)
void OpenNotSharedObjectTestImpl()
A Convolution2dDescriptor for the Convolution2dLayer.
std::string GetTestDirectoryBasePath()
std::unique_ptr< IRuntime, void(*)(IRuntime *runtime)> IRuntimePtr
std::unordered_map< BackendId, FactoryFunction > FactoryStorage
BackendRegistry & BackendRegistryInstance()
std::vector< std::pair< LayerBindingId, class ConstTensor > > InputTensors
void BackendVersioningTestImpl()
static std::vector< DynamicBackendPtr > CreateDynamicBackends(const std::vector< std::string > &sharedObjects)
void CreateDynamicBackendObjectInvalidHandleTestImpl()
std::string GetTestFilePath(const std::string &directory, const std::string &fileName)
Copyright (c) 2020 ARM Limited.
BOOST_CHECK(profilingService.GetCurrentState()==ProfilingState::WaitingForAck)
std::unique_ptr< DynamicBackend > DynamicBackendPtr
void CreateDynamicBackendObjectInvalidInterface6TestImpl()
static std::vector< std::string > GetBackendPathsImplTest(const std::string &path)
virtual void SetTensorInfo(const TensorInfo &tensorInfo)=0
void RegisterMixedDynamicBackendsTestImpl()
A tensor defined by a TensorInfo (shape and data type) and a mutable backing store.
void GetValidEntryPointTestImpl()
void RuntimeDynamicBackendsTestImpl()
void GetBackendPathsOverrideTestImpl()
const char * GetBackendId()
IOptimizedNetworkPtr Optimize(const INetwork &network, const std::vector< BackendId > &backendPreferences, const IDeviceSpec &deviceSpec, const OptimizerOptions &options=OptimizerOptions(), Optional< std::vector< std::string > &> messages=EmptyOptional())
Create an optimized version of the network.
void CreateDynamicBackendObjectInvalidInterface5TestImpl()
const ConstCpuTensorHandle * m_Weight
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
void RegisterMultipleInvalidDynamicBackendsTestImpl()
std::vector< std::pair< LayerBindingId, class Tensor > > OutputTensors
void GetNotExistingEntryPointTestImpl()
void CreateDynamicBackendObjectInvalidInterface1TestImpl()
std::unique_ptr< IOptimizedNetwork, void(*)(IOptimizedNetwork *network)> IOptimizedNetworkPtr
void RuntimeInvalidOverridePathTestImpl()
void CreateDynamicBackendsTestImpl()
void CreateDynamicBackendObjectInvalidInterface2TestImpl()
void RegisterMultipleDynamicBackendsTestImpl()
void CloseInvalidHandleTestImpl()
std::shared_ptr< ILayerSupport > ILayerSupportSharedPtr
void CreateDynamicBackendsMixedTypesTestImpl()
void OpenEmptyFileNameTestImpl()
std::string m_DynamicBackendsPath
Setting this value will override the paths set by the DYNAMIC_BACKEND_PATHS compiler directive Only a...
static BackendIdSet RegisterDynamicBackendsImpl(BackendRegistry &backendRegistry, const std::vector< DynamicBackendPtr > &dynamicBackends)
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
static bool IsBackendCompatibleTest(const armnn::BackendVersion &backendApiVersion, const armnn::BackendVersion &backendVersion)
virtual const BackendIdSet & GetSupportedBackends() const override
void OpenCloseHandleTestImpl()
std::string GetDynamicBackendsBasePath()
virtual const IInputSlot & GetInputSlot(unsigned int index) const =0
Get a const input slot handle by slot index.
static bool IsBackendCompatibleImpl(const BackendVersion &backendApiVersion, const BackendVersion &backendVersion)
Protected methods for testing purposes.
void CreateDynamicBackendObjectInvalidInterface4TestImpl()
static std::vector< std::string > GetBackendPathsImpl(const std::string &backendPaths)
virtual const IOutputSlot & GetOutputSlot(unsigned int index) const =0
Get the const output slot handle by slot index.
Contains information about inputs and outputs to a layer.
void RegisterSingleDynamicBackendTestImpl()
void RuntimeEmptyTestImpl()
void RuntimeDuplicateDynamicBackendsTestImpl()
std::vector< ITensorHandle * > m_Inputs
std::unique_ptr< INetwork, void(*)(INetwork *network)> INetworkPtr
std::unique_ptr< IBackendInternal > IBackendInternalUniquePtr
std::string GetBasePath(const std::string &basePath)
virtual int Connect(IInputSlot &destination)=0
armnn::Runtime::CreationOptions::ExternalProfilingOptions options
void RuntimeInvalidDynamicBackendsTestImpl()
void CreateValidDynamicBackendObjectTestImpl()
void OpenNotExistingFileTestImpl()
void CreateDynamicBackendObjectInvalidInterface7TestImpl()
void GetBackendPathsTestImpl()