1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/*
* Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <memory>
#include <dlfcn.h>
#include "BackendManager.h"
#include "backend/Backend.h"
#include "backend/IConfig.h"
#include "util/logging.h"
#include "util/ConfigSource.h"
namespace neurun
{
namespace backend
{
BackendManager &BackendManager::instance()
{
static BackendManager object;
return object;
}
template <typename T, class... Types>
void BackendManager::loadObjectFromPlugin(std::shared_ptr<T> &object_of_plugin_class,
const std::string obj_creator_func_name, void *handle,
Types &&... args)
{
T *(*allocate_obj)(Types && ... Args);
// load object creator function
allocate_obj = (T * (*)(Types && ... Args))dlsym(handle, obj_creator_func_name.c_str());
if (allocate_obj == nullptr)
{
fprintf(stderr, "BackendManager: unable to open function %s: %s\n",
obj_creator_func_name.c_str(), dlerror());
abort();
}
object_of_plugin_class.reset(allocate_obj(args...));
}
void BackendManager::loadBackend(const std::string &backend)
{
const std::string backend_plugin = "libbackend_" + backend + ".so";
void *handle = dlopen(backend_plugin.c_str(), RTLD_LAZY | RTLD_LOCAL);
if (handle == nullptr)
{
fprintf(stderr, "BackendManager::loadBackend failed to load plugin of %s backend: %s\n",
backend.c_str(), dlerror());
abort();
}
VERBOSE(BackendManager::loadBackend) << "loaded " << backend_plugin << " as a plugin of "
<< backend << " backend\n";
{
// load object creator function
auto backend_create = (backend_create_t)dlsym(handle, "neurun_backend_create");
if (backend_create == nullptr)
{
fprintf(stderr, "BackendManager: unable to open function neurun_backend_create : %s\n",
dlerror());
abort();
}
// load object creator function
auto backend_destroy = (backend_destroy_t)dlsym(handle, "neurun_backend_destroy");
if (backend_destroy == nullptr)
{
fprintf(stderr, "BackendManager: unable to open function neurun_backend_destroy : %s\n",
dlerror());
abort();
}
auto backend_object =
std::unique_ptr<backend::Backend, backend_destroy_t>(backend_create(), backend_destroy);
auto backend_object_raw = backend_object.get();
backend_object->config()->initialize(); // Call initialize here?
_gen_map.emplace(backend_object->config()->id(), std::move(backend_object));
_available_backends.push_back(backend_object_raw);
}
// Save backend handle (avoid warning by handle lost without dlclose())
_handle_map.emplace(backend, handle);
}
BackendManager::BackendManager()
{
const auto backends = util::getConfigString(util::config::BACKENDS);
size_t prev_pos = 0;
auto pos = backends.find(";");
while (pos != std::string::npos)
{
loadBackend(backends.substr(prev_pos, pos - prev_pos));
prev_pos = pos + 1;
pos = backends.find(";", prev_pos);
}
// if backends doesn't terminate with ";"
if (prev_pos < backends.size())
{
loadBackend(backends.substr(prev_pos));
}
}
Backend *BackendManager::get(const std::string &key) { return _gen_map.at(key).get(); }
const Backend *BackendManager::get(const std::string &key) const { return _gen_map.at(key).get(); }
const Backend *BackendManager::getDefault() const { return get("cpu"); }
} // namespace backend
} // namespace neurun
|
