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