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