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 "log.h"
11 : #include "hccs_reged_mem_mgr.h"
12 : // for hccl_network.h
13 : #include "hccl_network.h"
14 : #include "adapter_rts.h"
15 :
16 : using namespace hccl;
17 : namespace hcomm {
18 :
19 19 : HccsRegedMemMgr::HccsRegedMemMgr(HcclNetDevCtx netDevCtx)
20 : {
21 19 : netDevCtx_ = netDevCtx;
22 19 : }
23 :
24 19 : HccsRegedMemMgr::~HccsRegedMemMgr()
25 : {
26 19 : allRegisteredBuffers_.clear();
27 19 : }
28 :
29 21 : HcclResult HccsRegedMemMgr::RegisterMemory(HcommMem mem, const char *memTag, void **memHandle)
30 : {
31 21 : HCCL_INFO("[%s] Begin", __FUNCTION__);
32 21 : CHK_RET(ValidateMemParams(mem, memHandle));
33 18 : HCCL_INFO("[%s] addr[%p] size[%u] start", __FUNCTION__, mem.addr, mem.size);
34 :
35 18 : NetDevContext *netDevCtx = static_cast<NetDevContext *>(netDevCtx_);
36 18 : std::shared_ptr<LocalIpcRmaBufferMgr> localIpcRmaBufferMgr = netDevCtx->GetlocalIpcRmaBufferMgr();
37 18 : CHK_PTR_NULL(localIpcRmaBufferMgr);
38 :
39 18 : std::shared_ptr<hccl::LocalIpcRmaBuffer> localIpcRmaBuffer = nullptr;
40 : // LocalIpcRmaBuffer构造函数存在注册动作，在调用该构造函数前需检查是否注册过
41 18 : hccl::BufferKey<uintptr_t, u64> memKey(reinterpret_cast<uintptr_t>(mem.addr), mem.size);
42 18 : auto findPair = localIpcRmaBufferMgr->Find(memKey);
43 18 : if (findPair.first) {
44 5 : auto parentBuffer = findPair.second;
45 5 : EXCEPTION_CATCH((localIpcRmaBuffer = std::make_shared<hccl::LocalIpcRmaBuffer>(
46 : netDevCtx_, mem.addr, mem.size, static_cast<RmaMemType>(mem.type), *parentBuffer)),
47 : return HCCL_E_PTR);
48 5 : CHK_RET(AddBuffer(localIpcRmaBufferMgr, parentBuffer));
49 5 : HCCL_INFO("[HccsRegedMemMgr][RegisterMemory] alias created, key {%p, %llu}", mem.addr, mem.size);
50 5 : } else {
51 13 : EXCEPTION_CATCH((localIpcRmaBuffer = std::make_shared<hccl::LocalIpcRmaBuffer>(
52 : netDevCtx_, mem.addr, mem.size, static_cast<RmaMemType>(mem.type))),
53 : return HCCL_E_PTR);
54 :
55 13 : HcclResult ret = localIpcRmaBuffer->Init();
56 13 : if (ret != HCCL_SUCCESS) {
57 1 : HCCL_ERROR("[HccsRegedMemMgr][RegisterMemory]localbuffer init failed %d.", ret);
58 1 : return ret;
59 : }
60 :
61 12 : CHK_RET(AddBuffer(localIpcRmaBufferMgr, localIpcRmaBuffer));
62 12 : HCCL_INFO("[HccsRegedMemMgr][RegisterMemory]Register memory success! Add key {%p, %llu}", mem.addr, mem.size);
63 : }
64 :
65 17 : *memHandle = static_cast<void *>(localIpcRmaBuffer.get());
66 17 : allRegisteredBuffers_.emplace_back(localIpcRmaBuffer, false);
67 :
68 17 : HCCL_INFO("[%s] addr[%p] size[%u] memHandle[%p] allRegisteredBuffers_.size[%d]done",
69 : __FUNCTION__, mem.addr, mem.size, *memHandle, allRegisteredBuffers_.size());
70 17 : return HCCL_SUCCESS;
71 18 : }
72 :
73 20 : HcclResult HccsRegedMemMgr::UnregisterMemory(void* memHandle)
74 : {
75 20 : HCCL_INFO("[%s] Begin", __FUNCTION__);
76 20 : CHK_PTR_NULL(memHandle);
77 :
78 20 : NetDevContext *netDevCtx = static_cast<NetDevContext *>(netDevCtx_);
79 20 : std::shared_ptr<LocalIpcRmaBufferMgr> localIpcRmaBufferMgr = netDevCtx->GetlocalIpcRmaBufferMgr();
80 20 : CHK_PTR_NULL(localIpcRmaBufferMgr);
81 :
82 20 : hccl::LocalIpcRmaBuffer* buffer = static_cast<hccl::LocalIpcRmaBuffer*>(memHandle);
83 20 : void *addr = buffer->GetAddr();
84 20 : uint64_t size = buffer->GetSize();
85 20 : HCCL_INFO("[%s] addr[%p] size[%u] memHandle[%p] start", __FUNCTION__, addr, size, memHandle);
86 :
87 : // IsAlias() 直接区分父子buffer：
88 : // - 父buffer (IsAlias()=false): 自己的key在tree中 → Del(ownKey)
89 : // - 子buffer (IsAlias()=true): 自己的key不在tree中 → 通过Find找父key做Del
90 20 : hccl::BufferKey<uintptr_t, u64> ownKey(reinterpret_cast<uintptr_t>(addr), size);
91 20 : hccl::LocalIpcRmaBuffer* refBuffer = buffer;
92 :
93 20 : if (buffer->IsAlias()) {
94 6 : auto findResult = localIpcRmaBufferMgr->Find(ownKey);
95 6 : if (findResult.first) {
96 4 : refBuffer = findResult.second.get();
97 : } else {
98 2 : HCCL_ERROR("[HccsRegedMemMgr][UnregisterMemory] alias parent not found");
99 2 : return HCCL_E_NOT_FOUND;
100 : }
101 6 : }
102 :
103 18 : auto refBufferInfo = std::make_pair(refBuffer->GetAddr(), refBuffer->GetSize());
104 18 : hccl::BufferKey<uintptr_t, u64> memKey(reinterpret_cast<uintptr_t>(refBufferInfo.first), refBufferInfo.second);
105 18 : bool resultPair = false;
106 18 : EXCEPTION_CATCH(resultPair = localIpcRmaBufferMgr->Del(memKey), return HCCL_E_NOT_FOUND);
107 : // 无论tree中是否删除（ref是否归零），当前handle都要从allBuffers移除
108 16 : bool found = false;
109 21 : for (auto it = allRegisteredBuffers_.begin(); it != allRegisteredBuffers_.end(); it++) {
110 21 : if (it->first.get() == buffer) {
111 16 : HCCL_INFO("[%s] addr[%p] size[%u] memHandle[%p]", __FUNCTION__, addr, size, memHandle);
112 : // IsInTree判断tree中是否还有该key的引用
113 16 : if (!localIpcRmaBufferMgr->IsInTree(ownKey)) {
114 12 : it = allRegisteredBuffers_.erase(it);
115 : } else {
116 4 : it->second = true;
117 : }
118 16 : found = true;
119 16 : break;
120 : }
121 : }
122 16 : if (!found) {
123 0 : HCCL_ERROR("[%s] addr[%p] size[%zu] memHandle[%p] allRegisteredBuffers_.size[%zu] Not Found",
124 : __FUNCTION__, addr, static_cast<size_t>(size), memHandle, allRegisteredBuffers_.size());
125 0 : return HCCL_E_NOT_FOUND;
126 : }
127 16 : if (!resultPair) {
128 5 : HCCL_INFO("[HccsRegedMemMgr][UnregisterMemory]Memory reference count is larger than 0, do not deregister memory.");
129 5 : return HCCL_SUCCESS;
130 : }
131 11 : return HCCL_SUCCESS;
132 20 : }
133 :
134 2 : HcclResult HccsRegedMemMgr::SerializeToMemDesc(const EndpointDesc &endpointDesc, hccl::LocalIpcRmaBuffer *localIpcRmaBuffer,
135 : void **memDesc, uint32_t *descLen)
136 : {
137 2 : HCCL_INFO("[%s] Begin", __FUNCTION__);
138 2 : CHK_PTR_NULL(memDesc);
139 2 : CHK_PTR_NULL(descLen);
140 :
141 2 : std::string &ipcRmaBufferDesc = localIpcRmaBuffer->Serialize();
142 2 : HCCL_INFO("[%s] ipcRmaBufferDesc.len[%u]", __FUNCTION__, ipcRmaBufferDesc.length());
143 :
144 2 : ipcRmaBufferDesc.resize(ipcRmaBufferDesc.length() + sizeof(EndpointDesc));
145 : // put the EndpointDesc at the end of the Serialize-ed buf
146 2 : if(memcpy_s(const_cast<char *>(ipcRmaBufferDesc.c_str()) + (ipcRmaBufferDesc.length() - sizeof(EndpointDesc)),
147 2 : sizeof(EndpointDesc), &endpointDesc, sizeof(EndpointDesc)) != EOK) {
148 0 : HCCL_ERROR("[RoceRegedMemMgr][SerializeToMemDesc] [%s] endpointDesc memcpy_s failed.", __func__);
149 0 : return HCCL_E_INTERNAL;
150 : }
151 :
152 2 : *descLen = static_cast<uint32_t>(ipcRmaBufferDesc.length());
153 2 : *memDesc = const_cast<char *>(ipcRmaBufferDesc.c_str());
154 2 : return HCCL_SUCCESS;
155 : }
156 :
157 4 : HcclResult HccsRegedMemMgr::MakeRemoteIpcRmaBuffer(std::string &ipcRmaBufferDesc,
158 : std::shared_ptr<hccl::RemoteIpcRmaBuffer> &remoteIpcRmaBuffer)
159 : {
160 4 : HCCL_INFO("[HccsRegedMemMgr][%s] start", __FUNCTION__);
161 4 : EXCEPTION_CATCH(
162 : remoteIpcRmaBuffer = std::make_shared<hccl::RemoteIpcRmaBuffer>(netDevCtx_),
163 : return HCCL_E_PTR;
164 : );
165 4 : CHK_PTR_NULL(remoteIpcRmaBuffer);
166 :
167 4 : HcclResult ret = remoteIpcRmaBuffer->Deserialize(ipcRmaBufferDesc);
168 4 : if (ret != HCCL_SUCCESS) {
169 0 : HCCL_ERROR("[HccsRegedMemMgr][MemoryImport]RemoteIpcRmaBuffer Deserialize failed.");
170 0 : return ret;
171 : }
172 :
173 4 : HCCL_INFO("[%s] addr[%p] size[%lu] done", __FUNCTION__,
174 : remoteIpcRmaBuffer->GetAddr(), remoteIpcRmaBuffer->GetSize());
175 :
176 4 : return HCCL_SUCCESS;
177 : }
178 :
179 4 : HcclResult HccsRegedMemMgr::DeSerializeFromMemDesc(const void *memDesc, uint32_t descLen,
180 : EndpointDesc &endpointDesc, std::shared_ptr<hccl::RemoteIpcRmaBuffer> &remoteIpcRmaBuffer)
181 : {
182 4 : HCCL_INFO("[%s] Begin", __FUNCTION__);
183 4 : CHK_PTR_NULL(memDesc);
184 :
185 4 : const char *description = static_cast<const char *>(memDesc);
186 4 : HCCL_INFO("[%s] descLen[%u] memDesc[%s]", __FUNCTION__, descLen, description);
187 :
188 4 : if (descLen <= sizeof(EndpointDesc)) {
189 0 : HCCL_ERROR("[HccsRegedMemMgr][DeSerializeFromMemDesc] [%s] descLen :%u too small error. need more than size:[%llu]",
190 : __func__, sizeof(EndpointDesc));
191 0 : return HCCL_E_INTERNAL;
192 : }
193 :
194 4 : uint32_t ipcRmaBufferDescLen = descLen - sizeof(EndpointDesc);
195 4 : if (memcpy_s(&endpointDesc, sizeof(EndpointDesc), description + ipcRmaBufferDescLen, sizeof(EndpointDesc)) != EOK) {
196 0 : HCCL_ERROR("[HccsRegedMemMgr][DeSerializeFromMemDesc] [%s] endpointDesc copy error. aim size:[%llu]",
197 : __func__, sizeof(EndpointDesc));
198 0 : return HCCL_E_INTERNAL;
199 : }
200 :
201 4 : std::string ipcRmaBufferDesc;
202 4 : ipcRmaBufferDesc.resize(ipcRmaBufferDescLen);
203 4 : if (memcpy_s(const_cast<char *>(ipcRmaBufferDesc.c_str()), ipcRmaBufferDescLen,
204 4 : description, ipcRmaBufferDescLen) != EOK) {
205 0 : HCCL_ERROR("[HccsRegedMemMgr][DeSerializeFromMemDesc] [%s] ipcRmaBufferDesc copy error. aim size:[%llu]",
206 : __func__, ipcRmaBufferDescLen);
207 0 : return HCCL_E_INTERNAL;
208 : }
209 :
210 4 : CHK_RET(MakeRemoteIpcRmaBuffer(ipcRmaBufferDesc, remoteIpcRmaBuffer));
211 4 : return HCCL_SUCCESS;
212 4 : }
213 :
214 3 : HcclResult HccsRegedMemMgr::MemoryExport(
215 : const EndpointDesc endpointDesc, void *memHandle, void **memDesc, uint32_t *memDescLen)
216 : {
217 3 : HCCL_INFO("[%s] Begin", __FUNCTION__);
218 3 : CHK_PTR_NULL(memHandle);
219 3 : CHK_PTR_NULL(memDesc);
220 3 : CHK_PTR_NULL(memDescLen);
221 :
222 3 : hccl::LocalIpcRmaBuffer *localIpcRmaBuffer = nullptr;
223 3 : CHK_RET(ValidateMemExportHandle(memHandle, allRegisteredBuffers_, localIpcRmaBuffer));
224 2 : CHK_RET(SerializeToMemDesc(endpointDesc, localIpcRmaBuffer, memDesc, memDescLen));
225 2 : HCCL_INFO("[%s] memDesc[%p] descLen[%u]", __FUNCTION__, *memDesc, *memDescLen);
226 2 : return HCCL_SUCCESS;
227 : }
228 :
229 2 : HcclResult HccsRegedMemMgr::AddMem(hccl::BufferKey<uintptr_t, u64> &memKey,
230 : std::shared_ptr<hccl::RemoteIpcRmaBuffer> &remoteIpcRmaBuffer)
231 : {
232 2 : CHK_PTR_NULL(remoteIpcRmaBuffer);
233 2 : HCCL_INFO("[HccsRegedMemMgr][%s] addr[%p], size[%lu] start",
234 : __FUNCTION__, reinterpret_cast<void *>(memKey.Addr()), memKey.Size());
235 :
236 2 : auto resultPair = remoteIpcRmaBufferMgr_.Add(memKey, remoteIpcRmaBuffer);
237 2 : if(!resultPair.second) {
238 0 : HCCL_ERROR("[HccsRegedMemMgr][%s] addr[%p], size[%lu] has already been imported!",
239 : __FUNCTION__, reinterpret_cast<void *>(memKey.Addr()), memKey.Size());
240 0 : return HCCL_E_AGAIN;
241 : }
242 :
243 2 : HCCL_INFO("[HccsRegedMemMgr][%s] addr[%p], size[%lu] done",
244 : __FUNCTION__, reinterpret_cast<void *>(memKey.Addr()), memKey.Size());
245 2 : return HCCL_SUCCESS;
246 : }
247 :
248 2 : HcclResult HccsRegedMemMgr::DeleteMem(hccl::BufferKey<uintptr_t, u64> &memKey)
249 : {
250 2 : HCCL_INFO("[HccsRegedMemMgr][%s] addr[%p], size[%lu] start",
251 : __FUNCTION__, reinterpret_cast<void *>(memKey.Addr()), memKey.Size());
252 :
253 2 : bool delResultPair = false;
254 2 : EXCEPTION_CATCH(delResultPair = remoteIpcRmaBufferMgr_.Del(memKey), return HCCL_E_NOT_FOUND);
255 : // 计数器大于1时，返回false，说明框架层有其它设备在使用这段endpointDesc，返回HCCL_SUCCESS
256 2 : if (!delResultPair) {
257 0 : HCCL_INFO("[HccsRegedMemMgr][%s] addr[%p], size[%lu] reference count is larger than 0",
258 : __FUNCTION__, reinterpret_cast<void *>(memKey.Addr()), memKey.Size());
259 0 : return HCCL_SUCCESS;
260 : }
261 :
262 2 : HCCL_INFO("[HccsRegedMemMgr][%s] addr[%p], size[%lu] done",
263 : __FUNCTION__, reinterpret_cast<void *>(memKey.Addr()), memKey.Size());
264 :
265 2 : return HCCL_SUCCESS;
266 : }
267 :
268 2 : HcclResult HccsRegedMemMgr::MemoryImport(const void *memDesc, uint32_t descLen, HcommMem *outMem)
269 : {
270 2 : CHK_PTR_NULL(memDesc);
271 2 : CHK_PTR_NULL(outMem);
272 2 : HCCL_INFO("[%s] memDesc[%p] descLen[%u] start", __FUNCTION__, memDesc, descLen);
273 :
274 : EndpointDesc endpointDesc;
275 2 : std::shared_ptr<hccl::RemoteIpcRmaBuffer> remoteIpcRmaBuffer = nullptr;
276 2 : CHK_RET(DeSerializeFromMemDesc(memDesc, descLen, endpointDesc, remoteIpcRmaBuffer));
277 2 : hccl::BufferKey<uintptr_t, u64> memKey(reinterpret_cast<uintptr_t>(remoteIpcRmaBuffer->GetAddr()),
278 4 : remoteIpcRmaBuffer->GetSize());
279 :
280 2 : auto resultPair = remoteIpcRmaBufferMgr_.Find(memKey);
281 2 : if(!resultPair.first) {
282 2 : HCCL_INFO("[HccsRegedMemMgr][%s] addr[%p], size[%lu] has Not Found!",
283 : __FUNCTION__, memKey.Addr(), memKey.Size());
284 2 : CHK_RET(AddMem(memKey, remoteIpcRmaBuffer));
285 : }
286 :
287 2 : outMem->addr = reinterpret_cast<void *>(remoteIpcRmaBuffer->GetAddr());
288 2 : outMem->size = remoteIpcRmaBuffer->GetSize();
289 2 : outMem->type = static_cast<CommMemType>(remoteIpcRmaBuffer->GetMemType());
290 :
291 2 : HCCL_INFO("[%s]memDesc[%p] descLen[%u] addr[%p] size[%lu], type[%u] done",
292 : __FUNCTION__, memDesc, descLen, outMem->addr, outMem->size, outMem->type);
293 :
294 2 : return HCCL_SUCCESS;
295 2 : }
296 :
297 2 : HcclResult HccsRegedMemMgr::MemoryUnimport(const void *memDesc, uint32_t descLen)
298 : {
299 2 : CHK_PTR_NULL(memDesc);
300 2 : HCCL_INFO("[%s] memDesc[%p] descLen[%u] start", __FUNCTION__, memDesc, descLen);
301 :
302 : EndpointDesc endpointDesc;
303 2 : std::shared_ptr<hccl::RemoteIpcRmaBuffer> remoteIpcRmaBufferTmp = nullptr;
304 2 : CHK_RET(DeSerializeFromMemDesc(memDesc, descLen, endpointDesc, remoteIpcRmaBufferTmp));
305 2 : hccl::BufferKey<uintptr_t, u64> memKey(reinterpret_cast<uintptr_t>(remoteIpcRmaBufferTmp->GetAddr()),
306 4 : remoteIpcRmaBufferTmp->GetSize());
307 :
308 2 : std::shared_ptr<hccl::RemoteIpcRmaBuffer> remoteIpcRmaBuffer = nullptr;
309 2 : auto resultPair = remoteIpcRmaBufferMgr_.Find(memKey);
310 2 : if(!resultPair.first) {
311 0 : HCCL_ERROR("[HccsRegedMemMgr][%s] addr[%p], size[%lu] has Not Found!",
312 : __FUNCTION__, memKey.Addr(), memKey.Size());
313 0 : return HCCL_E_NOT_FOUND;
314 : }
315 2 : remoteIpcRmaBuffer = resultPair.second;
316 2 : CHK_PTR_NULL(remoteIpcRmaBuffer);
317 :
318 2 : if (remoteIpcRmaBuffer->IsOpened()) {
319 0 : HCCL_INFO("[HccsRegedMemMgr][DeleteMemDesc] memDesc[%p] descLen[%u] addr[%p] size[%lu] need to close first",
320 : memDesc, descLen, reinterpret_cast<void *>(memKey.Addr()), memKey.Size());
321 0 : return HCCL_SUCCESS;
322 : }
323 :
324 2 : CHK_RET(DeleteMem(memKey));
325 :
326 2 : HCCL_INFO("[%s] memDesc[%p] descLen[%u] addr[%p] size[%lu] done", __FUNCTION__,
327 : memDesc, descLen, reinterpret_cast<void *>(memKey.Addr()), memKey.Size());
328 :
329 2 : return HCCL_SUCCESS;
330 2 : }
331 :
332 2 : HcclResult HccsRegedMemMgr::MemoryGrant(const HcommMemGrantInfo *remoteGrantInfo)
333 : {
334 2 : HCCL_INFO("[%s] Begin", __FUNCTION__);
335 2 : CHK_PTR_NULL(remoteGrantInfo);
336 :
337 2 : HCCL_INFO("[HccsRegedMemMgr][MemoryGrant]Grant remotePid:%d, remoteSdid:%u",
338 : remoteGrantInfo->pid, remoteGrantInfo->sdid);
339 4 : for (auto it = allRegisteredBuffers_.begin(); it != allRegisteredBuffers_.end(); it++) {
340 2 : if (it->second) {
341 0 : continue;
342 : }
343 2 : std::shared_ptr<hccl::LocalIpcRmaBuffer> localIpcRmaBuffer = it->first;
344 2 : CHK_PTR_NULL(localIpcRmaBuffer);
345 :
346 2 : HcclResult ret = localIpcRmaBuffer->Grant(remoteGrantInfo->pid, remoteGrantInfo->sdid);
347 2 : CHK_PRT_RET((ret != HCCL_SUCCESS),
348 : HCCL_ERROR("[HccsRegedMemMgr][MemoryGrant]Grant remotePid:%d, remoteSdid:%u error",
349 : remoteGrantInfo->pid, remoteGrantInfo->sdid), ret);
350 2 : HCCL_INFO("[HccsRegedMemMgr][MemoryGrant]Grant remotePid:%d, remoteSdid:%u addr [%p] done",
351 : remoteGrantInfo->pid, remoteGrantInfo->sdid, localIpcRmaBuffer->GetAddr());
352 2 : }
353 :
354 2 : HCCL_INFO("[HccsRegedMemMgr][MemoryGrant]Grant remotePid:%d, remoteSdid:%u done",
355 : remoteGrantInfo->pid, remoteGrantInfo->sdid);
356 2 : return HCCL_SUCCESS;
357 : }
358 :
359 2 : HcclResult HccsRegedMemMgr::MemoryEnableP2P(const EndpointDesc &localEndpointDesc, const EndpointDesc &remoteEndpointDesc)
360 : {
361 2 : HCCL_INFO("[%s] Begin", __FUNCTION__);
362 2 : if (localEndpointDesc.loc.device.serverIdx == remoteEndpointDesc.loc.device.serverIdx) {
363 : u32 deviceLogicId;
364 2 : CHK_RET(hrtGetDeviceIndexByPhyId(localEndpointDesc.loc.device.devPhyId, deviceLogicId));
365 2 : HCCL_INFO("Need do hrtEnableP2P for device[%u] with deviceLogicId[%u]",
366 : remoteEndpointDesc.loc.device.devPhyId, deviceLogicId);
367 2 : CHK_RET(hrtEnableP2P(deviceLogicId, remoteEndpointDesc.loc.device.devPhyId));
368 : }
369 2 : return HCCL_SUCCESS;
370 : }
371 :
372 2 : HcclResult HccsRegedMemMgr::MemoryDisableP2P(const EndpointDesc &localEndpointDesc, const EndpointDesc &remoteEndpointDesc)
373 : {
374 2 : HCCL_INFO("[%s] Begin", __FUNCTION__);
375 2 : if (localEndpointDesc.loc.device.serverIdx == remoteEndpointDesc.loc.device.serverIdx) {
376 : u32 deviceLogicId;
377 2 : CHK_RET(hrtGetDeviceIndexByPhyId(localEndpointDesc.loc.device.devPhyId, deviceLogicId));
378 2 : HCCL_INFO("Need do hrtDisableP2P for device[%u] with deviceLogicId[%u]",
379 : remoteEndpointDesc.loc.device.devPhyId, deviceLogicId);
380 2 : CHK_RET(hrtDisableP2P(deviceLogicId, remoteEndpointDesc.loc.device.devPhyId));
381 : }
382 2 : return HCCL_SUCCESS;
383 : }
384 :
385 2 : HcclResult HccsRegedMemMgr::MemoryOpenRemoteIpc()
386 : {
387 2 : HCCL_INFO("[%s] Begin", __FUNCTION__);
388 3 : for (auto it = remoteIpcRmaBufferMgr_.Begin(); it != remoteIpcRmaBufferMgr_.End();) {
389 1 : const std::shared_ptr<hccl::RemoteIpcRmaBuffer> &remoteIpcRmaBuffer = it->second.buffer;
390 1 : HcclResult openRet = remoteIpcRmaBuffer->Open();
391 1 : if (openRet != HCCL_SUCCESS) {
392 0 : HCCL_ERROR("[HccsRegedMemMgr][MemoryOpenRemoteIpc]RemoteIpcRmaBuffer Open failed.");
393 0 : for (auto it2 = remoteIpcRmaBufferMgr_.Begin(); it2 != it;) {
394 0 : const std::shared_ptr<hccl::RemoteIpcRmaBuffer> &remoteIpcRmaBuffer2 = it2->second.buffer;
395 0 : (void)remoteIpcRmaBuffer2->Close();
396 0 : it2 = remoteIpcRmaBufferMgr_.Next(it2);
397 : }
398 0 : return openRet;
399 : }
400 1 : it = remoteIpcRmaBufferMgr_.Next(it);
401 : }
402 :
403 2 : return HCCL_SUCCESS;
404 : }
405 :
406 2 : HcclResult HccsRegedMemMgr::MemoryCloseRemoteIpc()
407 : {
408 2 : HCCL_INFO("[%s] Begin", __FUNCTION__);
409 3 : for (auto it = remoteIpcRmaBufferMgr_.Begin(); it != remoteIpcRmaBufferMgr_.End();) {
410 1 : const std::shared_ptr<hccl::RemoteIpcRmaBuffer> &remoteIpcRmaBuffer = it->second.buffer;
411 1 : (void)remoteIpcRmaBuffer->Close();
412 1 : it = remoteIpcRmaBufferMgr_.Next(it);
413 : }
414 :
415 2 : return HCCL_SUCCESS;
416 : }
417 :
418 0 : HcclResult HccsRegedMemMgr::GetAllMemHandles(void **memHandles, uint32_t *memHandleNum)
419 : {
420 0 : HCCL_INFO("[%s] Begin", __FUNCTION__);
421 0 : return GetAllMemHandlesImpl(allRegisteredBuffers_, activeHandles_, memHandles, memHandleNum, "HccsRegedMemMgr");
422 : }
423 :
424 0 : HcclResult HccsRegedMemMgr::GetRemoteIpcRmaBuffer(std::vector<CommMem> &remoteIpcRmaBufferVec)
425 : {
426 : CommMem mem;
427 0 : for (auto it = remoteIpcRmaBufferMgr_.Begin(); it != remoteIpcRmaBufferMgr_.End();) {
428 0 : const std::shared_ptr<hccl::RemoteIpcRmaBuffer> &remoteIpcRmaBuffer = it->second.buffer;
429 0 : mem.addr = remoteIpcRmaBuffer->GetAddr();
430 0 : mem.size = remoteIpcRmaBuffer->GetSize();
431 0 : mem.type = remoteIpcRmaBuffer->GetMemType() == RmaMemType::DEVICE ? CommMemType::COMM_MEM_TYPE_DEVICE :
432 : CommMemType::COMM_MEM_TYPE_HOST;
433 0 : remoteIpcRmaBufferVec.emplace_back(mem);
434 0 : HCCL_INFO("[HccsRegedMemMgr][GetRemoteIpcRmaBuffer]remote addr:%p, size[%lu], type[%u]",
435 : mem.addr, mem.size, static_cast<u32>(mem.type));
436 0 : it = remoteIpcRmaBufferMgr_.Next(it);
437 : }
438 0 : return HCCL_SUCCESS;
439 : }
440 :
441 0 : HcclResult HccsRegedMemMgr::GetRemoteIpcRmaBufferEx(std::vector<HcclMemEx> &remoteIpcRmaBufferVecEx)
442 : {
443 : HcclMemEx mem;
444 0 : for (auto it = remoteIpcRmaBufferMgr_.Begin(); it != remoteIpcRmaBufferMgr_.End();) {
445 0 : const std::shared_ptr<hccl::RemoteIpcRmaBuffer> &remoteIpcRmaBuffer = it->second.buffer;
446 0 : mem.addr = remoteIpcRmaBuffer->GetAddr();
447 0 : mem.size = remoteIpcRmaBuffer->GetSize();
448 0 : mem.type = remoteIpcRmaBuffer->GetMemType() == RmaMemType::DEVICE ? HcclMemType::HCCL_MEM_TYPE_DEVICE :
449 : HcclMemType::HCCL_MEM_TYPE_HOST;
450 0 : mem.devAddr = remoteIpcRmaBuffer->GetDevAddr();
451 0 : remoteIpcRmaBufferVecEx.emplace_back(mem);
452 0 : HCCL_INFO("[HccsRegedMemMgr][GetRemoteIpcRmaBufferEx]remote addr:%p, size[%lu], type[%u], devAddr[%p]",
453 : mem.addr, mem.size, static_cast<u32>(mem.type), mem.devAddr);
454 0 : it = remoteIpcRmaBufferMgr_.Next(it);
455 : }
456 0 : return HCCL_SUCCESS;
457 : }
458 :
459 0 : HcclResult HccsRegedMemMgr::GetLocalIpcRmaBufferEx(std::vector<HcclMemEx> &localIpcRmaBufferVecEx)
460 : {
461 0 : NetDevContext *netDevCtx = static_cast<NetDevContext *>(netDevCtx_);
462 0 : const std::shared_ptr<LocalIpcRmaBufferMgr> &localIpcRmaBufferMgr = netDevCtx->GetlocalIpcRmaBufferMgr();
463 0 : CHK_PTR_NULL(localIpcRmaBufferMgr);
464 :
465 : HcclMemEx mem;
466 0 : for (auto it = localIpcRmaBufferMgr->Begin(); it != localIpcRmaBufferMgr->End(); ) {
467 0 : const std::shared_ptr<hccl::LocalIpcRmaBuffer> &localIpcRmaBuffer = it->second.buffer;
468 0 : mem.addr = localIpcRmaBuffer->GetAddr();
469 0 : mem.size = localIpcRmaBuffer->GetSize();
470 0 : mem.type = localIpcRmaBuffer->GetMemType() == RmaMemType::DEVICE ? HcclMemType::HCCL_MEM_TYPE_DEVICE :
471 : HcclMemType::HCCL_MEM_TYPE_HOST;
472 0 : mem.devAddr = localIpcRmaBuffer->GetDevAddr();
473 0 : localIpcRmaBufferVecEx.emplace_back(mem);
474 0 : HCCL_INFO("[HccsRegedMemMgr][GetLocalIpcRmaBufferEx]local addr:%p, size[%lu], type[%u], devAddr[%p]",
475 : mem.addr, mem.size, static_cast<u32>(mem.type), mem.devAddr);
476 0 : it = localIpcRmaBufferMgr->Next(it);
477 : }
478 0 : return HCCL_SUCCESS;
479 0 : }
480 : }
|
