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 :
11 : #include "hccl_mem.h"
12 : #include "hccl_network.h"
13 : #include "remote_ipc_rma_buffer.h"
14 : #include "remote_rdma_rma_buffer.h"
15 : #include "hccl_mem_v2.h"
16 :
17 : using namespace hccl;
18 :
19 : using LocalIpcRmaBufferMgr = NetDevContext::LocalIpcRmaBufferMgr;
20 : using LocalRdmaRmaBufferMgr = NetDevContext::LocalRdmaRmaBufferMgr;
21 :
22 0 : static HcclResult HcclMemRegIpc(NetDevContext *netDevCtx, const HcclMem *mem, HcclBuf *buf)
23 : {
24 0 : std::shared_ptr<LocalIpcRmaBufferMgr> localRmaBufferMgr = netDevCtx->GetlocalIpcRmaBufferMgr();
25 0 : if (!localRmaBufferMgr) {
26 0 : HCCL_ERROR("[HcclMemRegIpc]Can't get LocalIpcRmaBufferMgr");
27 0 : return HCCL_E_INTERNAL;
28 : }
29 :
30 0 : RmaMemType memType = static_cast<RmaMemType>(mem->type);
31 0 : u64 size = static_cast<u64>(mem->size);
32 0 : BufferKey<uintptr_t, u64> tempKey(reinterpret_cast<uintptr_t>(mem->addr), size);
33 0 : std::shared_ptr<LocalIpcRmaBuffer> localbufferPtr = nullptr;
34 0 : EXCEPTION_CATCH((localbufferPtr = std::make_shared<LocalIpcRmaBuffer>(netDevCtx, mem->addr, size, memType)),
35 : return HCCL_E_PTR);
36 0 : auto resultPair = localRmaBufferMgr->Add(tempKey, localbufferPtr);
37 0 : if (resultPair.first == localRmaBufferMgr->End()) {
38 : // 输入key是表中某一个最相近key的交集、子集。返回空迭代器
39 0 : HCCL_ERROR("[HcclMemRegIpc]The memory that is expected to be"
40 : " registered overlaps with the memory that has been registered, please check params");
41 0 : return HCCL_E_INTERNAL;
42 : }
43 : // 已注册：输入key是表中某一最相近key的全集。 返回添加该key的迭代器，及false
44 : // 未注册：输入key是表中某一最相近key的空集。 返回添加成功的迭代器，及true
45 0 : std::shared_ptr<LocalIpcRmaBuffer> localBuffer = resultPair.first->second.buffer;
46 0 : buf->addr = localBuffer->GetAddr();
47 0 : buf->len = localBuffer->GetSize();
48 0 : auto rmaBufferPtr = dynamic_cast<RmaBuffer *>(localBuffer.get());
49 0 : CHK_PTR_NULL(rmaBufferPtr);
50 0 : buf->handle = static_cast<void *>(rmaBufferPtr);
51 0 : if (resultPair.second) {
52 0 : HcclResult ret = localBuffer->Init();
53 0 : if (ret != HCCL_SUCCESS) {
54 : // 此分支中一定删除成功
55 0 : localRmaBufferMgr->Del(tempKey);
56 0 : HCCL_ERROR("[HcclMemRegRoce]localbuffer init failed %d.", ret);
57 0 : return ret;
58 : }
59 0 : HCCL_INFO("[HcclMemRegIpc]Register memory success! Add key {%p, %llu}", mem->addr, size);
60 0 : return HCCL_SUCCESS;
61 : } else { // 内存再次注册时
62 0 : HCCL_INFO("[HcclMemRegIpc]Memory is already registered, just increase the reference count. Add key "
63 : "{%p, %llu}", mem->addr, size);;
64 0 : return HCCL_E_AGAIN;
65 : }
66 0 : }
67 :
68 0 : static HcclResult HcclMemDeregIpc(NetDevContext *netDevCtx, const HcclBuf *buf)
69 : {
70 0 : std::shared_ptr<LocalIpcRmaBufferMgr> localRmaBufferMgr = netDevCtx->GetlocalIpcRmaBufferMgr();
71 0 : if (!localRmaBufferMgr) {
72 0 : HCCL_ERROR("[HcclMemDeregIpc]Can't get LocalIpcRmaBufferMgr");
73 0 : return HCCL_E_INTERNAL;
74 : }
75 :
76 0 : BufferKey<uintptr_t, u64> tempKey(reinterpret_cast<uintptr_t>(buf->addr), buf->len);
77 0 : if (localRmaBufferMgr->Del(tempKey)) {
78 : // 删除成功：输入key是表中某一最相近key的全集，计数-1后为0，返回true
79 0 : HCCL_INFO("[HcclMemDeregIpc]Memory reference count is 0, deregister memory.");
80 0 : return HCCL_SUCCESS;
81 : } else {
82 : // 删除失败：输入key是表中某一最相近key的全集，计数不为0（存在其他remoteRank使用），返回false
83 0 : HCCL_INFO("[HcclMemDeregIpc]Memory reference count is larger than 0 "
84 : "(used by other RemoteRank), do not deregister memory.");
85 0 : return HCCL_E_AGAIN;
86 : }
87 0 : }
88 :
89 0 : static HcclResult HcclMemRegRoce(NetDevContext *netDevCtx, const HcclMem *mem, HcclBuf *buf)
90 : {
91 0 : std::shared_ptr<LocalRdmaRmaBufferMgr> localRmaBufferMgr = netDevCtx->GetlocalRdmaRmaBufferMgr();
92 0 : if (!localRmaBufferMgr) {
93 0 : HCCL_ERROR("[HcclMemRegRoce] can't get LocalRdmaRmaBufferMgr");
94 0 : return HCCL_E_INTERNAL;
95 : }
96 :
97 0 : RmaMemType memType = static_cast<RmaMemType>(mem->type);
98 0 : u64 size = static_cast<u64>(mem->size);
99 0 : BufferKey<uintptr_t, u64> tempKey(reinterpret_cast<uintptr_t>(mem->addr), size);
100 0 : std::shared_ptr<LocalRdmaRmaBuffer> localbufferPtr = nullptr;
101 0 : EXCEPTION_CATCH((localbufferPtr = std::make_shared<LocalRdmaRmaBuffer>(netDevCtx, mem->addr, size, memType)),
102 : return HCCL_E_PTR);
103 0 : auto resultPair = localRmaBufferMgr->Add(tempKey, localbufferPtr);
104 0 : if (resultPair.first == localRmaBufferMgr->End()) {
105 : // 输入key是表中某一个最相近key的交集、子集。返回空迭代器
106 0 : HCCL_ERROR("[HcclMemRegRoce]The memory that is expected to be"
107 : " registered overlaps with the memory that has been registered, please check params");
108 0 : return HCCL_E_INTERNAL;
109 : }
110 : // 已注册：输入key是表中某一最相近key的全集。 返回添加该key的迭代器，及false
111 : // 未注册：输入key是表中某一最相近key的空集。 返回添加成功的迭代器，及true
112 0 : std::shared_ptr<LocalRdmaRmaBuffer> localBuffer = resultPair.first->second.buffer;
113 0 : buf->addr = localBuffer->GetAddr();
114 0 : buf->len = localBuffer->GetSize();
115 0 : auto rmaBufferPtr = dynamic_cast<RmaBuffer *>(localBuffer.get());
116 0 : CHK_PTR_NULL(rmaBufferPtr);
117 0 : buf->handle = static_cast<void *>(rmaBufferPtr);
118 0 : if (resultPair.second) {
119 0 : HcclResult ret = localBuffer->Init();
120 0 : if (ret != HCCL_SUCCESS) {
121 : // 此分支中一定删除成功
122 0 : localRmaBufferMgr->Del(tempKey);
123 0 : HCCL_ERROR("[HcclMemRegRoce]localbuffer init failed %d.", ret);
124 0 : return ret;
125 : }
126 0 : HCCL_INFO("[HcclMemRegRoce]Register memory success! Add key {%p, %llu}", mem->addr, size);
127 0 : return HCCL_SUCCESS;
128 : } else { // 内存再次注册时
129 0 : HCCL_INFO("[HcclMemRegRoce]Memory is already registered, just increase the reference count. Add key "
130 : "{%p, %llu}", mem->addr, size);;
131 0 : return HCCL_E_AGAIN;
132 : }
133 0 : }
134 :
135 0 : static HcclResult HcclMemDeregRoce(NetDevContext *netDevCtx, const HcclBuf *buf)
136 : {
137 0 : std::shared_ptr<LocalRdmaRmaBufferMgr> localRmaBufferMgr = netDevCtx->GetlocalRdmaRmaBufferMgr();
138 0 : if (!localRmaBufferMgr) {
139 0 : HCCL_ERROR("[HcclMemDeregRoce]Can't get LocalRdmaRmaBufferMgr");
140 0 : return HCCL_E_INTERNAL;
141 : }
142 :
143 0 : BufferKey<uintptr_t, u64> tempKey(reinterpret_cast<uintptr_t>(buf->addr), buf->len);
144 0 : if (localRmaBufferMgr->Del(tempKey)) {
145 : // 删除成功：输入key是表中某一最相近key的全集，计数-1后为0，返回true
146 0 : HCCL_INFO("[HcclMemDeregRoce]Memory reference count is 0, deregister memory.");
147 0 : return HCCL_SUCCESS;
148 : } else {
149 : // 删除失败：输入key是表中某一最相近key的全集，计数不为0（存在其他remoteRank使用），返回false
150 0 : HCCL_INFO("[HcclMemDeregRoce]Memory reference count is larger than 0 "
151 : "(used by other RemoteRank), do not deregister memory.");
152 0 : return HCCL_E_AGAIN;
153 : }
154 0 : }
155 :
156 0 : static HcclResult HcclMemRempRoce(NetDevContext *netDevCtx, const HcclMem *memArray, u64 arraySize)
157 : {
158 0 : std::shared_ptr<LocalRdmaRmaBufferMgr> localRmaBufferMgr = netDevCtx->GetlocalRdmaRmaBufferMgr();
159 0 : if (!localRmaBufferMgr) {
160 0 : HCCL_ERROR("[HcclMemRempRoce]Can't get LocalRdmaRmaBufferMgr");
161 0 : return HCCL_E_INTERNAL;
162 : }
163 0 : HCCL_RUN_INFO("[HcclMemRempRoce] arraySize[%u]", arraySize);
164 0 : std::unordered_map<void*, bool> remapAddr;
165 0 : for (u64 i = 0; i < arraySize; i++) {
166 0 : const HcclMem &memInfo = memArray[i];
167 :
168 : // 检查地址和大小是否有效
169 0 : if (memInfo.addr == nullptr || memInfo.size <= 0 || memInfo.type != HcclMemType::HCCL_MEM_TYPE_DEVICE) {
170 0 : continue;
171 : }
172 :
173 : // 检查地址是否已经处理过
174 0 : if (remapAddr.find(memInfo.addr) != remapAddr.end()) {
175 0 : continue;
176 : }
177 :
178 : // 查找地址是否注册过
179 0 : BufferKey<uintptr_t, u64> searchKey(reinterpret_cast<uintptr_t>(memInfo.addr), 1U);
180 0 : auto bufferIter = localRmaBufferMgr->Find(searchKey);
181 0 : if (!bufferIter.first) {
182 0 : HCCL_ERROR("[HcclMemRempRoce]Memory addr[%p] size[%llu] has not been registered.", memInfo.addr,
183 : memInfo.size);
184 0 : return HCCL_E_PARA;
185 : }
186 :
187 : // 计算需要注册的内存大小
188 0 : u64 size = std::min(static_cast<u64>(memInfo.size), bufferIter.second->GetSize());
189 :
190 : // 注册内存
191 0 : HCCL_RUN_INFO("[HcclMemRempRoce]Re-register memory addr[%p] size[%llu].", memInfo.addr, size);
192 0 : HcclResult ret = bufferIter.second->Remap(memInfo.addr, size);
193 0 : CHK_PRT_RET(ret != HCCL_SUCCESS,
194 : HCCL_ERROR("[HcclMemRempRoce]remap mem failed,addr[%p], size[%llu]", memInfo.addr, size),
195 : ret);
196 :
197 : // 标记地址已处理
198 0 : remapAddr.emplace(memInfo.addr, true);
199 0 : }
200 :
201 0 : return HCCL_SUCCESS;
202 0 : }
203 :
204 :
205 0 : HcclResult HcclMemReg(HcclNetDev netDev, const HcclMem *mem, HcclBuf *buf)
206 : {
207 0 : CHK_PTR_NULL(netDev);
208 0 : CHK_PTR_NULL(mem);
209 0 : CHK_PTR_NULL(buf);
210 0 : CHK_PTR_NULL(mem->addr);
211 0 : CHK_PRT_RET((mem->type != HCCL_MEM_TYPE_DEVICE) && (mem->type != HCCL_MEM_TYPE_HOST),
212 : HCCL_ERROR("[HcclMemReg]memoryType[%d] must be device or host", mem->type), HCCL_E_PARA);
213 0 : CHK_PRT_RET(mem->size == 0, HCCL_ERROR("[HcclMemReg]memory size[%lld] is invalid", mem->size), HCCL_E_PARA);
214 :
215 : DevType devType;
216 0 : CHK_RET(hrtGetDeviceType(devType));
217 0 : if (devType == DevType::DEV_TYPE_950 || devType == DevType::DEV_TYPE_960) {return HcclMemRegV2(netDev, mem, buf);}
218 :
219 0 : NetDevContext *netDevCtx = static_cast<NetDevContext *>(netDev);
220 0 : if (netDevCtx->GetNicType() == NicType::VNIC_TYPE) {
221 0 : return HcclMemRegIpc(netDevCtx, mem, buf);
222 : } else {
223 0 : return HcclMemRegRoce(netDevCtx, mem, buf);
224 : }
225 : }
226 :
227 0 : HcclResult HcclMemDereg(const HcclBuf *buf)
228 : {
229 0 : CHK_PTR_NULL(buf);
230 0 : CHK_PTR_NULL(buf->addr);
231 0 : CHK_PTR_NULL(buf->handle);
232 0 : CHK_PRT_RET(buf->len == 0U, HCCL_ERROR("[HcclMemDereg]buf size[%llu] is invalid", buf->len), HCCL_E_PARA);
233 :
234 : DevType devType;
235 0 : CHK_RET(hrtGetDeviceType(devType));
236 0 : if (devType == DevType::DEV_TYPE_950 || devType == DevType::DEV_TYPE_960) {return HcclMemDeregV2(buf);}
237 :
238 0 : RmaBuffer *rmaBuffer = static_cast<RmaBuffer *>(buf->handle);
239 0 : NetDevContext *netDevCtx = static_cast<NetDevContext *>(const_cast<void *>(rmaBuffer->GetNetDevCtx()));
240 0 : if (netDevCtx->GetNicType() == NicType::VNIC_TYPE) {
241 0 : return HcclMemDeregIpc(netDevCtx, buf);
242 : } else {
243 0 : return HcclMemDeregRoce(netDevCtx, buf);
244 : }
245 : }
246 :
247 0 : HcclResult HcclMemRemap(HcclNetDev netDev, const HcclMem *memArray, uint64_t arraySize)
248 : {
249 0 : CHK_PTR_NULL(netDev);
250 0 : CHK_PTR_NULL(memArray);
251 0 : CHK_PRT_RET(arraySize == 0U, HCCL_ERROR("[HcclMemReMap]arraySize[%llu] is invalid", arraySize), HCCL_E_PARA);
252 :
253 0 : NetDevContext *netDevCtx = static_cast<NetDevContext *>(netDev);
254 0 : if (netDevCtx->GetNicType() == NicType::VNIC_TYPE) {
255 0 : HCCL_INFO("[HcclMemReMap][ReMapMemIpc] doesn't support ReMapMem");
256 0 : return HCCL_SUCCESS;
257 : } else {
258 0 : return HcclMemRempRoce(netDevCtx, memArray, arraySize);
259 : }
260 : }
261 :
262 0 : HcclResult HcclMemExport(HcclBuf *buf, char **outDesc, uint64_t *outDescLen)
263 : {
264 0 : CHK_PTR_NULL(buf);
265 0 : CHK_PTR_NULL(outDesc);
266 0 : CHK_PTR_NULL(outDescLen);
267 0 : CHK_PTR_NULL(buf->addr);
268 0 : CHK_PTR_NULL(buf->handle);
269 0 : CHK_PRT_RET(buf->len == 0U, HCCL_ERROR("[HcclMemExport]buf size[%llu] is invalid", buf->len), HCCL_E_PARA);
270 :
271 : DevType devType;
272 0 : CHK_RET(hrtGetDeviceType(devType));
273 0 : if (devType == DevType::DEV_TYPE_950 || devType == DevType::DEV_TYPE_960) {return HcclMemExportV2(buf, outDesc, outDescLen);}
274 :
275 0 : RmaBuffer *rmaBuffer = static_cast<RmaBuffer *>(buf->handle);
276 0 : if (rmaBuffer->GetRmaType() == RmaType::IPC_RMA) {
277 0 : LocalIpcRmaBuffer *localRmaBufer = dynamic_cast<LocalIpcRmaBuffer *>(rmaBuffer);
278 0 : CHK_PTR_NULL(localRmaBufer);
279 0 : std::string &tempLocalMemDesc = localRmaBufer->Serialize();
280 0 : if (tempLocalMemDesc.empty()) {
281 0 : HCCL_ERROR("[HcclMemExport][Ipc]tempLocalMemDesc is empty.");
282 0 : return HCCL_E_INTERNAL;
283 : }
284 :
285 0 : *outDesc = const_cast<char *>(tempLocalMemDesc.c_str());
286 0 : *outDescLen = tempLocalMemDesc.length();
287 : } else {
288 0 : LocalRdmaRmaBuffer *localRmaBufer = dynamic_cast<LocalRdmaRmaBuffer *>(rmaBuffer);
289 0 : CHK_PTR_NULL(localRmaBufer);
290 0 : std::string &tempLocalMemDesc = localRmaBufer->Serialize();
291 0 : if (tempLocalMemDesc.empty()) {
292 0 : HCCL_ERROR("[HcclMemExport][Roce]tempLocalMemDesc is empty.");
293 0 : return HCCL_E_INTERNAL;
294 : }
295 :
296 0 : *outDesc = const_cast<char *>(tempLocalMemDesc.c_str());
297 0 : *outDescLen = tempLocalMemDesc.length();
298 : }
299 0 : return HCCL_SUCCESS;
300 : }
301 :
302 0 : HcclResult HcclMemGrant(HcclBuf *localBuf, const HcclMemGrantInfo *remoteGrantInfo)
303 : {
304 0 : CHK_PTR_NULL(localBuf);
305 0 : CHK_PTR_NULL(remoteGrantInfo);
306 0 : CHK_PTR_NULL(localBuf->addr);
307 0 : CHK_PTR_NULL(localBuf->handle);
308 0 : CHK_PRT_RET(localBuf->len == 0U, HCCL_ERROR("[HcclMemGrant]buf size[%llu] is invalid", localBuf->len), HCCL_E_PARA);
309 0 : RmaBuffer *rmaBuffer = static_cast<RmaBuffer *>(localBuf->handle);
310 0 : if (rmaBuffer->GetRmaType() == RmaType::IPC_RMA) {
311 0 : LocalIpcRmaBuffer *localRmaBufer = dynamic_cast<LocalIpcRmaBuffer *>(rmaBuffer);
312 0 : CHK_PTR_NULL(localRmaBufer);
313 0 : HcclResult ret = localRmaBufer->Grant(remoteGrantInfo->remotePid, remoteGrantInfo->remoteSdid);
314 0 : CHK_PRT_RET((ret != HCCL_SUCCESS), HCCL_ERROR("[HcclMemGrant]Grant error"), ret);
315 : }
316 0 : return HCCL_SUCCESS;
317 : }
318 :
319 0 : HcclResult HcclMemImport(const char *description, uint32_t descLen, bool isRemote, HcclBuf *outBuf, HcclNetDevCtx netDevCtx)
320 : {
321 0 : CHK_PTR_NULL(netDevCtx);
322 0 : CHK_PTR_NULL(description);
323 0 : CHK_PTR_NULL(outBuf);
324 0 : CHK_PRT_RET((descLen == 0),
325 : HCCL_ERROR("[HcclMemImport]input parameter is invalid descLen[%u] ", descLen), HCCL_E_PARA);
326 0 : CHK_PRT_RET(descLen > TRANSPORT_EMD_ESC_SIZE,
327 : HCCL_ERROR("[HcclMemImport]descLen[%u] is larger than limit[%u] ", descLen, TRANSPORT_EMD_ESC_SIZE), HCCL_E_PARA);
328 0 : if (isRemote == false) {HCCL_WARNING("[HcclMemImport]isRemote[%d] is invalid", isRemote);}
329 :
330 : DevType devType;
331 0 : CHK_RET(hrtGetDeviceType(devType));
332 0 : if (devType == DevType::DEV_TYPE_950 || devType == DevType::DEV_TYPE_960) {return HcclMemImportV2(description, descLen, isRemote, outBuf, netDevCtx);}
333 :
334 0 : std::string tempDesc = std::string(description, descLen);
335 0 : u8 rmaType = static_cast<unsigned char>(description[0]);
336 0 : switch (rmaType) {
337 0 : case static_cast<int>(RmaType::IPC_RMA): {
338 0 : RemoteIpcRmaBuffer* tempRemoteBufferPtr = new (std::nothrow) RemoteIpcRmaBuffer(netDevCtx);
339 0 : CHK_PTR_NULL(tempRemoteBufferPtr);
340 0 : HcclResult deRet = tempRemoteBufferPtr->Deserialize(tempDesc);
341 0 : HcclResult openRet = tempRemoteBufferPtr->Open();
342 0 : if (deRet != HCCL_SUCCESS || openRet != HCCL_SUCCESS) {
343 0 : delete tempRemoteBufferPtr;
344 0 : CHK_PRT_RET(deRet != HCCL_SUCCESS,
345 : HCCL_ERROR("[HcclMemImport]RemoteBuffer Deserialize failed."), deRet);
346 0 : CHK_PRT_RET(openRet != HCCL_SUCCESS,
347 : HCCL_ERROR("[HcclMemImport]RemoteBuffer Open failed."), openRet);
348 : }
349 0 : outBuf->addr = tempRemoteBufferPtr->GetAddr();
350 0 : outBuf->len = tempRemoteBufferPtr->GetSize();
351 0 : outBuf->handle = static_cast<void*>(tempRemoteBufferPtr);
352 0 : break;
353 : }
354 0 : case static_cast<int>(RmaType::RDMA_RMA): {
355 0 : RemoteRdmaRmaBuffer* tempRemoteBufferPtr = new (std::nothrow) RemoteRdmaRmaBuffer();
356 0 : CHK_PTR_NULL(tempRemoteBufferPtr);
357 0 : HcclResult ret = tempRemoteBufferPtr->Deserialize(tempDesc);
358 0 : if (ret != HCCL_SUCCESS) {
359 0 : delete tempRemoteBufferPtr;
360 0 : HCCL_ERROR("[HcclMemImport]RemoteBuffer Deserialize failed.");
361 0 : return ret;
362 : }
363 0 : outBuf->addr = tempRemoteBufferPtr->GetAddr();
364 0 : outBuf->len = tempRemoteBufferPtr->GetSize();
365 0 : outBuf->handle = static_cast<void*>(tempRemoteBufferPtr);
366 0 : break;
367 : }
368 0 : default: {
369 0 : HCCL_ERROR("[HcclMemImport]RmaType[%u] is invalid", rmaType);
370 0 : return HCCL_E_NOT_SUPPORT;
371 : }
372 : }
373 0 : return HCCL_SUCCESS;
374 0 : }
375 :
376 0 : HcclResult HcclMemClose(HcclBuf *buf)
377 : {
378 : // remoteIpcRmaBufferMgr_ 和 remoteRdmaRmaBufferMgr_ 要抽到HcclOneSidedConn里
379 0 : CHK_PTR_NULL(buf);
380 0 : CHK_PTR_NULL(buf->handle);
381 0 : RmaBuffer *rmaBuffer = static_cast<RmaBuffer *>(buf->handle);
382 :
383 : DevType devType;
384 0 : CHK_RET(hrtGetDeviceType(devType));
385 0 : if (devType == DevType::DEV_TYPE_950 || devType == DevType::DEV_TYPE_960) {return HcclMemCloseV2(buf);}
386 :
387 0 : if (rmaBuffer->GetRmaType() == RmaType::IPC_RMA) {
388 0 : HCCL_INFO("[HcclMemClose][Ipc] CloseMem");
389 0 : RemoteIpcRmaBuffer *tempRemoteBufferPtr = static_cast<RemoteIpcRmaBuffer *>(buf->handle);
390 0 : HcclResult ret = tempRemoteBufferPtr->Close();
391 0 : delete rmaBuffer;
392 0 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[HcclMemClose]RemoteBuffer Close failed"), ret);
393 0 : } else if (rmaBuffer->GetRmaType() == RmaType::RDMA_RMA) {
394 0 : HCCL_INFO("[HcclMemClose][Roce] CloseMem");
395 0 : delete rmaBuffer;
396 : } else {
397 0 : HCCL_ERROR("[HcclMemClose]RmaType[%d] is invalid", rmaBuffer->GetRmaType());
398 0 : return HCCL_E_INTERNAL;
399 : }
400 0 : return HCCL_SUCCESS;
401 : }
|
