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);
384 using namespace armnn;
389 BOOST_CHECK_MESSAGE(fs::exists(testSubDirectory),
390 "Base path for shared objects does not exist: " + testSubDirectory);
392 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestValidTestDynamicBackendFileName);
394 void* sharedObjectHandle =
nullptr;
395 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
396 BOOST_TEST((sharedObjectHandle !=
nullptr));
399 BOOST_CHECK_NO_THROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
400 BOOST_TEST((dynamicBackend !=
nullptr));
403 BOOST_CHECK_NO_THROW(dynamicBackendId = dynamicBackend->GetBackendId());
404 BOOST_TEST((dynamicBackendId ==
"ValidTestDynamicBackend"));
407 BOOST_CHECK_NO_THROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
408 BOOST_TEST((dynamicBackendVersion == IBackendInternal::GetApiVersion()));
411 BOOST_CHECK_NO_THROW(dynamicBackendInstance1 = dynamicBackend->GetBackend());
412 BOOST_TEST((dynamicBackendInstance1 !=
nullptr));
415 BOOST_CHECK_NO_THROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
416 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
419 BOOST_CHECK_NO_THROW(dynamicBackendInstance2 = dynamicBackendFactoryFunction());
420 BOOST_TEST((dynamicBackendInstance2 !=
nullptr));
422 BOOST_TEST((dynamicBackendInstance1->GetId() ==
"ValidTestDynamicBackend"));
423 BOOST_TEST((dynamicBackendInstance2->GetId() ==
"ValidTestDynamicBackend"));
430 using namespace armnn;
432 void* sharedObjectHandle =
nullptr;
435 BOOST_TEST((dynamicBackend ==
nullptr));
443 using namespace armnn;
446 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend1FileName);
448 void* sharedObjectHandle =
nullptr;
449 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
450 BOOST_TEST((sharedObjectHandle !=
nullptr));
454 BOOST_TEST((dynamicBackend ==
nullptr));
463 using namespace armnn;
466 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend2FileName);
468 void* sharedObjectHandle =
nullptr;
469 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
470 BOOST_TEST((sharedObjectHandle !=
nullptr));
474 BOOST_TEST((dynamicBackend ==
nullptr));
483 using namespace armnn;
486 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend3FileName);
488 void* sharedObjectHandle =
nullptr;
489 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
490 BOOST_TEST((sharedObjectHandle !=
nullptr));
494 BOOST_TEST((dynamicBackend ==
nullptr));
503 using namespace armnn;
506 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend4FileName);
508 void* sharedObjectHandle =
nullptr;
509 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
510 BOOST_TEST((sharedObjectHandle !=
nullptr));
514 BOOST_TEST((dynamicBackend ==
nullptr));
524 using namespace armnn;
527 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend5FileName);
529 void* sharedObjectHandle =
nullptr;
530 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
531 BOOST_TEST((sharedObjectHandle !=
nullptr));
535 BOOST_TEST((dynamicBackend ==
nullptr));
545 using namespace armnn;
548 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend6FileName);
550 void* sharedObjectHandle =
nullptr;
551 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
552 BOOST_TEST((sharedObjectHandle !=
nullptr));
555 BOOST_CHECK_NO_THROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
556 BOOST_TEST((dynamicBackend !=
nullptr));
559 BOOST_CHECK_NO_THROW(dynamicBackendId = dynamicBackend->GetBackendId());
560 BOOST_TEST((dynamicBackendId ==
"InvalidTestDynamicBackend"));
563 BOOST_CHECK_NO_THROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
567 BOOST_CHECK_THROW(dynamicBackendInstance1 = dynamicBackend->GetBackend(),
RuntimeException);
568 BOOST_TEST((dynamicBackendInstance1 ==
nullptr));
571 BOOST_CHECK_NO_THROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
572 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
575 BOOST_CHECK_THROW(dynamicBackendInstance2 = dynamicBackendFactoryFunction(),
RuntimeException);
576 BOOST_TEST((dynamicBackendInstance2 ==
nullptr));
586 using namespace armnn;
589 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend7FileName);
591 void* sharedObjectHandle =
nullptr;
592 BOOST_CHECK_NO_THROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
593 BOOST_TEST((sharedObjectHandle !=
nullptr));
597 BOOST_TEST((dynamicBackend ==
nullptr));
602 using namespace armnn;
617 BOOST_CHECK(exists(subDir1));
618 BOOST_CHECK(exists(subDir2));
619 BOOST_CHECK(exists(subDir3));
620 BOOST_CHECK(!exists(subDir4));
626 std::string malformedDir(subDir1 +
"/" + subDir1);
631 BOOST_TEST(DynamicBackendPaths2.size() == 1);
632 BOOST_TEST(DynamicBackendPaths2[0] == subDir1);
635 std::string multipleEqualDirs(subDir1 +
":" + subDir1);
637 BOOST_TEST(DynamicBackendPaths3.size() == 1);
638 BOOST_TEST(DynamicBackendPaths3[0] == subDir1);
644 std::string multipleValidPaths(subDir1 +
":" + subDir2 +
":" + subDir3);
645 std::vector<std::string> DynamicBackendPaths5 =
647 BOOST_TEST(DynamicBackendPaths5.size() == 3);
648 BOOST_TEST(DynamicBackendPaths5[0] == subDir1);
649 BOOST_TEST(DynamicBackendPaths5[1] == subDir2);
650 BOOST_TEST(DynamicBackendPaths5[2] == subDir3);
653 std::string validAmongEmptyDirs(
"::" + subDir1 +
":");
654 std::vector<std::string> DynamicBackendPaths6 =
656 BOOST_TEST(DynamicBackendPaths6.size() == 1);
657 BOOST_TEST(DynamicBackendPaths6[0] == subDir1);
660 std::string invalidAmongEmptyDirs(
":" + subDir4 +
"::");
664 std::string validInvalidEmptyDirs(subDir1 +
":" + subDir4 +
":");
665 std::vector<std::string> DynamicBackendPaths8 =
667 BOOST_TEST(DynamicBackendPaths8.size() == 1);
668 BOOST_TEST(DynamicBackendPaths8[0] == subDir1);
671 std::string duplicateValidInvalidEmptyDirs(validInvalidEmptyDirs +
":" + validInvalidEmptyDirs +
":" +
672 subDir2 +
":" + subDir2);
673 std::vector<std::string> DynamicBackendPaths9 =
675 BOOST_TEST(DynamicBackendPaths9.size() == 2);
676 BOOST_TEST(DynamicBackendPaths9[0] == subDir1);
677 BOOST_TEST(DynamicBackendPaths9[1] == subDir2);
682 using namespace armnn;
688 BOOST_CHECK(exists(subDir1));
689 BOOST_CHECK(!exists(subDir4));
692 std::vector<std::string> validResult = DynamicBackendUtils::GetBackendPaths(subDir1);
693 BOOST_TEST(validResult.size() == 1);
694 BOOST_TEST(validResult[0] == subDir1);
697 std::vector<std::string> invalidResult = DynamicBackendUtils::GetBackendPaths(subDir4);
698 BOOST_TEST(invalidResult.empty());
703 using namespace armnn;
750 std::string testDynamicBackendsSubDir1 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir1);
751 std::string testDynamicBackendsSubDir2 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir2);
752 std::string testDynamicBackendsSubDir3 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir3);
753 std::string testDynamicBackendsSubDir4 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir4);
754 BOOST_CHECK(exists(testDynamicBackendsSubDir1));
755 BOOST_CHECK(exists(testDynamicBackendsSubDir2));
756 BOOST_CHECK(exists(testDynamicBackendsSubDir3));
757 BOOST_CHECK(!exists(testDynamicBackendsSubDir4));
759 std::vector<std::string> backendPaths
761 testDynamicBackendsSubDir1,
762 testDynamicBackendsSubDir2,
763 testDynamicBackendsSubDir3,
764 testDynamicBackendsSubDir4
766 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
767 std::vector<fs::path> expectedSharedObjects
769 path(testDynamicBackendsSubDir1 +
"Arm123_GpuAcc_backend.so"),
770 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc456_backend.so"),
771 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so"),
772 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1"),
773 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2"),
774 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2.3"),
775 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.10.1.27"),
776 path(testDynamicBackendsSubDir2 +
"Arm_CpuAcc_backend.so"),
777 path(testDynamicBackendsSubDir2 +
"Arm_GpuAcc_backend.so")
780 BOOST_TEST(sharedObjects.size() == expectedSharedObjects.size());
781 BOOST_TEST(fs::equivalent(path(sharedObjects[0]), expectedSharedObjects[0]));
782 BOOST_TEST(fs::equivalent(path(sharedObjects[1]), expectedSharedObjects[1]));
783 BOOST_TEST(fs::equivalent(path(sharedObjects[2]), expectedSharedObjects[2]));
784 BOOST_TEST(fs::equivalent(path(sharedObjects[3]), expectedSharedObjects[3]));
785 BOOST_TEST(fs::equivalent(path(sharedObjects[4]), expectedSharedObjects[4]));
786 BOOST_TEST(fs::equivalent(path(sharedObjects[5]), expectedSharedObjects[5]));
787 BOOST_TEST(fs::equivalent(path(sharedObjects[6]), expectedSharedObjects[6]));
788 BOOST_TEST(fs::equivalent(path(sharedObjects[7]), expectedSharedObjects[7]));
789 BOOST_TEST(fs::equivalent(path(sharedObjects[8]), expectedSharedObjects[8]));
794 using namespace armnn;
821 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
822 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
823 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
824 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
825 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
826 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
827 BOOST_CHECK(exists(testDynamicBackendsSubDir7));
828 BOOST_CHECK(!exists(testDynamicBackendsSubDir8));
830 std::vector<std::string> backendPaths
832 testDynamicBackendsSubDir5,
833 testDynamicBackendsSubDir6,
834 testDynamicBackendsSubDir7,
835 testDynamicBackendsSubDir8
837 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
838 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
840 BOOST_TEST(dynamicBackends.size() == 5);
841 BOOST_TEST((dynamicBackends[0] !=
nullptr));
842 BOOST_TEST((dynamicBackends[1] !=
nullptr));
843 BOOST_TEST((dynamicBackends[2] !=
nullptr));
844 BOOST_TEST((dynamicBackends[3] !=
nullptr));
845 BOOST_TEST((dynamicBackends[4] !=
nullptr));
848 BOOST_TEST((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
849 BOOST_TEST((dynamicBackends[1]->
GetBackendId() ==
"TestValid3"));
850 BOOST_TEST((dynamicBackends[2]->
GetBackendId() ==
"TestValid2"));
851 BOOST_TEST((dynamicBackends[3]->
GetBackendId() ==
"TestValid2"));
852 BOOST_TEST((dynamicBackends[4]->
GetBackendId() ==
"TestValid5"));
857 using namespace armnn;
859 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends({});
861 BOOST_TEST(dynamicBackends.empty());
866 using namespace armnn;
868 std::vector<std::string> sharedObjects
870 "InvalidSharedObject1",
871 "InvalidSharedObject2",
872 "InvalidSharedObject3",
874 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
876 BOOST_TEST(dynamicBackends.empty());
881 using namespace armnn;
884 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
885 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
886 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
887 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
889 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
890 g_TestValidBackend2FileName);
891 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
892 g_TestInvalidBackend8FileName);
893 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
894 g_TestInvalidBackend9FileName);
895 BOOST_CHECK(exists(testValidBackend2FilePath));
896 BOOST_CHECK(exists(testInvalidBackend8FilePath));
897 BOOST_CHECK(exists(testInvalidBackend9FilePath));
899 std::vector<std::string> sharedObjects
901 testValidBackend2FilePath,
902 testInvalidBackend8FilePath,
903 testInvalidBackend9FilePath,
904 "InvalidSharedObject",
906 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
908 BOOST_TEST(dynamicBackends.size() == 1);
909 BOOST_TEST((dynamicBackends[0] !=
nullptr));
910 BOOST_TEST((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
915 using namespace armnn;
922 BOOST_TEST(backendRegistry.
Size() == 0);
924 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
925 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
927 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
928 BOOST_CHECK(exists(testValidBackend2FilePath));
930 std::vector<std::string> sharedObjects{ testValidBackend2FilePath };
933 BOOST_TEST(dynamicBackends.size() == 1);
934 BOOST_TEST((dynamicBackends[0] !=
nullptr));
936 BackendId dynamicBackendId = dynamicBackends[0]->GetBackendId();
937 BOOST_TEST((dynamicBackendId ==
"TestValid2"));
939 BackendVersion dynamicBackendVersion = dynamicBackends[0]->GetBackendVersion();
944 BOOST_TEST(backendRegistry.
Size() == 1);
945 BOOST_TEST(registeredBackendIds.size() == 1);
948 BOOST_TEST(backendIds.size() == 1);
949 BOOST_TEST((backendIds.find(dynamicBackendId) != backendIds.end()));
950 BOOST_TEST((registeredBackendIds.find(dynamicBackendId) != registeredBackendIds.end()));
952 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(dynamicBackendId);
953 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
956 BOOST_TEST((dynamicBackend !=
nullptr));
957 BOOST_TEST((dynamicBackend->GetId() == dynamicBackendId));
962 using namespace armnn;
967 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
968 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
969 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
970 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
972 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
973 std::string testValidBackend3FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend3FileName);
974 std::string testValidBackend5FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend5FileName);
975 BOOST_CHECK(exists(testValidBackend2FilePath));
976 BOOST_CHECK(exists(testValidBackend3FilePath));
977 BOOST_CHECK(exists(testValidBackend5FilePath));
979 std::vector<std::string> sharedObjects
981 testValidBackend2FilePath,
982 testValidBackend3FilePath,
983 testValidBackend5FilePath
987 BOOST_TEST(dynamicBackends.size() == 3);
988 BOOST_TEST((dynamicBackends[0] !=
nullptr));
989 BOOST_TEST((dynamicBackends[1] !=
nullptr));
990 BOOST_TEST((dynamicBackends[2] !=
nullptr));
992 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
993 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
994 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
995 BOOST_TEST((dynamicBackendId1 ==
"TestValid2"));
996 BOOST_TEST((dynamicBackendId2 ==
"TestValid3"));
997 BOOST_TEST((dynamicBackendId3 ==
"TestValid5"));
999 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1001 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1007 BOOST_TEST(backendRegistry.
Size() == 0);
1011 BOOST_TEST(backendRegistry.
Size() == 3);
1012 BOOST_TEST(registeredBackendIds.size() == 3);
1015 BOOST_TEST(backendIds.size() == 3);
1016 BOOST_TEST((backendIds.find(dynamicBackendId1) != backendIds.end()));
1017 BOOST_TEST((backendIds.find(dynamicBackendId2) != backendIds.end()));
1018 BOOST_TEST((backendIds.find(dynamicBackendId3) != backendIds.end()));
1019 BOOST_TEST((registeredBackendIds.find(dynamicBackendId1) != registeredBackendIds.end()));
1020 BOOST_TEST((registeredBackendIds.find(dynamicBackendId2) != registeredBackendIds.end()));
1021 BOOST_TEST((registeredBackendIds.find(dynamicBackendId3) != registeredBackendIds.end()));
1023 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1025 BackendId dynamicBackendId = dynamicBackends[i]->GetBackendId();
1027 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(dynamicBackendId);
1028 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
1031 BOOST_TEST((dynamicBackend !=
nullptr));
1032 BOOST_TEST((dynamicBackend->GetId() == dynamicBackendId));
1038 using namespace armnn;
1052 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1053 BOOST_CHECK(exists(testDynamicBackendsSubDir9));
1055 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1056 g_TestInvalidBackend10FileName);
1057 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1058 g_TestInvalidBackend11FileName);
1059 BOOST_CHECK(exists(testInvalidBackend10FilePath));
1060 BOOST_CHECK(exists(testInvalidBackend11FilePath));
1062 std::vector<std::string> sharedObjects
1064 testInvalidBackend10FilePath,
1065 testInvalidBackend11FilePath,
1066 "InvalidSharedObject" 1070 BOOST_TEST(dynamicBackends.size() == 2);
1071 BOOST_TEST((dynamicBackends[0] !=
nullptr));
1072 BOOST_TEST((dynamicBackends[1] !=
nullptr));
1074 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1075 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1076 BOOST_TEST((dynamicBackendId1 ==
""));
1077 BOOST_TEST((dynamicBackendId2 ==
"Unknown"));
1079 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1081 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1087 BOOST_TEST(backendRegistry.
Size() == 0);
1092 BOOST_TEST(backendRegistry.
Size() == 0);
1093 BOOST_TEST(registeredBackendIds.empty());
1098 using namespace armnn;
1131 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1132 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1133 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
1134 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
1135 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1136 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
1137 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
1138 BOOST_CHECK(exists(testDynamicBackendsSubDir7));
1139 BOOST_CHECK(!exists(testDynamicBackendsSubDir8));
1140 BOOST_CHECK(exists(testDynamicBackendsSubDir9));
1142 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
1143 std::string testValidBackend3FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend3FileName);
1144 std::string testValidBackend2DupFilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend2FileName);
1145 std::string testValidBackend4FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend4FileName);
1146 std::string testValidBackend5FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend5FileName);
1147 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
1148 g_TestInvalidBackend8FileName);
1149 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
1150 g_TestInvalidBackend9FileName);
1151 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1152 g_TestInvalidBackend10FileName);
1153 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1154 g_TestInvalidBackend11FileName);
1155 BOOST_CHECK(exists(testValidBackend2FilePath));
1156 BOOST_CHECK(exists(testValidBackend3FilePath));
1157 BOOST_CHECK(exists(testValidBackend2DupFilePath));
1158 BOOST_CHECK(exists(testValidBackend4FilePath));
1159 BOOST_CHECK(exists(testValidBackend5FilePath));
1160 BOOST_CHECK(exists(testInvalidBackend8FilePath));
1161 BOOST_CHECK(exists(testInvalidBackend9FilePath));
1162 BOOST_CHECK(exists(testInvalidBackend10FilePath));
1163 BOOST_CHECK(exists(testInvalidBackend11FilePath));
1165 std::vector<std::string> sharedObjects
1167 testValidBackend2FilePath,
1168 testValidBackend3FilePath,
1169 testValidBackend2DupFilePath,
1170 testValidBackend4FilePath,
1171 testValidBackend5FilePath,
1172 testInvalidBackend8FilePath,
1173 testInvalidBackend9FilePath,
1174 testInvalidBackend10FilePath,
1175 testInvalidBackend11FilePath,
1176 "InvalidSharedObject" 1180 BOOST_TEST(dynamicBackends.size() == 7);
1181 BOOST_TEST((dynamicBackends[0] !=
nullptr));
1182 BOOST_TEST((dynamicBackends[1] !=
nullptr));
1183 BOOST_TEST((dynamicBackends[2] !=
nullptr));
1184 BOOST_TEST((dynamicBackends[3] !=
nullptr));
1185 BOOST_TEST((dynamicBackends[4] !=
nullptr));
1186 BOOST_TEST((dynamicBackends[5] !=
nullptr));
1187 BOOST_TEST((dynamicBackends[6] !=
nullptr));
1189 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1190 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1191 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
1192 BackendId dynamicBackendId4 = dynamicBackends[3]->GetBackendId();
1193 BackendId dynamicBackendId5 = dynamicBackends[4]->GetBackendId();
1194 BackendId dynamicBackendId6 = dynamicBackends[5]->GetBackendId();
1195 BackendId dynamicBackendId7 = dynamicBackends[6]->GetBackendId();
1196 BOOST_TEST((dynamicBackendId1 ==
"TestValid2"));
1197 BOOST_TEST((dynamicBackendId2 ==
"TestValid3"));
1198 BOOST_TEST((dynamicBackendId3 ==
"TestValid2"));
1199 BOOST_TEST((dynamicBackendId4 ==
"TestValid2"));
1200 BOOST_TEST((dynamicBackendId5 ==
"TestValid5"));
1201 BOOST_TEST((dynamicBackendId6 ==
""));
1202 BOOST_TEST((dynamicBackendId7 ==
"Unknown"));
1204 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1206 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1212 BOOST_TEST(backendRegistry.
Size() == 0);
1214 std::vector<BackendId> expectedRegisteredbackendIds
1223 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1224 BOOST_TEST(registeredBackendIds.size() == expectedRegisteredbackendIds.size());
1227 BOOST_TEST(backendIds.size() == expectedRegisteredbackendIds.size());
1228 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1230 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1231 BOOST_TEST((registeredBackendIds.find(expectedRegisteredbackendId) != registeredBackendIds.end()));
1233 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(expectedRegisteredbackendId);
1234 BOOST_TEST((dynamicBackendFactoryFunction !=
nullptr));
1237 BOOST_TEST((dynamicBackend !=
nullptr));
1238 BOOST_TEST((dynamicBackend->GetId() == expectedRegisteredbackendId));
1242 #if !defined(ARMNN_DYNAMIC_BACKEND_ENABLED) 1246 using namespace armnn;
1252 BOOST_TEST(backendRegistry.
Size() == 0);
1255 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1257 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1259 BOOST_TEST(supportedBackendIds.empty());
1261 BOOST_TEST(backendRegistry.
Size() == 0);
1268 using namespace armnn;
1275 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1276 BOOST_CHECK(exists(testDynamicBackendsSubDir5));
1281 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1283 std::vector<BackendId> expectedRegisteredbackendIds
1290 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1293 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1295 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1298 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1300 BOOST_TEST(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1301 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1303 BOOST_TEST((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1309 using namespace armnn;
1316 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1317 BOOST_CHECK(exists(testDynamicBackendsSubDir6));
1322 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1324 std::vector<BackendId> expectedRegisteredbackendIds
1331 BOOST_TEST(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1334 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1336 BOOST_TEST((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1339 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1341 BOOST_TEST(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1342 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1344 BOOST_TEST((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1350 using namespace armnn;
1357 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1358 BOOST_CHECK(exists(testDynamicBackendsSubDir9));
1363 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1366 BOOST_TEST(backendRegistry.
Size() == 0);
1368 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1370 BOOST_TEST(supportedBackendIds.empty());
1375 using namespace armnn;
1383 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1386 BOOST_TEST(backendRegistry.
Size() == 0);
1388 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1390 BOOST_TEST(supportedBackendIds.empty());
1393 #if defined(ARMNNREF_ENABLED) 1397 void CreateReferenceDynamicBackendTestImpl()
1399 using namespace armnn;
1408 g_ReferenceDynamicBackendSubDir);
1409 BOOST_CHECK(exists(referenceDynamicBackendSubDir));
1412 std::string referenceBackendFilePath =
GetTestFilePath(referenceDynamicBackendSubDir,
1413 g_ReferenceBackendFileName);
1414 BOOST_CHECK(exists(referenceBackendFilePath));
1419 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1422 BOOST_TEST(backendRegistry.
Size() == 1);
1425 BOOST_TEST((backendIds.find(
"CpuRef") != backendIds.end()));
1427 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1429 BOOST_TEST(supportedBackendIds.size() == 1);
1430 BOOST_TEST((supportedBackendIds.find(
"CpuRef") != supportedBackendIds.end()));
1433 auto referenceDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"CpuRef");
1434 BOOST_TEST((referenceDynamicBackendFactoryFunction !=
nullptr));
1438 BOOST_TEST((referenceDynamicBackend !=
nullptr));
1439 BOOST_TEST((referenceDynamicBackend->GetId() ==
"CpuRef"));
1443 BOOST_TEST((referenceLayerSupport !=
nullptr));
1448 TensorInfo inputInfo (inputShape, DataType::Float32);
1449 TensorInfo outputInfo(outputShape, DataType::Float32);
1450 TensorInfo weightInfo(weightShape, DataType::Float32);
1452 bool referenceConvolution2dSupported =
1453 referenceLayerSupport->IsConvolution2dSupported(inputInfo,
1455 convolution2dDescriptor,
1458 BOOST_TEST(referenceConvolution2dSupported);
1462 BOOST_TEST((referenceWorkloadFactory !=
nullptr));
1471 convolution2dQueueDescriptor.
m_Inputs.push_back(
nullptr);
1472 auto weights = std::make_unique<ScopedCpuTensorHandle>(weightInfo);
1473 convolution2dQueueDescriptor.
m_Weight = weights.get();
1476 auto workload = referenceWorkloadFactory->CreateConvolution2d(convolution2dQueueDescriptor, workloadInfo);
1477 BOOST_TEST((workload !=
nullptr));
1478 BOOST_TEST(workload.get() == PolymorphicDowncast<RefConvolution2dWorkload*>(workload.get()));
1483 #if defined(SAMPLE_DYNAMIC_BACKEND_ENABLED) 1485 void CheckSampleDynamicBackendLoaded()
1487 using namespace armnn;
1491 if (backendIds.find(
"SampleDynamic") == backendIds.end())
1493 std::string message =
"The SampleDynamic backend has not been loaded. This may be a build configuration error. " 1494 "Ensure a DYNAMIC_BACKEND_PATHS was set at compile time to the location of " 1495 "libArm_SampleDynamic_backend.so. " 1496 "To disable this test recompile with: -DSAMPLE_DYNAMIC_BACKEND_ENABLED=0";
1497 BOOST_FAIL(message);
1501 void CreateSampleDynamicBackendTestImpl()
1503 using namespace armnn;
1506 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1508 BOOST_TEST(backendRegistry.
Size() >= 1);
1509 CheckSampleDynamicBackendLoaded();
1510 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1512 BOOST_TEST(supportedBackendIds.size()>= 1);
1513 BOOST_TEST((supportedBackendIds.find(
"SampleDynamic") != supportedBackendIds.end()));
1516 auto sampleDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"SampleDynamic");
1517 BOOST_TEST((sampleDynamicBackendFactoryFunction !=
nullptr));
1521 BOOST_TEST((sampleDynamicBackend !=
nullptr));
1522 BOOST_TEST((sampleDynamicBackend->GetId() ==
"SampleDynamic"));
1526 BOOST_TEST((sampleLayerSupport !=
nullptr));
1531 TensorInfo inputInfo (inputShape, DataType::Float32);
1532 TensorInfo outputInfo(outputShape, DataType::Float32);
1533 TensorInfo weightInfo(weightShape, DataType::Float32);
1535 bool sampleConvolution2dSupported =
1536 sampleLayerSupport->IsConvolution2dSupported(inputInfo,
1538 convolution2dDescriptor,
1541 BOOST_TEST(!sampleConvolution2dSupported);
1545 BOOST_TEST((sampleWorkloadFactory !=
nullptr));
1551 { inputInfo, inputInfo },
1556 auto workload = sampleWorkloadFactory->CreateAddition(additionQueueDescriptor, workloadInfo);
1557 BOOST_TEST((workload !=
nullptr));
1560 void SampleDynamicBackendEndToEndTestImpl()
1562 using namespace armnn;
1566 CheckSampleDynamicBackendLoaded();
1589 runtime->LoadNetwork(netId, std::move(optNet));
1591 std::vector<float> input0Data{ 5.0f, 3.0f };
1592 std::vector<float> input1Data{ 10.0f, 8.0f };
1593 std::vector<float> expectedOutputData{ 15.0f, 11.0f };
1594 std::vector<float> outputData(2);
1603 {0,
armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
1607 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
1610 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.
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.
#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 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
void RuntimeInvalidDynamicBackendsTestImpl()
void CreateValidDynamicBackendObjectTestImpl()
void OpenNotExistingFileTestImpl()
void CreateDynamicBackendObjectInvalidInterface7TestImpl()
void GetBackendPathsTestImpl()