21 #include <boost/test/unit_test.hpp> 23 #if !defined(DYNAMIC_BACKEND_BUILD_DIR) 24 #define DYNAMIC_BACKEND_BUILD_DIR fs::path("./") 27 static std::string g_TestDirCLI =
"--dynamic-backend-build-dir";
28 static std::string g_TestBaseDir =
"src/backends/backendsCommon/test/";
30 static std::string g_TestSharedObjectSubDir =
"testSharedObject/";
31 static std::string g_TestDynamicBackendSubDir =
"testDynamicBackend/";
33 static std::string g_TestSharedObjectFileName =
"libTestSharedObject.so";
34 static std::string g_TestNoSharedObjectFileName =
"libNoSharedObject.txt";
36 static std::string g_TestValidTestDynamicBackendFileName =
"libValidTestDynamicBackend.so";
37 static std::string g_TestInvalidTestDynamicBackend1FileName =
"libInvalidTestDynamicBackend1.so";
38 static std::string g_TestInvalidTestDynamicBackend2FileName =
"libInvalidTestDynamicBackend2.so";
39 static std::string g_TestInvalidTestDynamicBackend3FileName =
"libInvalidTestDynamicBackend3.so";
40 static std::string g_TestInvalidTestDynamicBackend4FileName =
"libInvalidTestDynamicBackend4.so";
41 static std::string g_TestInvalidTestDynamicBackend5FileName =
"libInvalidTestDynamicBackend5.so";
42 static std::string g_TestInvalidTestDynamicBackend6FileName =
"libInvalidTestDynamicBackend6.so";
43 static std::string g_TestInvalidTestDynamicBackend7FileName =
"libInvalidTestDynamicBackend7.so";
45 static std::string g_TestValidBackend2FileName =
"Arm_TestValid2_backend.so";
46 static std::string g_TestValidBackend3FileName =
"Arm_TestValid3_backend.so";
47 static std::string g_TestValidBackend4FileName =
"Arm_TestValid4_backend.so";
48 static std::string g_TestValidBackend5FileName =
"Arm_TestValid5_backend.so";
49 static std::string g_TestInvalidBackend8FileName =
"Arm_TestInvalid8_backend.so";
50 static std::string g_TestInvalidBackend9FileName =
"Arm_TestInvalid9_backend.so";
51 static std::string g_TestInvalidBackend10FileName =
"Arm_TestInvalid10_backend.so";
52 static std::string g_TestInvalidBackend11FileName =
"Arm_TestInvalid11_backend.so";
54 static std::string g_TestDynamicBackendsSubDir1 =
"backendsTestPath1/";
55 static std::string g_TestDynamicBackendsSubDir2 =
"backendsTestPath2/";
56 static std::string g_TestDynamicBackendsSubDir3 =
"backendsTestPath3/";
57 static std::string g_TestDynamicBackendsSubDir4 =
"backendsTestPath4/";
58 static std::string g_TestDynamicBackendsSubDir5 =
"backendsTestPath5/";
59 static std::string g_TestDynamicBackendsSubDir6 =
"backendsTestPath6/";
60 static std::string g_TestDynamicBackendsSubDir7 =
"backendsTestPath7/";
61 static std::string g_TestDynamicBackendsSubDir8 =
"backendsTestPath8/";
62 static std::string g_TestDynamicBackendsSubDir9 =
"backendsTestPath9/";
64 static std::string g_DynamicBackendsBaseDir =
"src/backends/dynamic";
65 static std::string g_ReferenceDynamicBackendSubDir =
"reference/";
66 static std::string g_ReferenceBackendFileName =
"Arm_CpuRef_backend.so";
85 const std::vector<armnn::DynamicBackendPtr>& dynamicBackends)
122 if (boost::unit_test::framework::master_test_suite().argc == 3)
125 if (g_TestDirCLI.compare(boost::unit_test::framework::master_test_suite().argv[1]) == 0)
128 programLocation = boost::unit_test::framework::master_test_suite().argv[2];
134 if (!exists(programLocation))
137 path arg0Path(boost::unit_test::framework::master_test_suite().argv[0]);
138 arg0Path.remove_filename();
139 path arg0SharedObjectPath(arg0Path);
140 arg0SharedObjectPath.append(basePath);
141 if (exists(arg0SharedObjectPath))
144 programLocation = arg0Path;
149 path sharedObjectPath = programLocation.append(basePath);
150 BOOST_REQUIRE_MESSAGE(exists(sharedObjectPath),
"Base path for shared objects does not exist: " +
151 sharedObjectPath.string() +
"\nTo specify the root of this base path on the " +
152 "command line add: \'-- --dynamic-backend-build-dir <path>\'");
153 return sharedObjectPath.string();
171 path testDynamicBackendsBasePath(testDynamicBackendsBaseDir);
172 path testDynamicBackendsSubDir = testDynamicBackendsBasePath.append(subdir);
175 return testDynamicBackendsSubDir.string();
182 path testDynamicBackendsBasePath(basePath);
183 path testDynamicBackendsSubDir = testDynamicBackendsBasePath.append(subdir);
186 return testDynamicBackendsSubDir.string();
189 std::string
GetTestFilePath(
const std::string& directory,
const std::string& fileName)
193 path directoryPath(directory);
194 path fileNamePath = directoryPath.append(fileName);
195 BOOST_CHECK(exists(fileNamePath));
197 return fileNamePath.string();
202 using namespace armnn;
205 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
207 void* sharedObjectHandle =
nullptr;
208 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
209 BOOST_TEST((sharedObjectHandle !=
nullptr));
211 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
216 using namespace armnn;
219 DynamicBackendUtils::CloseHandle(
nullptr);
224 using namespace armnn;
226 void* sharedObjectHandle =
nullptr;
227 BOOST_CHECK_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(
""),
RuntimeException);
228 BOOST_TEST((sharedObjectHandle ==
nullptr));
233 using namespace armnn;
235 void* sharedObjectHandle =
nullptr;
236 BOOST_CHECK_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(
"NotExistingFileName"),
RuntimeException);
237 BOOST_TEST((sharedObjectHandle ==
nullptr));
242 using namespace armnn;
245 std::string notSharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestNoSharedObjectFileName);
247 void* sharedObjectHandle =
nullptr;
248 BOOST_CHECK_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(notSharedObjectFilePath),
RuntimeException);
249 BOOST_TEST((sharedObjectHandle ==
nullptr));
254 using namespace armnn;
257 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
259 void* sharedObjectHandle =
nullptr;
260 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
261 BOOST_TEST((sharedObjectHandle !=
nullptr));
263 using TestFunctionType = int(*)(int);
264 TestFunctionType testFunctionPointer =
nullptr;
265 BOOST_CHECK_NO_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
267 BOOST_TEST((testFunctionPointer !=
nullptr));
268 BOOST_TEST(testFunctionPointer(7) == 7);
270 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
275 using namespace armnn;
278 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
280 void* sharedObjectHandle =
nullptr;
281 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
282 BOOST_TEST((sharedObjectHandle !=
nullptr));
284 using TestFunctionType = int(*)(int);
285 TestFunctionType testFunctionPointer =
nullptr;
286 BOOST_CHECK_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
289 BOOST_TEST((testFunctionPointer ==
nullptr));
291 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
296 using namespace armnn;
299 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
301 void* sharedObjectHandle =
nullptr;
302 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
303 BOOST_TEST((sharedObjectHandle !=
nullptr));
305 using TestFunctionType = int(*)(int);
306 TestFunctionType testFunctionPointer =
nullptr;
307 BOOST_CHECK_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
310 BOOST_TEST((testFunctionPointer ==
nullptr));
312 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
317 using namespace armnn;
320 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
322 void* sharedObjectHandle =
nullptr;
323 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
324 BOOST_TEST((sharedObjectHandle !=
nullptr));
326 using TestFunctionType = int(*)(int);
327 TestFunctionType testFunctionPointer =
nullptr;
328 BOOST_CHECK_THROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
331 BOOST_TEST((testFunctionPointer ==
nullptr));
333 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
338 using namespace armnn;
345 BOOST_TEST(sameBackendVersion == backendApiVersion);
346 BOOST_TEST(sameBackendVersion <= backendApiVersion);
352 BOOST_TEST(!(laterMajorBackendVersion == backendApiVersion));
353 BOOST_TEST(!(laterMajorBackendVersion <= backendApiVersion));
357 BOOST_TEST(!(earlierMajorBackendVersion == backendApiVersion));
358 BOOST_TEST(earlierMajorBackendVersion <= backendApiVersion);
360 earlierMajorBackendVersion) ==
false);
365 BOOST_TEST(!(laterMinorBackendVersion == backendApiVersion));
366 BOOST_TEST(!(laterMinorBackendVersion <= backendApiVersion));
372 BOOST_TEST(!(earlierMinorBackendVersion == backendApiVersion));
373 BOOST_TEST(earlierMinorBackendVersion <= backendApiVersion);
377 #if defined(ARMNNREF_ENABLED) 378 void CreateValidDynamicBackendObjectTestImpl()
385 using namespace armnn;
390 BOOST_CHECK_MESSAGE(fs::exists(testSubDirectory),
391 "Base path for shared objects does not exist: " + testSubDirectory);
393 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestValidTestDynamicBackendFileName);
395 void* sharedObjectHandle =
nullptr;
396 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
397 BOOST_TEST((sharedObjectHandle !=
nullptr));
400 BOOST_CHECK_NO_THROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
401 BOOST_TEST((dynamicBackend !=
nullptr));
404 BOOST_CHECK_NO_THROW(dynamicBackendId = dynamicBackend->GetBackendId());
405 BOOST_TEST((dynamicBackendId ==
"ValidTestDynamicBackend"));
408 BOOST_CHECK_NO_THROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
409 BOOST_TEST((dynamicBackendVersion == IBackendInternal::GetApiVersion()));
412 BOOST_CHECK_NO_THROW(dynamicBackendInstance1 = dynamicBackend->GetBackend());
413 BOOST_TEST((dynamicBackendInstance1 !=
nullptr));
416 BOOST_CHECK_NO_THROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
417 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
420 BOOST_CHECK_NO_THROW(dynamicBackendInstance2 = dynamicBackendFactoryFunction());
421 BOOST_TEST((dynamicBackendInstance2 !=
nullptr));
423 BOOST_TEST((dynamicBackendInstance1->GetId() ==
"ValidTestDynamicBackend"));
424 BOOST_TEST((dynamicBackendInstance2->GetId() ==
"ValidTestDynamicBackend"));
432 using namespace armnn;
434 void* sharedObjectHandle =
nullptr;
437 BOOST_TEST((dynamicBackend ==
nullptr));
445 using namespace armnn;
448 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend1FileName);
450 void* sharedObjectHandle =
nullptr;
451 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
452 BOOST_TEST((sharedObjectHandle !=
nullptr));
456 BOOST_TEST((dynamicBackend ==
nullptr));
465 using namespace armnn;
468 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend2FileName);
470 void* sharedObjectHandle =
nullptr;
471 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
472 BOOST_TEST((sharedObjectHandle !=
nullptr));
476 BOOST_TEST((dynamicBackend ==
nullptr));
485 using namespace armnn;
488 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend3FileName);
490 void* sharedObjectHandle =
nullptr;
491 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
492 BOOST_TEST((sharedObjectHandle !=
nullptr));
496 BOOST_TEST((dynamicBackend ==
nullptr));
505 using namespace armnn;
508 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend4FileName);
510 void* sharedObjectHandle =
nullptr;
511 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
512 BOOST_TEST((sharedObjectHandle !=
nullptr));
516 BOOST_TEST((dynamicBackend ==
nullptr));
526 using namespace armnn;
529 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend5FileName);
531 void* sharedObjectHandle =
nullptr;
532 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
533 BOOST_TEST((sharedObjectHandle !=
nullptr));
537 BOOST_TEST((dynamicBackend ==
nullptr));
547 using namespace armnn;
550 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend6FileName);
552 void* sharedObjectHandle =
nullptr;
553 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
554 BOOST_TEST((sharedObjectHandle !=
nullptr));
557 BOOST_CHECK_NO_THROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
558 BOOST_TEST((dynamicBackend !=
nullptr));
561 BOOST_CHECK_NO_THROW(dynamicBackendId = dynamicBackend->GetBackendId());
562 BOOST_TEST((dynamicBackendId ==
"InvalidTestDynamicBackend"));
565 BOOST_CHECK_NO_THROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
569 BOOST_CHECK_THROW(dynamicBackendInstance1 = dynamicBackend->GetBackend(),
RuntimeException);
570 BOOST_TEST((dynamicBackendInstance1 ==
nullptr));
573 BOOST_CHECK_NO_THROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
574 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
577 BOOST_CHECK_THROW(dynamicBackendInstance2 = dynamicBackendFactoryFunction(),
RuntimeException);
578 BOOST_TEST((dynamicBackendInstance2 ==
nullptr));
588 using namespace armnn;
591 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend7FileName);
593 void* sharedObjectHandle =
nullptr;
594 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
595 BOOST_TEST((sharedObjectHandle !=
nullptr));
599 BOOST_TEST((dynamicBackend ==
nullptr));
604 using namespace armnn;
619 BOOST_CHECK(exists(subDir1));
620 BOOST_CHECK(exists(subDir2));
621 BOOST_CHECK(exists(subDir3));
622 BOOST_CHECK(!exists(subDir4));
628 std::string malformedDir(subDir1 +
"/" + subDir1);
633 BOOST_TEST(DynamicBackendPaths2.size() == 1);
634 BOOST_TEST(DynamicBackendPaths2[0] == subDir1);
637 std::string multipleEqualDirs(subDir1 +
":" + subDir1);
639 BOOST_TEST(DynamicBackendPaths3.size() == 1);
640 BOOST_TEST(DynamicBackendPaths3[0] == subDir1);
646 std::string multipleValidPaths(subDir1 +
":" + subDir2 +
":" + subDir3);
647 std::vector<std::string> DynamicBackendPaths5 =
649 BOOST_TEST(DynamicBackendPaths5.size() == 3);
650 BOOST_TEST(DynamicBackendPaths5[0] == subDir1);
651 BOOST_TEST(DynamicBackendPaths5[1] == subDir2);
652 BOOST_TEST(DynamicBackendPaths5[2] == subDir3);
655 std::string validAmongEmptyDirs(
"::" + subDir1 +
":");
656 std::vector<std::string> DynamicBackendPaths6 =
658 BOOST_TEST(DynamicBackendPaths6.size() == 1);
659 BOOST_TEST(DynamicBackendPaths6[0] == subDir1);
662 std::string invalidAmongEmptyDirs(
":" + subDir4 +
"::");
666 std::string validInvalidEmptyDirs(subDir1 +
":" + subDir4 +
":");
667 std::vector<std::string> DynamicBackendPaths8 =
669 BOOST_TEST(DynamicBackendPaths8.size() == 1);
670 BOOST_TEST(DynamicBackendPaths8[0] == subDir1);
673 std::string duplicateValidInvalidEmptyDirs(validInvalidEmptyDirs +
":" + validInvalidEmptyDirs +
":" +
674 subDir2 +
":" + subDir2);
675 std::vector<std::string> DynamicBackendPaths9 =
677 BOOST_TEST(DynamicBackendPaths9.size() == 2);
678 BOOST_TEST(DynamicBackendPaths9[0] == subDir1);
679 BOOST_TEST(DynamicBackendPaths9[1] == subDir2);
684 using namespace armnn;
690 BOOST_CHECK(exists(subDir1));
691 BOOST_CHECK(!exists(subDir4));
694 std::vector<std::string> validResult = DynamicBackendUtils::GetBackendPaths(subDir1);
695 BOOST_TEST(validResult.size() == 1);
696 BOOST_TEST(validResult[0] == subDir1);
699 std::vector<std::string> invalidResult = DynamicBackendUtils::GetBackendPaths(subDir4);
700 BOOST_TEST(invalidResult.empty());
705 using namespace armnn;
752 std::string testDynamicBackendsSubDir1 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir1);
753 std::string testDynamicBackendsSubDir2 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir2);
754 std::string testDynamicBackendsSubDir3 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir3);
755 std::string testDynamicBackendsSubDir4 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir4);
756 BOOST_CHECK(exists(testDynamicBackendsSubDir1));
757 BOOST_CHECK(exists(testDynamicBackendsSubDir2));
758 BOOST_CHECK(exists(testDynamicBackendsSubDir3));
759 BOOST_CHECK(!exists(testDynamicBackendsSubDir4));
761 std::vector<std::string> backendPaths
763 testDynamicBackendsSubDir1,
764 testDynamicBackendsSubDir2,
765 testDynamicBackendsSubDir3,
766 testDynamicBackendsSubDir4
768 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
769 std::vector<fs::path> expectedSharedObjects
771 path(testDynamicBackendsSubDir1 +
"Arm123_GpuAcc_backend.so"),
772 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc456_backend.so"),
773 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so"),
774 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1"),
775 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2"),
776 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2.3"),
777 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.10.1.27"),
778 path(testDynamicBackendsSubDir2 +
"Arm_CpuAcc_backend.so"),
779 path(testDynamicBackendsSubDir2 +
"Arm_GpuAcc_backend.so")
782 BOOST_TEST(sharedObjects.size() == expectedSharedObjects.size());
783 BOOST_TEST(fs::equivalent(path(sharedObjects[0]), expectedSharedObjects[0]));
784 BOOST_TEST(fs::equivalent(path(sharedObjects[1]), expectedSharedObjects[1]));
785 BOOST_TEST(fs::equivalent(path(sharedObjects[2]), expectedSharedObjects[2]));
786 BOOST_TEST(fs::equivalent(path(sharedObjects[3]), expectedSharedObjects[3]));
787 BOOST_TEST(fs::equivalent(path(sharedObjects[4]), expectedSharedObjects[4]));
788 BOOST_TEST(fs::equivalent(path(sharedObjects[5]), expectedSharedObjects[5]));
789 BOOST_TEST(fs::equivalent(path(sharedObjects[6]), expectedSharedObjects[6]));
790 BOOST_TEST(fs::equivalent(path(sharedObjects[7]), expectedSharedObjects[7]));
791 BOOST_TEST(fs::equivalent(path(sharedObjects[8]), expectedSharedObjects[8]));
796 using namespace armnn;
823 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
824 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
825 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
826 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
827 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
828 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
829 BOOST_CHECK(exists(testDynamicBackendsSubDir7));
830 BOOST_CHECK(!exists(testDynamicBackendsSubDir8));
832 std::vector<std::string> backendPaths
834 testDynamicBackendsSubDir5,
835 testDynamicBackendsSubDir6,
836 testDynamicBackendsSubDir7,
837 testDynamicBackendsSubDir8
839 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
840 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
842 BOOST_TEST(dynamicBackends.size() == 5);
843 BOOST_TEST((dynamicBackends[0] !=
nullptr));
844 BOOST_TEST((dynamicBackends[1] !=
nullptr));
845 BOOST_TEST((dynamicBackends[2] !=
nullptr));
846 BOOST_TEST((dynamicBackends[3] !=
nullptr));
847 BOOST_TEST((dynamicBackends[4] !=
nullptr));
850 BOOST_TEST((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
851 BOOST_TEST((dynamicBackends[1]->
GetBackendId() ==
"TestValid3"));
852 BOOST_TEST((dynamicBackends[2]->
GetBackendId() ==
"TestValid2"));
853 BOOST_TEST((dynamicBackends[3]->
GetBackendId() ==
"TestValid2"));
854 BOOST_TEST((dynamicBackends[4]->
GetBackendId() ==
"TestValid5"));
859 using namespace armnn;
861 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends({});
863 BOOST_TEST(dynamicBackends.empty());
868 using namespace armnn;
870 std::vector<std::string> sharedObjects
872 "InvalidSharedObject1",
873 "InvalidSharedObject2",
874 "InvalidSharedObject3",
876 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
878 BOOST_TEST(dynamicBackends.empty());
883 using namespace armnn;
886 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
887 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
888 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
889 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
891 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
892 g_TestValidBackend2FileName);
893 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
894 g_TestInvalidBackend8FileName);
895 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
896 g_TestInvalidBackend9FileName);
897 BOOST_CHECK(exists(testValidBackend2FilePath));
898 BOOST_CHECK(exists(testInvalidBackend8FilePath));
899 BOOST_CHECK(exists(testInvalidBackend9FilePath));
901 std::vector<std::string> sharedObjects
903 testValidBackend2FilePath,
904 testInvalidBackend8FilePath,
905 testInvalidBackend9FilePath,
906 "InvalidSharedObject",
908 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
910 BOOST_TEST(dynamicBackends.size() == 1);
911 BOOST_TEST((dynamicBackends[0] !=
nullptr));
912 BOOST_TEST((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
915 #if defined(ARMNNREF_ENABLED) 916 void RegisterSingleDynamicBackendTestImpl()
918 using namespace armnn;
925 BOOST_TEST(backendRegistry.
Size() == 0);
927 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
928 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
930 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
931 BOOST_CHECK(exists(testValidBackend2FilePath));
933 std::vector<std::string> sharedObjects{ testValidBackend2FilePath };
936 BOOST_TEST(dynamicBackends.size() == 1);
937 BOOST_TEST((dynamicBackends[0] !=
nullptr));
939 BackendId dynamicBackendId = dynamicBackends[0]->GetBackendId();
940 BOOST_TEST((dynamicBackendId ==
"TestValid2"));
942 BackendVersion dynamicBackendVersion = dynamicBackends[0]->GetBackendVersion();
947 BOOST_TEST(backendRegistry.
Size() == 1);
948 BOOST_TEST(registeredBackendIds.size() == 1);
951 BOOST_TEST(backendIds.size() == 1);
952 BOOST_TEST((backendIds.find(dynamicBackendId) != backendIds.end()));
953 BOOST_TEST((registeredBackendIds.find(dynamicBackendId) != registeredBackendIds.end()));
955 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(dynamicBackendId);
956 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
959 BOOST_TEST((dynamicBackend !=
nullptr));
960 BOOST_TEST((dynamicBackend->GetId() == dynamicBackendId));
963 void RegisterMultipleDynamicBackendsTestImpl()
965 using namespace armnn;
970 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
971 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
972 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
973 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
975 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
976 std::string testValidBackend3FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend3FileName);
977 std::string testValidBackend5FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend5FileName);
978 BOOST_CHECK(exists(testValidBackend2FilePath));
979 BOOST_CHECK(exists(testValidBackend3FilePath));
980 BOOST_CHECK(exists(testValidBackend5FilePath));
982 std::vector<std::string> sharedObjects
984 testValidBackend2FilePath,
985 testValidBackend3FilePath,
986 testValidBackend5FilePath
990 BOOST_TEST(dynamicBackends.size() == 3);
991 BOOST_TEST((dynamicBackends[0] !=
nullptr));
992 BOOST_TEST((dynamicBackends[1] !=
nullptr));
993 BOOST_TEST((dynamicBackends[2] !=
nullptr));
995 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
996 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
997 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
998 BOOST_TEST((dynamicBackendId1 ==
"TestValid2"));
999 BOOST_TEST((dynamicBackendId2 ==
"TestValid3"));
1000 BOOST_TEST((dynamicBackendId3 ==
"TestValid5"));
1002 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1004 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1010 BOOST_TEST(backendRegistry.
Size() == 0);
1014 BOOST_TEST(backendRegistry.
Size() == 3);
1015 BOOST_TEST(registeredBackendIds.size() == 3);
1018 BOOST_TEST(backendIds.size() == 3);
1019 BOOST_TEST((backendIds.find(dynamicBackendId1) != backendIds.end()));
1020 BOOST_TEST((backendIds.find(dynamicBackendId2) != backendIds.end()));
1021 BOOST_TEST((backendIds.find(dynamicBackendId3) != backendIds.end()));
1022 BOOST_TEST((registeredBackendIds.find(dynamicBackendId1) != registeredBackendIds.end()));
1023 BOOST_TEST((registeredBackendIds.find(dynamicBackendId2) != registeredBackendIds.end()));
1024 BOOST_TEST((registeredBackendIds.find(dynamicBackendId3) != registeredBackendIds.end()));
1026 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1028 BackendId dynamicBackendId = dynamicBackends[i]->GetBackendId();
1030 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(dynamicBackendId);
1031 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
1034 BOOST_TEST((dynamicBackend !=
nullptr));
1035 BOOST_TEST((dynamicBackend->GetId() == dynamicBackendId));
1039 void RegisterMixedDynamicBackendsTestImpl()
1041 using namespace armnn;
1074 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1075 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1076 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
1077 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
1078 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1079 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
1080 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
1081 BOOST_CHECK(exists(testDynamicBackendsSubDir7));
1082 BOOST_CHECK(!exists(testDynamicBackendsSubDir8));
1083 BOOST_CHECK(exists(testDynamicBackendsSubDir9));
1085 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
1086 std::string testValidBackend3FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend3FileName);
1087 std::string testValidBackend2DupFilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend2FileName);
1088 std::string testValidBackend4FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend4FileName);
1089 std::string testValidBackend5FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend5FileName);
1090 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
1091 g_TestInvalidBackend8FileName);
1092 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
1093 g_TestInvalidBackend9FileName);
1094 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1095 g_TestInvalidBackend10FileName);
1096 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1097 g_TestInvalidBackend11FileName);
1098 BOOST_CHECK(exists(testValidBackend2FilePath));
1099 BOOST_CHECK(exists(testValidBackend3FilePath));
1100 BOOST_CHECK(exists(testValidBackend2DupFilePath));
1101 BOOST_CHECK(exists(testValidBackend4FilePath));
1102 BOOST_CHECK(exists(testValidBackend5FilePath));
1103 BOOST_CHECK(exists(testInvalidBackend8FilePath));
1104 BOOST_CHECK(exists(testInvalidBackend9FilePath));
1105 BOOST_CHECK(exists(testInvalidBackend10FilePath));
1106 BOOST_CHECK(exists(testInvalidBackend11FilePath));
1108 std::vector<std::string> sharedObjects
1110 testValidBackend2FilePath,
1111 testValidBackend3FilePath,
1112 testValidBackend2DupFilePath,
1113 testValidBackend4FilePath,
1114 testValidBackend5FilePath,
1115 testInvalidBackend8FilePath,
1116 testInvalidBackend9FilePath,
1117 testInvalidBackend10FilePath,
1118 testInvalidBackend11FilePath,
1119 "InvalidSharedObject" 1123 BOOST_TEST(dynamicBackends.size() == 7);
1124 BOOST_TEST((dynamicBackends[0] !=
nullptr));
1125 BOOST_TEST((dynamicBackends[1] !=
nullptr));
1126 BOOST_TEST((dynamicBackends[2] !=
nullptr));
1127 BOOST_TEST((dynamicBackends[3] !=
nullptr));
1128 BOOST_TEST((dynamicBackends[4] !=
nullptr));
1129 BOOST_TEST((dynamicBackends[5] !=
nullptr));
1130 BOOST_TEST((dynamicBackends[6] !=
nullptr));
1132 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1133 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1134 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
1135 BackendId dynamicBackendId4 = dynamicBackends[3]->GetBackendId();
1136 BackendId dynamicBackendId5 = dynamicBackends[4]->GetBackendId();
1137 BackendId dynamicBackendId6 = dynamicBackends[5]->GetBackendId();
1138 BackendId dynamicBackendId7 = dynamicBackends[6]->GetBackendId();
1139 BOOST_TEST((dynamicBackendId1 ==
"TestValid2"));
1140 BOOST_TEST((dynamicBackendId2 ==
"TestValid3"));
1141 BOOST_TEST((dynamicBackendId3 ==
"TestValid2"));
1142 BOOST_TEST((dynamicBackendId4 ==
"TestValid2"));
1143 BOOST_TEST((dynamicBackendId5 ==
"TestValid5"));
1144 BOOST_TEST((dynamicBackendId6 ==
""));
1145 BOOST_TEST((dynamicBackendId7 ==
"Unknown"));
1147 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1149 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1155 BOOST_TEST(backendRegistry.
Size() == 0);
1157 std::vector<BackendId> expectedRegisteredbackendIds
1166 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1167 BOOST_TEST(registeredBackendIds.size() == expectedRegisteredbackendIds.size());
1170 BOOST_TEST(backendIds.size() == expectedRegisteredbackendIds.size());
1171 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1173 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1174 BOOST_TEST((registeredBackendIds.find(expectedRegisteredbackendId) != registeredBackendIds.end()));
1176 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(expectedRegisteredbackendId);
1177 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
1180 BOOST_TEST((dynamicBackend !=
nullptr));
1181 BOOST_TEST((dynamicBackend->GetId() == expectedRegisteredbackendId));
1188 using namespace armnn;
1202 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1203 BOOST_CHECK(exists(testDynamicBackendsSubDir9));
1205 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1206 g_TestInvalidBackend10FileName);
1207 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1208 g_TestInvalidBackend11FileName);
1209 BOOST_CHECK(exists(testInvalidBackend10FilePath));
1210 BOOST_CHECK(exists(testInvalidBackend11FilePath));
1212 std::vector<std::string> sharedObjects
1214 testInvalidBackend10FilePath,
1215 testInvalidBackend11FilePath,
1216 "InvalidSharedObject" 1220 BOOST_TEST(dynamicBackends.size() == 2);
1221 BOOST_TEST((dynamicBackends[0] !=
nullptr));
1222 BOOST_TEST((dynamicBackends[1] !=
nullptr));
1224 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1225 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1226 BOOST_TEST((dynamicBackendId1 ==
""));
1227 BOOST_TEST((dynamicBackendId2 ==
"Unknown"));
1229 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1231 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1237 BOOST_TEST(backendRegistry.
Size() == 0);
1242 BOOST_TEST(backendRegistry.
Size() == 0);
1243 BOOST_TEST(registeredBackendIds.empty());
1246 #if !defined(ARMNN_DYNAMIC_BACKEND_ENABLED) 1250 using namespace armnn;
1256 BOOST_TEST(backendRegistry.
Size() == 0);
1259 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1261 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1263 BOOST_TEST(supportedBackendIds.empty());
1265 BOOST_TEST(backendRegistry.
Size() == 0);
1272 using namespace armnn;
1279 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1280 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
1285 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1287 std::vector<BackendId> expectedRegisteredbackendIds
1294 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1297 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1299 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1302 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1304 BOOST_TEST(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1305 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1307 BOOST_TEST((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1313 using namespace armnn;
1320 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1321 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
1326 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1328 std::vector<BackendId> expectedRegisteredbackendIds
1335 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1338 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1340 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1343 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1345 BOOST_TEST(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1346 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1348 BOOST_TEST((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1354 using namespace armnn;
1361 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1362 BOOST_CHECK(exists(testDynamicBackendsSubDir9));
1367 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1370 BOOST_TEST(backendRegistry.
Size() == 0);
1372 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1374 BOOST_TEST(supportedBackendIds.empty());
1379 using namespace armnn;
1387 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1390 BOOST_TEST(backendRegistry.
Size() == 0);
1392 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1394 BOOST_TEST(supportedBackendIds.empty());
1397 #if defined(ARMNNREF_ENABLED) 1401 void CreateReferenceDynamicBackendTestImpl()
1403 using namespace armnn;
1412 g_ReferenceDynamicBackendSubDir);
1413 BOOST_CHECK(exists(referenceDynamicBackendSubDir));
1416 std::string referenceBackendFilePath =
GetTestFilePath(referenceDynamicBackendSubDir,
1417 g_ReferenceBackendFileName);
1418 BOOST_CHECK(exists(referenceBackendFilePath));
1423 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1426 BOOST_TEST(backendRegistry.
Size() == 1);
1429 BOOST_TEST((backendIds.find(
"CpuRef") != backendIds.end()));
1431 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1433 BOOST_TEST(supportedBackendIds.size() == 1);
1434 BOOST_TEST((supportedBackendIds.find(
"CpuRef") != supportedBackendIds.end()));
1437 auto referenceDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"CpuRef");
1438 BOOST_TEST((referenceDynamicBackendFactoryFunction !=
nullptr));
1442 BOOST_TEST((referenceDynamicBackend !=
nullptr));
1443 BOOST_TEST((referenceDynamicBackend->GetId() ==
"CpuRef"));
1447 BOOST_TEST((referenceLayerSupport !=
nullptr));
1452 TensorInfo inputInfo (inputShape, DataType::Float32);
1453 TensorInfo outputInfo(outputShape, DataType::Float32);
1454 TensorInfo weightInfo(weightShape, DataType::Float32);
1456 bool referenceConvolution2dSupported =
1457 referenceLayerSupport->IsConvolution2dSupported(inputInfo,
1459 convolution2dDescriptor,
1462 BOOST_TEST(referenceConvolution2dSupported);
1466 BOOST_TEST((referenceWorkloadFactory !=
nullptr));
1475 convolution2dQueueDescriptor.
m_Inputs.push_back(
nullptr);
1476 auto weights = std::make_unique<ScopedTensorHandle>(weightInfo);
1477 convolution2dQueueDescriptor.
m_Weight = weights.get();
1480 auto workload = referenceWorkloadFactory->CreateConvolution2d(convolution2dQueueDescriptor, workloadInfo);
1481 BOOST_TEST((workload !=
nullptr));
1482 BOOST_TEST(workload.get() == PolymorphicDowncast<RefConvolution2dWorkload*>(workload.get()));
1487 #if defined(SAMPLE_DYNAMIC_BACKEND_ENABLED) 1489 void CheckSampleDynamicBackendLoaded()
1491 using namespace armnn;
1495 if (backendIds.find(
"SampleDynamic") == backendIds.end())
1497 std::string message =
"The SampleDynamic backend has not been loaded. This may be a build configuration error. " 1498 "Ensure a DYNAMIC_BACKEND_PATHS was set at compile time to the location of " 1499 "libArm_SampleDynamic_backend.so. " 1500 "To disable this test recompile with: -DSAMPLE_DYNAMIC_BACKEND_ENABLED=0";
1501 BOOST_FAIL(message);
1505 void CreateSampleDynamicBackendTestImpl()
1507 using namespace armnn;
1510 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1512 BOOST_TEST(backendRegistry.
Size() >= 1);
1513 CheckSampleDynamicBackendLoaded();
1514 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1516 BOOST_TEST(supportedBackendIds.size()>= 1);
1517 BOOST_TEST((supportedBackendIds.find(
"SampleDynamic") != supportedBackendIds.end()));
1520 auto sampleDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"SampleDynamic");
1521 BOOST_TEST((sampleDynamicBackendFactoryFunction !=
nullptr));
1525 BOOST_TEST((sampleDynamicBackend !=
nullptr));
1526 BOOST_TEST((sampleDynamicBackend->GetId() ==
"SampleDynamic"));
1530 BOOST_TEST((sampleLayerSupport !=
nullptr));
1535 TensorInfo inputInfo (inputShape, DataType::Float32);
1536 TensorInfo outputInfo(outputShape, DataType::Float32);
1537 TensorInfo weightInfo(weightShape, DataType::Float32);
1539 bool sampleConvolution2dSupported =
1540 sampleLayerSupport->IsConvolution2dSupported(inputInfo,
1542 convolution2dDescriptor,
1545 BOOST_TEST(!sampleConvolution2dSupported);
1549 BOOST_TEST((sampleWorkloadFactory !=
nullptr));
1555 { inputInfo, inputInfo },
1560 auto workload = sampleWorkloadFactory->CreateAddition(additionQueueDescriptor, workloadInfo);
1561 BOOST_TEST((workload !=
nullptr));
1564 void SampleDynamicBackendEndToEndTestImpl()
1566 using namespace armnn;
1570 CheckSampleDynamicBackendLoaded();
1593 runtime->LoadNetwork(netId, std::move(optNet));
1595 std::vector<float> input0Data{ 5.0f, 3.0f };
1596 std::vector<float> input1Data{ 10.0f, 8.0f };
1597 std::vector<float> expectedOutputData{ 15.0f, 11.0f };
1598 std::vector<float> outputData(2);
1607 {0,
armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
1611 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
1614 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
const ConstTensorHandle * m_Weight
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) 2021 ARM Limited and Contributors.
std::unique_ptr< DynamicBackend > DynamicBackendPtr
void CreateDynamicBackendObjectInvalidInterface6TestImpl()
static std::vector< std::string > GetBackendPathsImplTest(const std::string &path)
virtual void SetTensorInfo(const TensorInfo &tensorInfo)=0
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()
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
#define DYNAMIC_BACKEND_BUILD_DIR
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 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 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
void RuntimeInvalidDynamicBackendsTestImpl()
void OpenNotExistingFileTestImpl()
void CreateDynamicBackendObjectInvalidInterface7TestImpl()
void GetBackendPathsTestImpl()