10 #include <boost/filesystem.hpp> 20 if (sharedObjectPath.empty())
22 throw RuntimeException(
"OpenHandle error: shared object path must not be empty");
25 void* sharedObjectHandle = dlopen(sharedObjectPath.c_str(), RTLD_LAZY);
26 if (!sharedObjectHandle)
28 throw RuntimeException(boost::str(boost::format(
"OpenHandle error: %1%") % GetDlError()));
31 return sharedObjectHandle;
40 if (!sharedObjectHandle)
45 dlclose(const_cast<void*>(sharedObjectHandle));
65 std::string DynamicBackendUtils::GetDlError()
68 const char* errorMessage = dlerror();
74 return std::string(errorMessage);
83 if (!overrideBackendPath.empty())
87 ARMNN_LOG(
warning) <<
"WARNING: The given override path for dynamic backends \"" 88 << overrideBackendPath <<
"\" is not valid";
93 return std::vector<std::string>{ overrideBackendPath };
105 if (backendPaths.empty())
112 std::unordered_set<std::string> uniqueBackendPaths;
113 std::vector<std::string> validBackendPaths;
118 for (
const std::string& path : tempBackendPaths)
127 auto it = uniqueBackendPaths.find(path);
128 if (it != uniqueBackendPaths.end())
135 uniqueBackendPaths.insert(path);
138 validBackendPaths.push_back(path);
141 return validBackendPaths;
152 boost::filesystem::path boostPath(path);
154 if (!boost::filesystem::exists(boostPath))
156 ARMNN_LOG(
warning) <<
"WARNING: The given backend path \"" << path <<
"\" does not exist";
160 if (!boost::filesystem::is_directory(boostPath))
162 ARMNN_LOG(
warning) <<
"WARNING: The given backend path \"" << path <<
"\" is not a directory";
166 if (!boostPath.is_absolute())
168 ARMNN_LOG(
warning) <<
"WARNING: The given backend path \"" << path <<
"\" is not absolute";
177 std::unordered_set<std::string> uniqueSharedObjects;
178 std::vector<std::string> sharedObjects;
180 for (
const std::string& backendPath : backendPaths)
182 using namespace boost::filesystem;
191 std::vector<path> backendPathFiles;
192 std::copy(directory_iterator(backendPath), directory_iterator(), std::back_inserter(backendPathFiles));
193 std::sort(backendPathFiles.begin(), backendPathFiles.end());
196 for (
const path& backendPathFile : backendPathFiles)
199 std::string filename = backendPathFile.filename().string();
201 if (filename.empty())
212 canonicalPath = canonical(backendPathFile);
214 catch (
const filesystem_error& e)
218 if (canonicalPath.empty())
227 const std::regex dynamicBackendRegex(
"^[a-zA-Z0-9]+_[a-zA-Z0-9]+_backend.so(\\.[0-9]+)*$");
229 bool filenameMatch =
false;
233 filenameMatch = std::regex_match(filename, dynamicBackendRegex);
235 catch (
const std::exception& e)
246 std::string validCanonicalPath = canonicalPath.string();
247 auto it = uniqueSharedObjects.find(validCanonicalPath);
248 if (it == uniqueSharedObjects.end())
251 sharedObjects.push_back(validCanonicalPath);
254 uniqueSharedObjects.insert(validCanonicalPath);
259 return sharedObjects;
265 std::vector<DynamicBackendPtr> dynamicBackends;
266 for (
const std::string& sharedObject : sharedObjects)
269 void* sharedObjectHandle =
nullptr;
277 << sharedObject <<
"\": " << e.
what();
280 if (!sharedObjectHandle)
282 ARMNN_LOG(
warning) <<
"Invalid handle to the shared object file \"" << sharedObject <<
"\"";
295 ARMNN_LOG(
warning) <<
"Cannot create a valid dynamic backend from the shared object file \"" 296 << sharedObject <<
"\": " << e.
what();
301 ARMNN_LOG(
warning) <<
"Invalid dynamic backend object for the shared object file \"" 302 << sharedObject <<
"\"";
307 dynamicBackends.push_back(std::move(dynamicBackend));
310 return dynamicBackends;
318 for (
const auto&
id : dynamicBackends)
335 const std::vector<DynamicBackendPtr>& dynamicBackends)
347 dynamicBackendId = dynamicBackend->GetBackendId();
352 <<
"an error has occurred when getting the backend id: " << e.
what();
355 if (dynamicBackendId.
IsEmpty() ||
358 ARMNN_LOG(
warning) <<
"Cannot register dynamic backend, invalid backend id: " << dynamicBackendId;
364 if (backendAlreadyRegistered)
366 ARMNN_LOG(
warning) <<
"Cannot register dynamic backend \"" << dynamicBackendId
367 <<
"\": backend already registered";
375 dynamicBackendFactoryFunction = dynamicBackend->GetFactoryFunction();
379 ARMNN_LOG(
warning) <<
"Cannot register dynamic backend \"" << dynamicBackendId
380 <<
"\": an error has occurred when getting the backend factory function: " 384 if (dynamicBackendFactoryFunction ==
nullptr)
386 ARMNN_LOG(
warning) <<
"Cannot register dynamic backend \"" << dynamicBackendId
387 <<
"\": invalid backend factory function";
394 backendRegistry.
Register(dynamicBackendId, dynamicBackendFactoryFunction);
398 ARMNN_LOG(
warning) <<
"An error has occurred when registering the dynamic backend \"" 399 << dynamicBackendId <<
"\": " << e.
what();
404 registeredBackendIds.insert(dynamicBackendId);
407 return registeredBackendIds;
std::vector< std::string > StringTokenizer(const std::string &str, const char *delimiters, bool tokenCompression=true)
Function to take a string and a list of delimiters and split the string into tokens based on those de...
static void DeregisterDynamicBackends(const BackendIdSet &dynamicBackends)
bool IsBackendRegistered(const BackendId &id) const
std::function< PointerType()> FactoryFunction
void Register(const BackendId &id, FactoryFunction factory)
std::unordered_set< BackendId > BackendIdSet
static bool IsBackendCompatible(const BackendVersion &backendVersion)
virtual const char * what() const noexcept override
#define ARMNN_LOG(severity)
BackendRegistry & BackendRegistryInstance()
static void * OpenHandle(const std::string &sharedObjectPath)
static std::vector< DynamicBackendPtr > CreateDynamicBackends(const std::vector< std::string > &sharedObjects)
Copyright (c) 2020 ARM Limited.
static std::vector< std::string > GetBackendPaths(const std::string &overrideBackendPath="")
std::unique_ptr< DynamicBackend > DynamicBackendPtr
static constexpr BackendVersion GetApiVersion()
Returns the version of the Backend API.
static std::vector< std::string > GetSharedObjects(const std::vector< std::string > &backendPaths)
static bool IsPathValid(const std::string &path)
static BackendIdSet RegisterDynamicBackendsImpl(BackendRegistry &backendRegistry, const std::vector< DynamicBackendPtr > &dynamicBackends)
#define DYNAMIC_BACKEND_PATHS
Base class for all ArmNN exceptions so that users can filter to just those.
void Deregister(const BackendId &id)
static bool IsBackendCompatibleImpl(const BackendVersion &backendApiVersion, const BackendVersion &backendVersion)
Protected methods for testing purposes.
static std::vector< std::string > GetBackendPathsImpl(const std::string &backendPaths)
static BackendIdSet RegisterDynamicBackends(const std::vector< DynamicBackendPtr > &dynamicBackends)
static void CloseHandle(const void *sharedObjectHandle)