21 #include <doctest/doctest.h> 27 #if !defined(DYNAMIC_BACKEND_BUILD_DIR) 28 #define DYNAMIC_BACKEND_BUILD_DIR fs::path("./") 31 static std::string g_TestDirCLI =
"--dynamic-backend-build-dir";
32 static std::string g_TestBaseDir =
"src/backends/backendsCommon/test/";
34 static std::string g_TestSharedObjectSubDir =
"testSharedObject/";
35 static std::string g_TestDynamicBackendSubDir =
"testDynamicBackend/";
37 static std::string g_TestSharedObjectFileName =
"libTestSharedObject.so";
38 static std::string g_TestNoSharedObjectFileName =
"libNoSharedObject.txt";
40 static std::string g_TestValidTestDynamicBackendFileName =
"libValidTestDynamicBackend.so";
41 static std::string g_TestInvalidTestDynamicBackend1FileName =
"libInvalidTestDynamicBackend1.so";
42 static std::string g_TestInvalidTestDynamicBackend2FileName =
"libInvalidTestDynamicBackend2.so";
43 static std::string g_TestInvalidTestDynamicBackend3FileName =
"libInvalidTestDynamicBackend3.so";
44 static std::string g_TestInvalidTestDynamicBackend4FileName =
"libInvalidTestDynamicBackend4.so";
45 static std::string g_TestInvalidTestDynamicBackend5FileName =
"libInvalidTestDynamicBackend5.so";
46 static std::string g_TestInvalidTestDynamicBackend6FileName =
"libInvalidTestDynamicBackend6.so";
47 static std::string g_TestInvalidTestDynamicBackend7FileName =
"libInvalidTestDynamicBackend7.so";
49 static std::string g_TestValidBackend2FileName =
"Arm_TestValid2_backend.so";
50 static std::string g_TestValidBackend3FileName =
"Arm_TestValid3_backend.so";
51 static std::string g_TestValidBackend4FileName =
"Arm_TestValid4_backend.so";
52 static std::string g_TestValidBackend5FileName =
"Arm_TestValid5_backend.so";
53 static std::string g_TestInvalidBackend8FileName =
"Arm_TestInvalid8_backend.so";
54 static std::string g_TestInvalidBackend9FileName =
"Arm_TestInvalid9_backend.so";
55 static std::string g_TestInvalidBackend10FileName =
"Arm_TestInvalid10_backend.so";
56 static std::string g_TestInvalidBackend11FileName =
"Arm_TestInvalid11_backend.so";
58 static std::string g_TestDynamicBackendsSubDir1 =
"backendsTestPath1/";
59 static std::string g_TestDynamicBackendsSubDir2 =
"backendsTestPath2/";
60 static std::string g_TestDynamicBackendsSubDir3 =
"backendsTestPath3/";
61 static std::string g_TestDynamicBackendsSubDir4 =
"backendsTestPath4/";
62 static std::string g_TestDynamicBackendsSubDir5 =
"backendsTestPath5/";
63 static std::string g_TestDynamicBackendsSubDir6 =
"backendsTestPath6/";
64 static std::string g_TestDynamicBackendsSubDir7 =
"backendsTestPath7/";
65 static std::string g_TestDynamicBackendsSubDir8 =
"backendsTestPath8/";
66 static std::string g_TestDynamicBackendsSubDir9 =
"backendsTestPath9/";
68 static std::string g_DynamicBackendsBaseDir =
"src/backends/dynamic";
69 static std::string g_ReferenceDynamicBackendSubDir =
"reference/";
70 static std::string g_ReferenceBackendFileName =
"Arm_CpuRef_backend.so";
89 const std::vector<armnn::DynamicBackendPtr>& dynamicBackends)
113 #if defined(_MSC_VER) 116 char buffer[MAX_PATH] =
"";
117 GetModuleFileNameA(NULL, buffer, MAX_PATH);
118 fs::path executablePath(buffer);
119 return executablePath.parent_path();
125 char buffer[PATH_MAX] =
"";
126 if (readlink(
"/proc/self/exe", buffer, PATH_MAX) != -1)
128 fs::path executablePath(buffer);
129 return executablePath.parent_path();
141 if (!exists(programLocation))
147 path sharedObjectPath = programLocation.append(basePath);
148 REQUIRE_MESSAGE(exists(sharedObjectPath),
149 (
"Base path for shared objects does not exist: " + sharedObjectPath.string()));
150 return sharedObjectPath.string();
168 path testDynamicBackendsBasePath(testDynamicBackendsBaseDir);
169 path testDynamicBackendsSubDir = testDynamicBackendsBasePath.append(subdir);
172 return testDynamicBackendsSubDir.string();
179 path testDynamicBackendsBasePath(basePath);
180 path testDynamicBackendsSubDir = testDynamicBackendsBasePath.append(subdir);
183 return testDynamicBackendsSubDir.string();
186 std::string
GetTestFilePath(
const std::string& directory,
const std::string& fileName)
190 path directoryPath(directory);
191 path fileNamePath = directoryPath.append(fileName);
192 CHECK(exists(fileNamePath));
194 return fileNamePath.string();
199 using namespace armnn;
202 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
204 void* sharedObjectHandle =
nullptr;
205 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
206 CHECK((sharedObjectHandle !=
nullptr));
208 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
213 using namespace armnn;
216 DynamicBackendUtils::CloseHandle(
nullptr);
221 using namespace armnn;
223 void* sharedObjectHandle =
nullptr;
224 CHECK_THROWS_AS(sharedObjectHandle = DynamicBackendUtils::OpenHandle(
""),
RuntimeException);
225 CHECK((sharedObjectHandle ==
nullptr));
230 using namespace armnn;
232 void* sharedObjectHandle =
nullptr;
233 CHECK_THROWS_AS(sharedObjectHandle = DynamicBackendUtils::OpenHandle(
"NotExistingFileName"),
RuntimeException);
234 CHECK((sharedObjectHandle ==
nullptr));
239 using namespace armnn;
242 std::string notSharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestNoSharedObjectFileName);
244 void* sharedObjectHandle =
nullptr;
245 CHECK_THROWS_AS(sharedObjectHandle = DynamicBackendUtils::OpenHandle(notSharedObjectFilePath),
RuntimeException);
246 CHECK((sharedObjectHandle ==
nullptr));
251 using namespace armnn;
254 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
256 void* sharedObjectHandle =
nullptr;
257 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
258 CHECK((sharedObjectHandle !=
nullptr));
260 using TestFunctionType = int(*)(int);
261 TestFunctionType testFunctionPointer =
nullptr;
262 CHECK_NOTHROW(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
264 CHECK((testFunctionPointer !=
nullptr));
265 CHECK(testFunctionPointer(7) == 7);
267 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
272 using namespace armnn;
275 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
277 void* sharedObjectHandle =
nullptr;
278 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
279 CHECK((sharedObjectHandle !=
nullptr));
281 using TestFunctionType = int(*)(int);
282 TestFunctionType testFunctionPointer =
nullptr;
283 CHECK_THROWS_AS(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
286 CHECK((testFunctionPointer ==
nullptr));
288 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
293 using namespace armnn;
296 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
298 void* sharedObjectHandle =
nullptr;
299 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
300 CHECK((sharedObjectHandle !=
nullptr));
302 using TestFunctionType = int(*)(int);
303 TestFunctionType testFunctionPointer =
nullptr;
304 CHECK_THROWS_AS(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
307 CHECK((testFunctionPointer ==
nullptr));
309 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
314 using namespace armnn;
317 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestSharedObjectFileName);
319 void* sharedObjectHandle =
nullptr;
320 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
321 CHECK((sharedObjectHandle !=
nullptr));
323 using TestFunctionType = int(*)(int);
324 TestFunctionType testFunctionPointer =
nullptr;
325 CHECK_THROWS_AS(testFunctionPointer = DynamicBackendUtils::GetEntryPoint<TestFunctionType>(sharedObjectHandle,
328 CHECK((testFunctionPointer ==
nullptr));
330 DynamicBackendUtils::CloseHandle(sharedObjectHandle);
335 using namespace armnn;
342 CHECK(sameBackendVersion == backendApiVersion);
343 CHECK(sameBackendVersion <= backendApiVersion);
349 CHECK(!(laterMajorBackendVersion == backendApiVersion));
350 CHECK(!(laterMajorBackendVersion <= backendApiVersion));
354 CHECK(!(earlierMajorBackendVersion == backendApiVersion));
355 CHECK(earlierMajorBackendVersion <= backendApiVersion);
357 earlierMajorBackendVersion) ==
false);
362 CHECK(!(laterMinorBackendVersion == backendApiVersion));
363 CHECK(!(laterMinorBackendVersion <= backendApiVersion));
369 CHECK(!(earlierMinorBackendVersion == backendApiVersion));
370 CHECK(earlierMinorBackendVersion <= backendApiVersion);
374 #if defined(ARMNNREF_ENABLED) 375 void CreateValidDynamicBackendObjectTestImpl()
382 using namespace armnn;
387 CHECK_MESSAGE(fs::exists(testSubDirectory),
388 (
"Base path for shared objects does not exist: " + testSubDirectory));
390 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestValidTestDynamicBackendFileName);
392 void* sharedObjectHandle =
nullptr;
393 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
394 CHECK((sharedObjectHandle !=
nullptr));
397 CHECK_NOTHROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
398 CHECK((dynamicBackend !=
nullptr));
401 CHECK_NOTHROW(dynamicBackendId = dynamicBackend->GetBackendId());
402 CHECK((dynamicBackendId ==
"ValidTestDynamicBackend"));
405 CHECK_NOTHROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
406 CHECK((dynamicBackendVersion == IBackendInternal::GetApiVersion()));
409 CHECK_NOTHROW(dynamicBackendInstance1 = dynamicBackend->GetBackend());
410 CHECK((dynamicBackendInstance1 !=
nullptr));
413 CHECK_NOTHROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
414 CHECK((dynamicBackendFactoryFunction !=
nullptr));
417 CHECK_NOTHROW(dynamicBackendInstance2 = dynamicBackendFactoryFunction());
418 CHECK((dynamicBackendInstance2 !=
nullptr));
420 CHECK((dynamicBackendInstance1->GetId() ==
"ValidTestDynamicBackend"));
421 CHECK((dynamicBackendInstance2->GetId() ==
"ValidTestDynamicBackend"));
429 using namespace armnn;
431 void* sharedObjectHandle =
nullptr;
434 CHECK((dynamicBackend ==
nullptr));
442 using namespace armnn;
445 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend1FileName);
447 void* sharedObjectHandle =
nullptr;
448 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
449 CHECK((sharedObjectHandle !=
nullptr));
453 CHECK((dynamicBackend ==
nullptr));
462 using namespace armnn;
465 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend2FileName);
467 void* sharedObjectHandle =
nullptr;
468 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
469 CHECK((sharedObjectHandle !=
nullptr));
473 CHECK((dynamicBackend ==
nullptr));
482 using namespace armnn;
485 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend3FileName);
487 void* sharedObjectHandle =
nullptr;
488 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
489 CHECK((sharedObjectHandle !=
nullptr));
493 CHECK((dynamicBackend ==
nullptr));
502 using namespace armnn;
505 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend4FileName);
507 void* sharedObjectHandle =
nullptr;
508 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
509 CHECK((sharedObjectHandle !=
nullptr));
513 CHECK((dynamicBackend ==
nullptr));
523 using namespace armnn;
526 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend5FileName);
528 void* sharedObjectHandle =
nullptr;
529 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
530 CHECK((sharedObjectHandle !=
nullptr));
534 CHECK((dynamicBackend ==
nullptr));
544 using namespace armnn;
547 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend6FileName);
549 void* sharedObjectHandle =
nullptr;
550 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
551 CHECK((sharedObjectHandle !=
nullptr));
554 CHECK_NOTHROW(dynamicBackend.reset(
new DynamicBackend(sharedObjectHandle)));
555 CHECK((dynamicBackend !=
nullptr));
558 CHECK_NOTHROW(dynamicBackendId = dynamicBackend->GetBackendId());
559 CHECK((dynamicBackendId ==
"InvalidTestDynamicBackend"));
562 CHECK_NOTHROW(dynamicBackendVersion = dynamicBackend->GetBackendVersion());
566 CHECK_THROWS_AS(dynamicBackendInstance1 = dynamicBackend->GetBackend(),
RuntimeException);
567 CHECK((dynamicBackendInstance1 ==
nullptr));
570 CHECK_NOTHROW(dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction());
571 CHECK((dynamicBackendFactoryFunction !=
nullptr));
574 CHECK_THROWS_AS(dynamicBackendInstance2 = dynamicBackendFactoryFunction(),
RuntimeException);
575 CHECK((dynamicBackendInstance2 ==
nullptr));
585 using namespace armnn;
588 std::string sharedObjectFilePath =
GetTestFilePath(testSubDirectory, g_TestInvalidTestDynamicBackend7FileName);
590 void* sharedObjectHandle =
nullptr;
591 CHECK_NOTHROW(sharedObjectHandle = DynamicBackendUtils::OpenHandle(sharedObjectFilePath));
592 CHECK((sharedObjectHandle !=
nullptr));
596 CHECK((dynamicBackend ==
nullptr));
601 using namespace armnn;
616 CHECK(exists(subDir1));
617 CHECK(exists(subDir2));
618 CHECK(exists(subDir3));
619 CHECK(!exists(subDir4));
625 std::string malformedDir(subDir1 +
"/" + subDir1);
630 CHECK(DynamicBackendPaths2.size() == 1);
631 CHECK(DynamicBackendPaths2[0] == subDir1);
634 std::string multipleEqualDirs(subDir1 +
":" + subDir1);
636 CHECK(DynamicBackendPaths3.size() == 1);
637 CHECK(DynamicBackendPaths3[0] == subDir1);
643 std::string multipleValidPaths(subDir1 +
":" + subDir2 +
":" + subDir3);
644 std::vector<std::string> DynamicBackendPaths5 =
646 CHECK(DynamicBackendPaths5.size() == 3);
647 CHECK(DynamicBackendPaths5[0] == subDir1);
648 CHECK(DynamicBackendPaths5[1] == subDir2);
649 CHECK(DynamicBackendPaths5[2] == subDir3);
652 std::string validAmongEmptyDirs(
"::" + subDir1 +
":");
653 std::vector<std::string> DynamicBackendPaths6 =
655 CHECK(DynamicBackendPaths6.size() == 1);
656 CHECK(DynamicBackendPaths6[0] == subDir1);
659 std::string invalidAmongEmptyDirs(
":" + subDir4 +
"::");
663 std::string validInvalidEmptyDirs(subDir1 +
":" + subDir4 +
":");
664 std::vector<std::string> DynamicBackendPaths8 =
666 CHECK(DynamicBackendPaths8.size() == 1);
667 CHECK(DynamicBackendPaths8[0] == subDir1);
670 std::string duplicateValidInvalidEmptyDirs(validInvalidEmptyDirs +
":" + validInvalidEmptyDirs +
":" +
671 subDir2 +
":" + subDir2);
672 std::vector<std::string> DynamicBackendPaths9 =
674 CHECK(DynamicBackendPaths9.size() == 2);
675 CHECK(DynamicBackendPaths9[0] == subDir1);
676 CHECK(DynamicBackendPaths9[1] == subDir2);
681 using namespace armnn;
687 CHECK(exists(subDir1));
688 CHECK(!exists(subDir4));
691 std::vector<std::string> validResult = DynamicBackendUtils::GetBackendPaths(subDir1);
692 CHECK(validResult.size() == 1);
693 CHECK(validResult[0] == subDir1);
696 std::vector<std::string> invalidResult = DynamicBackendUtils::GetBackendPaths(subDir4);
697 CHECK(invalidResult.empty());
702 using namespace armnn;
749 std::string testDynamicBackendsSubDir1 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir1);
750 std::string testDynamicBackendsSubDir2 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir2);
751 std::string testDynamicBackendsSubDir3 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir3);
752 std::string testDynamicBackendsSubDir4 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir4);
753 CHECK(exists(testDynamicBackendsSubDir1));
754 CHECK(exists(testDynamicBackendsSubDir2));
755 CHECK(exists(testDynamicBackendsSubDir3));
756 CHECK(!exists(testDynamicBackendsSubDir4));
758 std::vector<std::string> backendPaths
760 testDynamicBackendsSubDir1,
761 testDynamicBackendsSubDir2,
762 testDynamicBackendsSubDir3,
763 testDynamicBackendsSubDir4
765 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
766 std::vector<fs::path> expectedSharedObjects
768 path(testDynamicBackendsSubDir1 +
"Arm123_GpuAcc_backend.so"),
769 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc456_backend.so"),
770 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so"),
771 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1"),
772 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2"),
773 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.1.2.3"),
774 path(testDynamicBackendsSubDir1 +
"Arm_GpuAcc_backend.so.10.1.27"),
775 path(testDynamicBackendsSubDir2 +
"Arm_CpuAcc_backend.so"),
776 path(testDynamicBackendsSubDir2 +
"Arm_GpuAcc_backend.so")
779 CHECK(sharedObjects.size() == expectedSharedObjects.size());
780 CHECK(fs::equivalent(path(sharedObjects[0]), expectedSharedObjects[0]));
781 CHECK(fs::equivalent(path(sharedObjects[1]), expectedSharedObjects[1]));
782 CHECK(fs::equivalent(path(sharedObjects[2]), expectedSharedObjects[2]));
783 CHECK(fs::equivalent(path(sharedObjects[3]), expectedSharedObjects[3]));
784 CHECK(fs::equivalent(path(sharedObjects[4]), expectedSharedObjects[4]));
785 CHECK(fs::equivalent(path(sharedObjects[5]), expectedSharedObjects[5]));
786 CHECK(fs::equivalent(path(sharedObjects[6]), expectedSharedObjects[6]));
787 CHECK(fs::equivalent(path(sharedObjects[7]), expectedSharedObjects[7]));
788 CHECK(fs::equivalent(path(sharedObjects[8]), expectedSharedObjects[8]));
793 using namespace armnn;
820 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
821 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
822 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
823 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
824 CHECK(exists(testDynamicBackendsSubDir5));
825 CHECK(exists(testDynamicBackendsSubDir6));
826 CHECK(exists(testDynamicBackendsSubDir7));
827 CHECK(!exists(testDynamicBackendsSubDir8));
829 std::vector<std::string> backendPaths
831 testDynamicBackendsSubDir5,
832 testDynamicBackendsSubDir6,
833 testDynamicBackendsSubDir7,
834 testDynamicBackendsSubDir8
836 std::vector<std::string> sharedObjects = DynamicBackendUtils::GetSharedObjects(backendPaths);
837 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
839 CHECK(dynamicBackends.size() == 5);
840 CHECK((dynamicBackends[0] !=
nullptr));
841 CHECK((dynamicBackends[1] !=
nullptr));
842 CHECK((dynamicBackends[2] !=
nullptr));
843 CHECK((dynamicBackends[3] !=
nullptr));
844 CHECK((dynamicBackends[4] !=
nullptr));
847 CHECK((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
848 CHECK((dynamicBackends[1]->
GetBackendId() ==
"TestValid3"));
849 CHECK((dynamicBackends[2]->
GetBackendId() ==
"TestValid2"));
850 CHECK((dynamicBackends[3]->
GetBackendId() ==
"TestValid2"));
851 CHECK((dynamicBackends[4]->
GetBackendId() ==
"TestValid5"));
856 using namespace armnn;
858 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends({});
860 CHECK(dynamicBackends.empty());
865 using namespace armnn;
867 std::vector<std::string> sharedObjects
869 "InvalidSharedObject1",
870 "InvalidSharedObject2",
871 "InvalidSharedObject3",
873 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
875 CHECK(dynamicBackends.empty());
880 using namespace armnn;
883 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
884 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
885 CHECK(exists(testDynamicBackendsSubDir5));
886 CHECK(exists(testDynamicBackendsSubDir6));
888 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
889 g_TestValidBackend2FileName);
890 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
891 g_TestInvalidBackend8FileName);
892 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
893 g_TestInvalidBackend9FileName);
894 CHECK(exists(testValidBackend2FilePath));
895 CHECK(exists(testInvalidBackend8FilePath));
896 CHECK(exists(testInvalidBackend9FilePath));
898 std::vector<std::string> sharedObjects
900 testValidBackend2FilePath,
901 testInvalidBackend8FilePath,
902 testInvalidBackend9FilePath,
903 "InvalidSharedObject",
905 std::vector<DynamicBackendPtr> dynamicBackends = DynamicBackendUtils::CreateDynamicBackends(sharedObjects);
907 CHECK(dynamicBackends.size() == 1);
908 CHECK((dynamicBackends[0] !=
nullptr));
909 CHECK((dynamicBackends[0]->
GetBackendId() ==
"TestValid2"));
912 #if defined(ARMNNREF_ENABLED) 913 void RegisterSingleDynamicBackendTestImpl()
915 using namespace armnn;
922 CHECK(backendRegistry.
Size() == 0);
924 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
925 CHECK(exists(testDynamicBackendsSubDir5));
927 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
928 CHECK(exists(testValidBackend2FilePath));
930 std::vector<std::string> sharedObjects{ testValidBackend2FilePath };
933 CHECK(dynamicBackends.size() == 1);
934 CHECK((dynamicBackends[0] !=
nullptr));
936 BackendId dynamicBackendId = dynamicBackends[0]->GetBackendId();
937 CHECK((dynamicBackendId ==
"TestValid2"));
939 BackendVersion dynamicBackendVersion = dynamicBackends[0]->GetBackendVersion();
944 CHECK(backendRegistry.
Size() == 1);
945 CHECK(registeredBackendIds.size() == 1);
948 CHECK(backendIds.size() == 1);
949 CHECK((backendIds.find(dynamicBackendId) != backendIds.end()));
950 CHECK((registeredBackendIds.find(dynamicBackendId) != registeredBackendIds.end()));
952 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(dynamicBackendId);
953 CHECK((dynamicBackendFactoryFunction !=
nullptr));
956 CHECK((dynamicBackend !=
nullptr));
957 CHECK((dynamicBackend->GetId() == dynamicBackendId));
960 void RegisterMultipleDynamicBackendsTestImpl()
962 using namespace armnn;
967 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
968 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
969 CHECK(exists(testDynamicBackendsSubDir5));
970 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 CHECK(exists(testValidBackend2FilePath));
976 CHECK(exists(testValidBackend3FilePath));
977 CHECK(exists(testValidBackend5FilePath));
979 std::vector<std::string> sharedObjects
981 testValidBackend2FilePath,
982 testValidBackend3FilePath,
983 testValidBackend5FilePath
987 CHECK(dynamicBackends.size() == 3);
988 CHECK((dynamicBackends[0] !=
nullptr));
989 CHECK((dynamicBackends[1] !=
nullptr));
990 CHECK((dynamicBackends[2] !=
nullptr));
992 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
993 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
994 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
995 CHECK((dynamicBackendId1 ==
"TestValid2"));
996 CHECK((dynamicBackendId2 ==
"TestValid3"));
997 CHECK((dynamicBackendId3 ==
"TestValid5"));
999 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1001 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1007 CHECK(backendRegistry.
Size() == 0);
1011 CHECK(backendRegistry.
Size() == 3);
1012 CHECK(registeredBackendIds.size() == 3);
1015 CHECK(backendIds.size() == 3);
1016 CHECK((backendIds.find(dynamicBackendId1) != backendIds.end()));
1017 CHECK((backendIds.find(dynamicBackendId2) != backendIds.end()));
1018 CHECK((backendIds.find(dynamicBackendId3) != backendIds.end()));
1019 CHECK((registeredBackendIds.find(dynamicBackendId1) != registeredBackendIds.end()));
1020 CHECK((registeredBackendIds.find(dynamicBackendId2) != registeredBackendIds.end()));
1021 CHECK((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 CHECK((dynamicBackendFactoryFunction !=
nullptr));
1031 CHECK((dynamicBackend !=
nullptr));
1032 CHECK((dynamicBackend->GetId() == dynamicBackendId));
1036 void RegisterMixedDynamicBackendsTestImpl()
1038 using namespace armnn;
1071 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1072 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1073 std::string testDynamicBackendsSubDir7 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir7);
1074 std::string testDynamicBackendsSubDir8 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir8);
1075 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1076 CHECK(exists(testDynamicBackendsSubDir5));
1077 CHECK(exists(testDynamicBackendsSubDir6));
1078 CHECK(exists(testDynamicBackendsSubDir7));
1079 CHECK(!exists(testDynamicBackendsSubDir8));
1080 CHECK(exists(testDynamicBackendsSubDir9));
1082 std::string testValidBackend2FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend2FileName);
1083 std::string testValidBackend3FilePath =
GetTestFilePath(testDynamicBackendsSubDir5, g_TestValidBackend3FileName);
1084 std::string testValidBackend2DupFilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend2FileName);
1085 std::string testValidBackend4FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend4FileName);
1086 std::string testValidBackend5FilePath =
GetTestFilePath(testDynamicBackendsSubDir6, g_TestValidBackend5FileName);
1087 std::string testInvalidBackend8FilePath =
GetTestFilePath(testDynamicBackendsSubDir5,
1088 g_TestInvalidBackend8FileName);
1089 std::string testInvalidBackend9FilePath =
GetTestFilePath(testDynamicBackendsSubDir6,
1090 g_TestInvalidBackend9FileName);
1091 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1092 g_TestInvalidBackend10FileName);
1093 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1094 g_TestInvalidBackend11FileName);
1095 CHECK(exists(testValidBackend2FilePath));
1096 CHECK(exists(testValidBackend3FilePath));
1097 CHECK(exists(testValidBackend2DupFilePath));
1098 CHECK(exists(testValidBackend4FilePath));
1099 CHECK(exists(testValidBackend5FilePath));
1100 CHECK(exists(testInvalidBackend8FilePath));
1101 CHECK(exists(testInvalidBackend9FilePath));
1102 CHECK(exists(testInvalidBackend10FilePath));
1103 CHECK(exists(testInvalidBackend11FilePath));
1105 std::vector<std::string> sharedObjects
1107 testValidBackend2FilePath,
1108 testValidBackend3FilePath,
1109 testValidBackend2DupFilePath,
1110 testValidBackend4FilePath,
1111 testValidBackend5FilePath,
1112 testInvalidBackend8FilePath,
1113 testInvalidBackend9FilePath,
1114 testInvalidBackend10FilePath,
1115 testInvalidBackend11FilePath,
1116 "InvalidSharedObject" 1120 CHECK(dynamicBackends.size() == 7);
1121 CHECK((dynamicBackends[0] !=
nullptr));
1122 CHECK((dynamicBackends[1] !=
nullptr));
1123 CHECK((dynamicBackends[2] !=
nullptr));
1124 CHECK((dynamicBackends[3] !=
nullptr));
1125 CHECK((dynamicBackends[4] !=
nullptr));
1126 CHECK((dynamicBackends[5] !=
nullptr));
1127 CHECK((dynamicBackends[6] !=
nullptr));
1129 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1130 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1131 BackendId dynamicBackendId3 = dynamicBackends[2]->GetBackendId();
1132 BackendId dynamicBackendId4 = dynamicBackends[3]->GetBackendId();
1133 BackendId dynamicBackendId5 = dynamicBackends[4]->GetBackendId();
1134 BackendId dynamicBackendId6 = dynamicBackends[5]->GetBackendId();
1135 BackendId dynamicBackendId7 = dynamicBackends[6]->GetBackendId();
1136 CHECK((dynamicBackendId1 ==
"TestValid2"));
1137 CHECK((dynamicBackendId2 ==
"TestValid3"));
1138 CHECK((dynamicBackendId3 ==
"TestValid2"));
1139 CHECK((dynamicBackendId4 ==
"TestValid2"));
1140 CHECK((dynamicBackendId5 ==
"TestValid5"));
1141 CHECK((dynamicBackendId6 ==
""));
1142 CHECK((dynamicBackendId7 ==
"Unknown"));
1144 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1146 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1152 CHECK(backendRegistry.
Size() == 0);
1154 std::vector<BackendId> expectedRegisteredbackendIds
1163 CHECK(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1164 CHECK(registeredBackendIds.size() == expectedRegisteredbackendIds.size());
1167 CHECK(backendIds.size() == expectedRegisteredbackendIds.size());
1168 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1170 CHECK((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1171 CHECK((registeredBackendIds.find(expectedRegisteredbackendId) != registeredBackendIds.end()));
1173 auto dynamicBackendFactoryFunction = backendRegistry.
GetFactory(expectedRegisteredbackendId);
1174 CHECK((dynamicBackendFactoryFunction !=
nullptr));
1177 CHECK((dynamicBackend !=
nullptr));
1178 CHECK((dynamicBackend->GetId() == expectedRegisteredbackendId));
1185 using namespace armnn;
1199 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1200 CHECK(exists(testDynamicBackendsSubDir9));
1202 std::string testInvalidBackend10FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1203 g_TestInvalidBackend10FileName);
1204 std::string testInvalidBackend11FilePath =
GetTestFilePath(testDynamicBackendsSubDir9,
1205 g_TestInvalidBackend11FileName);
1206 CHECK(exists(testInvalidBackend10FilePath));
1207 CHECK(exists(testInvalidBackend11FilePath));
1209 std::vector<std::string> sharedObjects
1211 testInvalidBackend10FilePath,
1212 testInvalidBackend11FilePath,
1213 "InvalidSharedObject" 1217 CHECK(dynamicBackends.size() == 2);
1218 CHECK((dynamicBackends[0] !=
nullptr));
1219 CHECK((dynamicBackends[1] !=
nullptr));
1221 BackendId dynamicBackendId1 = dynamicBackends[0]->GetBackendId();
1222 BackendId dynamicBackendId2 = dynamicBackends[1]->GetBackendId();
1223 CHECK((dynamicBackendId1 ==
""));
1224 CHECK((dynamicBackendId2 ==
"Unknown"));
1226 for (
size_t i = 0; i < dynamicBackends.size(); i++)
1228 BackendVersion dynamicBackendVersion = dynamicBackends[i]->GetBackendVersion();
1234 CHECK(backendRegistry.
Size() == 0);
1239 CHECK(backendRegistry.
Size() == 0);
1240 CHECK(registeredBackendIds.empty());
1243 #if !defined(ARMNN_DYNAMIC_BACKEND_ENABLED) 1247 using namespace armnn;
1253 CHECK(backendRegistry.
Size() == 0);
1256 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1258 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1260 CHECK(supportedBackendIds.empty());
1262 CHECK(backendRegistry.
Size() == 0);
1269 using namespace armnn;
1276 std::string testDynamicBackendsSubDir5 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir5);
1277 CHECK(exists(testDynamicBackendsSubDir5));
1282 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1284 std::vector<BackendId> expectedRegisteredbackendIds
1291 CHECK(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1294 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1296 CHECK((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1299 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1301 CHECK(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1302 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1304 CHECK((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1310 using namespace armnn;
1317 std::string testDynamicBackendsSubDir6 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir6);
1318 CHECK(exists(testDynamicBackendsSubDir6));
1323 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1325 std::vector<BackendId> expectedRegisteredbackendIds
1332 CHECK(backendRegistry.
Size() == expectedRegisteredbackendIds.size());
1335 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1337 CHECK((backendIds.find(expectedRegisteredbackendId) != backendIds.end()));
1340 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1342 CHECK(supportedBackendIds.size() == expectedRegisteredbackendIds.size());
1343 for (
const BackendId& expectedRegisteredbackendId : expectedRegisteredbackendIds)
1345 CHECK((supportedBackendIds.find(expectedRegisteredbackendId) != supportedBackendIds.end()));
1351 using namespace armnn;
1358 std::string testDynamicBackendsSubDir9 =
GetTestSubDirectory(g_TestDynamicBackendsSubDir9);
1359 CHECK(exists(testDynamicBackendsSubDir9));
1364 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1367 CHECK(backendRegistry.
Size() == 0);
1369 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1371 CHECK(supportedBackendIds.empty());
1376 using namespace armnn;
1384 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1387 CHECK(backendRegistry.
Size() == 0);
1389 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1391 CHECK(supportedBackendIds.empty());
1394 #if defined(ARMNNREF_ENABLED) 1398 void CreateReferenceDynamicBackendTestImpl()
1400 using namespace armnn;
1409 g_ReferenceDynamicBackendSubDir);
1410 CHECK(exists(referenceDynamicBackendSubDir));
1413 std::string referenceBackendFilePath =
GetTestFilePath(referenceDynamicBackendSubDir,
1414 g_ReferenceBackendFileName);
1415 CHECK(exists(referenceBackendFilePath));
1420 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1423 CHECK(backendRegistry.
Size() == 1);
1426 CHECK((backendIds.find(
"CpuRef") != backendIds.end()));
1428 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1430 CHECK(supportedBackendIds.size() == 1);
1431 CHECK((supportedBackendIds.find(
"CpuRef") != supportedBackendIds.end()));
1434 auto referenceDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"CpuRef");
1435 CHECK((referenceDynamicBackendFactoryFunction !=
nullptr));
1439 CHECK((referenceDynamicBackend !=
nullptr));
1440 CHECK((referenceDynamicBackend->GetId() ==
"CpuRef"));
1444 CHECK((referenceLayerSupport !=
nullptr));
1449 TensorInfo inputInfo (inputShape, DataType::Float32);
1450 TensorInfo outputInfo(outputShape, DataType::Float32);
1451 TensorInfo weightInfo(weightShape, DataType::Float32);
1453 std::vector<TensorInfo> infos = {inputInfo, outputInfo, weightInfo,
TensorInfo()};
1454 bool referenceConvolution2dSupported =
1455 referenceLayerSupport->IsLayerSupported(LayerType::Convolution2d,
1457 convolution2dDescriptor);
1458 CHECK(referenceConvolution2dSupported);
1462 CHECK((referenceWorkloadFactory !=
nullptr));
1471 convolution2dQueueDescriptor.
m_Inputs.push_back(
nullptr);
1472 auto weights = std::make_unique<ScopedTensorHandle>(weightInfo);
1473 convolution2dQueueDescriptor.
m_Weight = weights.get();
1476 auto workload = referenceWorkloadFactory->CreateWorkload(LayerType::Convolution2d,
1477 convolution2dQueueDescriptor,
1479 CHECK((workload !=
nullptr));
1480 CHECK(workload.get() == PolymorphicDowncast<RefConvolution2dWorkload*>(workload.get()));
1485 #if defined(SAMPLE_DYNAMIC_BACKEND_ENABLED) 1487 void CheckSampleDynamicBackendLoaded()
1489 using namespace armnn;
1493 if (backendIds.find(
"SampleDynamic") == backendIds.end())
1495 std::string message =
"The SampleDynamic backend has not been loaded. This may be a build configuration error. " 1496 "Ensure a DYNAMIC_BACKEND_PATHS was set at compile time to the location of " 1497 "libArm_SampleDynamic_backend.so. " 1498 "To disable this test recompile with: -DSAMPLE_DYNAMIC_BACKEND_ENABLED=0";
1503 void CreateSampleDynamicBackendTestImpl()
1505 using namespace armnn;
1508 IRuntimePtr runtime = IRuntime::Create(creationOptions);
1510 CHECK(backendRegistry.
Size() >= 1);
1511 CheckSampleDynamicBackendLoaded();
1512 const DeviceSpec& deviceSpec = *PolymorphicDowncast<const DeviceSpec*>(&runtime->GetDeviceSpec());
1514 CHECK(supportedBackendIds.size()>= 1);
1515 CHECK((supportedBackendIds.find(
"SampleDynamic") != supportedBackendIds.end()));
1518 auto sampleDynamicBackendFactoryFunction = backendRegistry.
GetFactory(
"SampleDynamic");
1519 CHECK((sampleDynamicBackendFactoryFunction !=
nullptr));
1523 CHECK((sampleDynamicBackend !=
nullptr));
1524 CHECK((sampleDynamicBackend->GetId() ==
"SampleDynamic"));
1528 CHECK((sampleLayerSupport !=
nullptr));
1533 TensorInfo inputInfo (inputShape, DataType::Float32);
1534 TensorInfo outputInfo(outputShape, DataType::Float32);
1535 TensorInfo weightInfo(weightShape, DataType::Float32);
1537 std::vector<TensorInfo> infos = {inputInfo, outputInfo, weightInfo,
TensorInfo()};
1538 bool sampleConvolution2dSupported =
1539 sampleLayerSupport->IsLayerSupported(LayerType::Convolution2d,
1541 convolution2dDescriptor);
1542 CHECK(!sampleConvolution2dSupported);
1546 CHECK((sampleWorkloadFactory !=
nullptr));
1552 { inputInfo, inputInfo },
1557 auto workload = sampleWorkloadFactory->CreateWorkload(LayerType::Addition, additionQueueDescriptor, workloadInfo);
1558 CHECK((workload !=
nullptr));
1561 void SampleDynamicBackendEndToEndTestImpl()
1563 using namespace armnn;
1567 CheckSampleDynamicBackendLoaded();
1590 runtime->LoadNetwork(netId, std::move(optNet));
1592 std::vector<float> input0Data{ 5.0f, 3.0f };
1593 std::vector<float> input1Data{ 10.0f, 8.0f };
1594 std::vector<float> expectedOutputData{ 15.0f, 11.0f };
1595 std::vector<float> outputData(2);
1597 TensorInfo inputTensorInfo = runtime->GetInputTensorInfo(netId, 0);
1606 {0,
armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
1610 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
1613 CHECK(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 GetUnitTestExecutablePath()
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)
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.
void SetConstant(const bool IsConstant=true)
Marks the data corresponding to this tensor info as constant.
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 TensorInfos of 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()