Line data Source code
1 : /**
2 : * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 : #include "typical_qp_manager.h"
11 : #include <map>
12 : #include <memory>
13 : #include "externalinput.h"
14 : #include "adapter_rts_common.h"
15 : #include "rdma_resource_manager.h"
16 :
17 : namespace hccl {
18 66 : TypicalQpManager::TypicalQpManager()
19 : {
20 66 : }
21 :
22 66 : TypicalQpManager::~TypicalQpManager()
23 : {
24 66 : std::unique_lock<std::mutex> cqLock(cqMutex_);
25 66 : for (auto& item : cqMap_) {
26 0 : if (item.second.second == nullptr) {
27 0 : continue;
28 : }
29 0 : DestroyTypicalCq(rdmaHandle_, item.first, item.second.second);
30 : }
31 66 : cqMap_.clear();
32 66 : cqLock.unlock();
33 :
34 66 : std::unique_lock<std::mutex> lock(qpMutex_);
35 72 : for (auto& item : qpMap_) {
36 6 : if (item.second.second == nullptr) {
37 0 : continue;
38 : }
39 6 : HrtRaQpDestroy(item.second.second);
40 : }
41 66 : qpMap_.clear();
42 66 : for (auto& item : verbsQpMap_) {
43 0 : if (item.second.second == nullptr) {
44 0 : continue;
45 : }
46 0 : HrtRaQpDestroyWithoutCQ(item.second.second);
47 : }
48 66 : verbsQpMap_.clear();
49 66 : lock.unlock();
50 66 : }
51 :
52 209 : TypicalQpManager& TypicalQpManager::GetInstance()
53 : {
54 275 : static TypicalQpManager qpInstance[MAX_MODULE_DEVICE_NUM + 1];
55 209 : s32 deviceLogicId = INVALID_INT;
56 209 : HcclResult ret = hrtGetDevice(&deviceLogicId);
57 209 : if (ret == HCCL_SUCCESS && (static_cast<u32>(deviceLogicId) < MAX_MODULE_DEVICE_NUM)) {
58 209 : HCCL_INFO("[TypicalQpManager::GetInstance]deviceLogicID[%d]", deviceLogicId);
59 209 : return qpInstance[deviceLogicId];
60 : }
61 0 : HCCL_WARNING("[TypicalQpManager::GetInstance]deviceLogicID[%d] is invalid, ret[%d]", deviceLogicId, ret);
62 0 : return qpInstance[MAX_MODULE_DEVICE_NUM];
63 : }
64 :
65 30 : HcclResult TypicalQpManager::CreateQp(struct TypicalQp& qpInfo)
66 : {
67 30 : HcclResult ret = HCCL_SUCCESS;
68 30 : QpHandle qpHandle = nullptr;
69 30 : CHK_RET(RdmaResourceManager::GetInstance().GetRdmaHandle(rdmaHandle_));
70 30 : CHK_PTR_NULL(rdmaHandle_);
71 30 : std::unique_lock<std::mutex> lock(qpMutex_);
72 30 : ret = hrtRaTypicalQpCreate(rdmaHandle_, QP_FLAG_RC, OPBASE_QP_MODE, &qpInfo, qpHandle);
73 30 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[TypicalQpManager][CreateQp] Create qp failed."), HCCL_E_INTERNAL);
74 30 : qpMap_.insert(std::make_pair(qpInfo.qpn, std::make_pair(qpInfo, qpHandle)));
75 30 : return HCCL_SUCCESS;
76 30 : }
77 :
78 10 : HcclResult TypicalQpManager::CreateQp(struct TypicalQp& qpInfo, const QpConfigInfo& qpConfig)
79 : {
80 10 : HcclResult ret = HCCL_SUCCESS;
81 10 : QpHandle qpHandle = nullptr;
82 10 : CHK_RET(RdmaResourceManager::GetInstance().GetRdmaHandle(rdmaHandle_));
83 10 : CHK_PTR_NULL(rdmaHandle_);
84 10 : std::unique_lock<std::mutex> lock(qpMutex_);
85 10 : ret = CreateQpWithDepthConfig(rdmaHandle_, OPBASE_QP_MODE, qpConfig, qpHandle, qpInfo);
86 10 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[TypicalQpManager][CreateQp] Create qp failed."), HCCL_E_INTERNAL);
87 9 : qpMap_.insert(std::make_pair(qpInfo.qpn, std::make_pair(qpInfo, qpHandle)));
88 9 : return HCCL_SUCCESS;
89 10 : }
90 :
91 1 : HcclResult TypicalQpManager::CreateCq(AscendCQInfo& cqInfo)
92 : {
93 1 : HcclResult ret = HCCL_SUCCESS;
94 1 : void *cqHandle = nullptr;
95 1 : CHK_RET(RdmaResourceManager::GetInstance().GetRdmaHandle(rdmaHandle_));
96 1 : CHK_PTR_NULL(rdmaHandle_);
97 1 : std::unique_lock<std::mutex> lock(cqMutex_);
98 1 : ret = CreateTypicalCq(rdmaHandle_, cqInfo.cqDepth, cqInfo.cqn, &cqHandle);
99 1 : CHK_PRT_RET(ret != HCCL_SUCCESS,
100 : HCCL_ERROR("[TypicalQpManager][CreateCq] Create cq failed."), HCCL_E_INTERNAL);
101 1 : cqMap_.insert(std::make_pair(cqInfo.cqn, std::make_pair(cqInfo, cqHandle)));
102 1 : return HCCL_SUCCESS;
103 1 : }
104 :
105 0 : HcclResult TypicalQpManager::DestroyCq(uint32_t cqn)
106 : {
107 0 : HcclResult ret = HCCL_SUCCESS;
108 0 : CHK_RET(RdmaResourceManager::GetInstance().GetRdmaHandle(rdmaHandle_));
109 0 : CHK_PTR_NULL(rdmaHandle_);
110 0 : std::unique_lock<std::mutex> lock(cqMutex_);
111 0 : auto it = cqMap_.find(cqn);
112 0 : CHK_PRT_RET((it == cqMap_.end()),
113 : HCCL_ERROR("[TypicalQpManager][DestroyCq] cqn[%u] not found.", cqn), HCCL_E_PARA);
114 0 : ret = DestroyTypicalCq(rdmaHandle_, cqn, it->second.second);
115 0 : CHK_PRT_RET(ret != HCCL_SUCCESS,
116 : HCCL_ERROR("[TypicalQpManager][DestroyCq] Destroy cq failed."), HCCL_E_INTERNAL);
117 0 : cqMap_.erase(it);
118 0 : return HCCL_SUCCESS;
119 0 : }
120 :
121 0 : HcclResult TypicalQpManager::ValidateCq(uint32_t cqn)
122 : {
123 0 : std::unique_lock<std::mutex> lock(cqMutex_);
124 0 : auto it = cqMap_.find(cqn);
125 0 : CHK_PRT_RET((it == cqMap_.end()),
126 : HCCL_ERROR("[TypicalQpManager][ValidateCq] cqn[%u] not found.", cqn), HCCL_E_PARA);
127 0 : return HCCL_SUCCESS;
128 0 : }
129 :
130 0 : HcclResult TypicalQpManager::GetCqDepth(uint32_t cqn, uint32_t &cqDepth)
131 : {
132 0 : std::unique_lock<std::mutex> lock(cqMutex_);
133 0 : auto it = cqMap_.find(cqn);
134 0 : CHK_PRT_RET((it == cqMap_.end()),
135 : HCCL_ERROR("[TypicalQpManager][GetCqDepth] cqn[%u] not found.", cqn), HCCL_E_PARA);
136 0 : cqDepth = it->second.first.cqDepth;
137 0 : return HCCL_SUCCESS;
138 0 : }
139 :
140 0 : HcclResult TypicalQpManager::GetCqHandle(uint32_t cqn, void*& cqHandle)
141 : {
142 0 : std::unique_lock<std::mutex> lock(cqMutex_);
143 0 : auto it = cqMap_.find(cqn);
144 0 : CHK_PRT_RET((it == cqMap_.end()),
145 : HCCL_ERROR("[TypicalQpManager][GetCqHandle] cqn[%u] not found.", cqn), HCCL_E_PARA);
146 0 : cqHandle = it->second.second;
147 0 : return HCCL_SUCCESS;
148 0 : }
149 :
150 2 : HcclResult TypicalQpManager::CreateQpWithCQ(struct TypicalQp& qpInfo, const QpConfigWithCQInfo& qpConfig)
151 : {
152 2 : HcclResult ret = HCCL_SUCCESS;
153 2 : QpHandle qpHandle = nullptr;
154 2 : CHK_RET(RdmaResourceManager::GetInstance().GetRdmaHandle(rdmaHandle_));
155 2 : CHK_PTR_NULL(rdmaHandle_);
156 2 : std::unique_lock<std::mutex> lock(qpMutex_);
157 2 : ret = CreateQpWithCQConfig(rdmaHandle_, OPBASE_QP_MODE, qpConfig, qpHandle, qpInfo);
158 2 : CHK_PRT_RET(ret != HCCL_SUCCESS,
159 : HCCL_ERROR("[TypicalQpManager][CreateQpWithCQ] Create qp with cq failed."), HCCL_E_INTERNAL);
160 1 : verbsQpMap_.insert(std::make_pair(qpInfo.qpn, std::make_pair(qpInfo, qpHandle)));
161 1 : return HCCL_SUCCESS;
162 2 : }
163 :
164 30 : HcclResult TypicalQpManager::ModifyQp(struct TypicalQp& localQpInfo, struct TypicalQp& remoteQpInfo)
165 : {
166 30 : CHK_PRT_RET((localQpInfo.qpn == 0 || remoteQpInfo.qpn == 0),
167 : HCCL_ERROR("[TypicalQpManager][ModifyQp] the qpinfo is wrong, qpn is 0."), HCCL_E_PARA);
168 30 : QpHandle qpHandle = nullptr;
169 30 : CHK_RET(GetQpHandleByQpn(localQpInfo.qpn, qpHandle));
170 30 : CHK_PTR_NULL(qpHandle);
171 30 : CHK_RET(SetQpRdmaRetryCfg(localQpInfo));
172 30 : std::unique_lock<std::mutex> lock(qpMutex_);
173 30 : HcclResult ret = hrtRaTypicalQpModify(qpHandle, &localQpInfo, &remoteQpInfo);
174 30 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[TypicalQpManager][ModifyQp] Modify qp failed."), HCCL_E_INTERNAL);
175 :
176 30 : return HCCL_SUCCESS;
177 30 : }
178 :
179 5 : HcclResult TypicalQpManager::ModifyVerbsQp(struct TypicalQp& localQpInfo, struct TypicalQp& remoteQpInfo)
180 : {
181 5 : CHK_PRT_RET((localQpInfo.qpn == 0 || remoteQpInfo.qpn == 0),
182 : HCCL_ERROR("[TypicalQpManager][ModifyVerbsQp] the qpinfo is wrong, qpn is 0."), HCCL_E_PARA);
183 3 : QpHandle qpHandle = nullptr;
184 3 : CHK_RET(GetVerbsQpHandleByQpn(localQpInfo.qpn, qpHandle));
185 2 : CHK_PTR_NULL(qpHandle);
186 2 : CHK_RET(SetQpRdmaRetryCfg(localQpInfo));
187 2 : std::unique_lock<std::mutex> lock(qpMutex_);
188 2 : HcclResult ret = hrtRaTypicalQpModify(qpHandle, &localQpInfo, &remoteQpInfo);
189 2 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[TypicalQpManager][ModifyVerbsQp] Modify qp failed."), HCCL_E_INTERNAL);
190 :
191 1 : return HCCL_SUCCESS;
192 2 : }
193 :
194 30 : HcclResult TypicalQpManager::DestroyQp(struct TypicalQp& qpInfo)
195 : {
196 30 : CHK_PRT_RET((qpInfo.qpn == 0), HCCL_ERROR("[TypicalQpManager][DestroyQp] The qpinfo is wrong, qpn is 0."),
197 : HCCL_E_PARA);
198 : QpHandle qpHandle;
199 30 : CHK_RET(GetQpHandleByQpn(qpInfo.qpn, qpHandle));
200 30 : CHK_PTR_NULL(qpHandle);
201 30 : std::unique_lock<std::mutex> lock(qpMutex_);
202 30 : HcclResult ret = HrtRaQpDestroy(qpHandle);
203 30 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[TypicalQpManager][DestroyQp] Destroy qp failed."), HCCL_E_INTERNAL);
204 30 : qpMap_.erase(qpInfo.qpn);
205 30 : return HCCL_SUCCESS;
206 30 : }
207 :
208 4 : HcclResult TypicalQpManager::DestroyQpWithoutCQ(struct TypicalQp& qpInfo)
209 : {
210 4 : CHK_PRT_RET((qpInfo.qpn == 0), HCCL_ERROR("[TypicalQpManager][DestroyQpWithoutCQ] The qpinfo is wrong, qpn is 0."),
211 : HCCL_E_PARA);
212 : QpHandle qpHandle;
213 3 : CHK_RET(GetVerbsQpHandleByQpn(qpInfo.qpn, qpHandle));
214 2 : CHK_PTR_NULL(qpHandle);
215 2 : std::unique_lock<std::mutex> lock(qpMutex_);
216 2 : HcclResult ret = HrtRaQpDestroyWithoutCQ(qpHandle);
217 2 : CHK_PRT_RET(ret != HCCL_SUCCESS,
218 : HCCL_ERROR("[TypicalQpManager][DestroyQpWithoutCQ] Destroy qp without cq failed."), HCCL_E_INTERNAL);
219 1 : verbsQpMap_.erase(qpInfo.qpn);
220 1 : return HCCL_SUCCESS;
221 2 : }
222 :
223 32 : HcclResult TypicalQpManager::SetQpRdmaRetryCfg(struct TypicalQp& qpInfo)
224 : {
225 32 : qpInfo.retryCnt = GetExternalInputRdmaRetryCnt();
226 32 : qpInfo.retryTime = GetExternalInputRdmaTimeOut();
227 32 : HCCL_INFO("[TypicalQpManager][SetQpCreateBaseInfo] Qpinfo is set, tc is %u, sl is %u, retry cnt is %u, "\
228 : "retry time is %u", qpInfo.tc, qpInfo.sl, qpInfo.retryCnt, qpInfo.retryTime);
229 32 : return HCCL_SUCCESS;
230 : }
231 :
232 108 : HcclResult TypicalQpManager::GetQpHandleByQpn(u32 qpn, QpHandle& qpHandle)
233 : {
234 108 : HCCL_DEBUG("[TypicalQpManager][GetQpHandleByQpn] Get qpHandle by qpn[%u]", qpn);
235 108 : CHK_RET(RdmaResourceManager::GetInstance().GetRdmaHandle(rdmaHandle_));
236 108 : CHK_PTR_NULL(rdmaHandle_);
237 108 : std::unique_lock<std::mutex> lock(qpMutex_);
238 108 : auto it = qpMap_.find(qpn);
239 108 : CHK_PRT_RET((it == qpMap_.end()),
240 : HCCL_ERROR("[TypicalQpManager][GetQpHandleByQpn] Qpn is not found"), HCCL_E_NOT_FOUND);
241 108 : qpHandle = it->second.second;
242 108 : CHK_PRT_RET((qpHandle == nullptr),
243 : HCCL_ERROR("[TypicalQpManager][GetQpHandleByQpn] Get Qphandle failed, qphandle is nullptr. qpn is %u", qpn),
244 : HCCL_E_NOT_FOUND);
245 108 : return HCCL_SUCCESS;
246 108 : }
247 :
248 10 : HcclResult TypicalQpManager::GetVerbsQpHandleByQpn(u32 qpn, QpHandle& qpHandle)
249 : {
250 10 : HCCL_DEBUG("[TypicalQpManager][GetVerbsQpHandleByQpn] Get qpHandle by qpn[%u]", qpn);
251 10 : CHK_RET(RdmaResourceManager::GetInstance().GetRdmaHandle(rdmaHandle_));
252 9 : CHK_PTR_NULL(rdmaHandle_);
253 9 : std::unique_lock<std::mutex> lock(qpMutex_);
254 9 : auto it = verbsQpMap_.find(qpn);
255 9 : CHK_PRT_RET((it == verbsQpMap_.end()),
256 : HCCL_ERROR("[TypicalQpManager][GetVerbsQpHandleByQpn] Qpn is not found"), HCCL_E_NOT_FOUND);
257 6 : qpHandle = it->second.second;
258 6 : CHK_PRT_RET((qpHandle == nullptr),
259 : HCCL_ERROR("[TypicalQpManager][GetVerbsQpHandleByQpn] Get Qphandle failed, qphandle is nullptr. qpn is %u", qpn),
260 : HCCL_E_NOT_FOUND);
261 5 : return HCCL_SUCCESS;
262 9 : }
263 : } // namespace hccl
|
