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