1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "plugin_manager/include/plugin_manager.h"
17
18 #include "plugin_manager/include/plugin.h"
19 #include "protocol/retcode_inner/aie_retcode_inner.h"
20 #include "utils/aie_macros.h"
21 #include "utils/log/aie_log.h"
22
23 namespace OHOS {
24 namespace AI {
GetPlugin(const std::string & aid,long long version,std::shared_ptr<Plugin> & plugin)25 int PluginManager::GetPlugin(const std::string &aid, long long version, std::shared_ptr<Plugin> &plugin)
26 {
27 HILOGI("[PluginManager]Get plugin for server, aid=%s, version=%lld.", aid.c_str(), version);
28 PluginKey pluginKey(aid, version);
29 plugin = FindPlugin(pluginKey);
30 if (plugin) {
31 return RETCODE_SUCCESS;
32 }
33
34 std::lock_guard<std::mutex> lock(mutex4Interface_);
35 plugin = FindPlugin(pluginKey);
36 if (plugin) {
37 return RETCODE_SUCCESS;
38 }
39
40 return LoadPlugin(aid, version, plugin);
41 }
42
FindPlugin(const PluginKey & pluginKey)43 std::shared_ptr<Plugin> PluginManager::FindPlugin(const PluginKey &pluginKey)
44 {
45 std::lock_guard<std::mutex> lock(mutex_);
46
47 auto iter = pluginMap_.find(pluginKey);
48 CHK_RET(pluginMap_.end() == iter, nullptr);
49
50 return iter->second;
51 }
52
AddPlugin(const PluginKey & pluginKey,const std::shared_ptr<Plugin> & pluginValue)53 void PluginManager::AddPlugin(const PluginKey &pluginKey, const std::shared_ptr<Plugin> &pluginValue)
54 {
55 std::lock_guard<std::mutex> lock(mutex_);
56 pluginMap_[pluginKey] = pluginValue;
57 }
58
DelPlugin(const PluginKey & pluginKey)59 void PluginManager::DelPlugin(const PluginKey &pluginKey)
60 {
61 std::lock_guard<std::mutex> lock(mutex_);
62 pluginMap_.erase(pluginKey);
63 }
64
DelPluginByAID(const std::string & aid)65 void PluginManager::DelPluginByAID(const std::string &aid)
66 {
67 std::lock_guard<std::mutex> lock(mutex_);
68 PluginMap::iterator iter = pluginMap_.begin();
69 while (iter != pluginMap_.end()) {
70 if (aid == iter->first.aid) {
71 HILOGI("[PluginManager]Try to delete plugin. aid=%s, version=%lld.", iter->first.aid.c_str(),
72 iter->first.version);
73 iter = pluginMap_.erase(iter);
74 continue;
75 }
76 ++iter;
77 }
78 }
79
LoadPlugin(const std::string & aid,long long version,std::shared_ptr<Plugin> & plugin)80 int PluginManager::LoadPlugin(const std::string &aid, long long version, std::shared_ptr<Plugin> &plugin)
81 {
82 auto pluginPtr = std::make_shared<Plugin>(Plugin(aid, version));
83 if (pluginPtr == nullptr) {
84 HILOGE("[PluginManager]The plugin is null.");
85 return RETCODE_OUT_OF_MEMORY;
86 }
87 int ret = pluginPtr->LoadPluginAlgorithm();
88 if (ret != RETCODE_SUCCESS) {
89 HILOGE("[PluginManager]Failed to load plugin(aid=%s, version=%lld): ret=%d.", aid.c_str(), version, ret);
90 return ret;
91 }
92 PluginKey pluginKey(aid, version);
93 AddPlugin(pluginKey, pluginPtr);
94 plugin = pluginPtr;
95 HILOGI("[PluginManager]End to load plugin: aid=%s, version=%lld.", aid.c_str(), version);
96 return RETCODE_SUCCESS;
97 }
98
UnloadPlugin(const std::string & aid,long long version)99 void PluginManager::UnloadPlugin(const std::string &aid, long long version)
100 {
101 PluginKey pluginKey(aid, version);
102 std::shared_ptr<Plugin> plugin = FindPlugin(pluginKey);
103 if (plugin) {
104 DelPlugin(pluginKey);
105 HILOGI("[PluginManager]End to unload plugin, aid=%s, version=%lld, successfully.", pluginKey.aid.c_str(),
106 pluginKey.version);
107 return;
108 }
109 HILOGI("[PluginManager]End to unload plugin, aid=%s, version=%lld, plugin is not exists, no need to unload.",
110 pluginKey.aid.c_str(), pluginKey.version);
111 }
112
113 std::mutex PluginManager::instanceLock_;
114 PluginManager *PluginManager::instance_ = nullptr;
115
GetInstance()116 PluginManager *PluginManager::GetInstance()
117 {
118 CHK_RET(instance_ != nullptr, instance_);
119
120 std::lock_guard<std::mutex> lock(instanceLock_);
121 CHK_RET(instance_ != nullptr, instance_);
122
123 AIE_NEW(instance_, PluginManager);
124 return instance_;
125 }
126
Destroy()127 void PluginManager::Destroy()
128 {
129 HILOGI("[PluginManager]Begin to Destroy plugin");
130 pluginMap_.clear();
131 AIE_DELETE(instance_);
132 }
133
134 PluginManager::PluginManager() = default;
135
136 PluginManager::~PluginManager() = default;
137
GetPluginManager()138 IPluginManager *IPluginManager::GetPluginManager()
139 {
140 return reinterpret_cast<IPluginManager*>(PluginManager::GetInstance());
141 }
142 } // namespace AI
143 } // namespace OHOS