Line data Source code
1 : /**
2 : * Copyright (c) 2026 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 "./dev_rdma_connection_v2.h"
11 : #include "log.h"
12 : #include "orion_adapter_rts.h"
13 : #include "hccp.h"
14 :
15 : namespace hcomm {
16 : constexpr uint32_t DEFAULT_CQN = 0;
17 :
18 40 : DevRdmaConnectionV2::DevRdmaConnectionV2(Hccl::Socket *socket, RdmaHandle rdmaHandle):
19 40 : socket_(socket), rdmaHandle_(rdmaHandle) {}
20 :
21 40 : HcclResult DevRdmaConnectionV2::Init()
22 : {
23 40 : if (rdmaConnStatus_ != RdmaConnStatus::CLOSED) {
24 0 : HCCL_INFO("[DevRdmaConnectionV2][%s] status[%s] is not need init.",
25 : __func__, rdmaConnStatus_.Describe().c_str());
26 0 : return HCCL_SUCCESS;
27 : }
28 :
29 40 : GetNdaOps();
30 40 : CHK_RET(GetDirectFlag());
31 40 : CHK_RET(GetDmaMode());
32 :
33 40 : rdmaConnStatus_ = RdmaConnStatus::INIT;
34 40 : return HCCL_SUCCESS;
35 : }
36 :
37 44 : DevRdmaConnectionV2::~DevRdmaConnectionV2()
38 : {
39 40 : if (rdmaConnStatus_ == RdmaConnStatus::CLOSED || rdmaConnStatus_ == RdmaConnStatus::INIT) {
40 36 : return;
41 : }
42 4 : HcclResult ret = DestroyQp();
43 4 : if (ret != HCCL_SUCCESS) {
44 0 : HCCL_ERROR("[%s]call DestroyQp failed: hcclRet -> %d", __func__, ret);
45 : }
46 148 : }
47 :
48 5 : std::string DevRdmaConnectionV2::Describe() const
49 : {
50 5 : return Hccl::StringFormat("DevRdmaConnectionV2[status=%s]", rdmaConnStatus_.Describe().c_str());
51 : }
52 :
53 0 : static void *NdaAlloc(size_t size) {
54 0 : return Hccl::HrtMalloc(size, static_cast<int>(ACL_MEM_MALLOC_HUGE_ONLY));
55 : }
56 :
57 0 : static void NdaFree(void *ptr) {
58 0 : if (ptr == nullptr) {
59 0 : return;
60 : }
61 0 : Hccl::HrtFree(ptr);
62 : }
63 :
64 0 : static void NdaMemset(void *dst, int value, size_t count) {
65 0 : Hccl::HrtMemsetV2(dst, count, value, count);
66 0 : }
67 :
68 0 : static int NdaMemcpy(void *dst, size_t dstSize, void *src, size_t srcSize, uint32_t direct) {
69 0 : Hccl::rtMemcpyKind_t kind = Hccl::rtMemcpyKind_t::RT_MEMCPY_DEFAULT;
70 0 : switch (direct) {
71 0 : case MEMCPY_DIRECT_HOST_TO_HOST: {
72 0 : kind = Hccl::rtMemcpyKind_t::RT_MEMCPY_HOST_TO_HOST;
73 0 : break;
74 : }
75 0 : case MEMCPY_DIRECT_HOST_TO_DEVICE: {
76 0 : kind = Hccl::rtMemcpyKind_t::RT_MEMCPY_HOST_TO_DEVICE;
77 0 : break;
78 : }
79 0 : case MEMCPY_DIRECT_DEVICE_TO_HOST: {
80 0 : kind = Hccl::rtMemcpyKind_t::RT_MEMCPY_DEVICE_TO_HOST;
81 0 : break;
82 : }
83 0 : case MEMCPY_DIRECT_DEVICE_TO_DEVICE: {
84 0 : kind = Hccl::rtMemcpyKind_t::RT_MEMCPY_DEVICE_TO_DEVICE;
85 0 : break;
86 : }
87 0 : default: {
88 0 : HCCL_ERROR("[MemcpyKindTranslate]Not support the memory copy type[%d].", direct);
89 0 : return -1;
90 : }
91 : }
92 0 : Hccl::HrtMemcpy(dst, dstSize, src, srcSize, kind);
93 0 : return 0;
94 : }
95 :
96 40 : void DevRdmaConnectionV2::GetNdaOps() {
97 40 : ndaOps_ = {
98 : .alloc = NdaAlloc,
99 : .free = NdaFree,
100 : .memset_s = NdaMemset,
101 : .memcpy_s = NdaMemcpy
102 : };
103 40 : }
104 :
105 40 : HcclResult DevRdmaConnectionV2::GetDirectFlag() {
106 40 : s32 ret = RaNdaGetDirectFlag(rdmaHandle_, &directFlag_);
107 40 : if (ret != 0) {
108 0 : HCCL_ERROR("[DevRdmaConnectionV2][GetDirectFlag]errNo[0x%016llx] get directFlag fail. "
109 : "return[%d], params: rdmaHandle[%p], directFlag[%d]",
110 : HCCL_ERROR_CODE(HCCL_E_INTERNAL), ret, rdmaHandle_, directFlag_);
111 0 : return HCCL_E_INTERNAL;
112 : }
113 40 : return HCCL_SUCCESS;
114 : }
115 :
116 40 : HcclResult DevRdmaConnectionV2::GetDmaMode() {
117 40 : switch (directFlag_) {
118 40 : case DIRECT_FLAG_PCIE: {
119 40 : dmaMode_ = QBUF_DMA_MODE_DEFAULT;
120 40 : break;
121 : }
122 0 : case DIRECT_FLAG_UB: {
123 0 : dmaMode_ = QBUF_DMA_MODE_INDEP_UB;
124 0 : break;
125 : }
126 0 : default: {
127 0 : HCCL_ERROR("[GetDmaMode]Not support the directFlag [%d].", directFlag_);
128 0 : dmaMode_ = QBUF_DMA_MODE_MAX;
129 0 : return HCCL_E_INTERNAL;
130 : }
131 : }
132 40 : HCCL_INFO("[GetDmaMode] directFlag[%d], dmaMode[%d]", directFlag_, dmaMode_);
133 40 : return HCCL_SUCCESS;
134 : }
135 :
136 4 : HcclResult DevRdmaConnectionV2::CreateQp()
137 : {
138 4 : if (socket_->GetStatus() != Hccl::SocketStatus::OK) {
139 0 : HCCL_WARNING("[DevRdmaConnectionV2::CreateQp] socket status is not ok, please");
140 0 : return HCCL_E_AGAIN;
141 : }
142 :
143 4 : CHK_RET(Hccl::HrtRaNdaCqCreate(rdmaHandle_, &ndaOps_, dmaMode_, &ndaCqInfo_, &cqHandle_));
144 :
145 4 : CHK_RET(Hccl::HrtRaNdaQpCreate(rdmaHandle_, &ndaOps_, dmaMode_, &ndaCqInfo_, &ndaQpInfo_, &qpHandle_));
146 :
147 4 : SqPiMem_ = hccl::DeviceMem::alloc(sizeof(void*));
148 4 : SqCiMem_ = hccl::DeviceMem::alloc(sizeof(void*));
149 4 : CqPiMem_ = hccl::DeviceMem::alloc(sizeof(void*));
150 4 : CqCiMem_ = hccl::DeviceMem::alloc(sizeof(void*));
151 4 : CHK_PRT_RET(!SqPiMem_ || !SqCiMem_ || !CqPiMem_ || !CqCiMem_,
152 : HCCL_ERROR("%s DeviceMem::alloc for SqPi_ or SqCi_ or CqPi_ or CqCi_ failed, size=%zu", __func__, sizeof(void*)),
153 : HCCL_E_MEMORY);
154 :
155 4 : rdmaConnStatus_ = RdmaConnStatus::QP_CREATED;
156 4 : return HCCL_SUCCESS;
157 : }
158 :
159 4 : HcclResult DevRdmaConnectionV2::DestroyQp()
160 : {
161 4 : if (rdmaConnStatus_ == RdmaConnStatus::CLOSED || rdmaConnStatus_ == RdmaConnStatus::INIT) {
162 0 : return HCCL_SUCCESS;
163 : }
164 :
165 4 : HcclResult ret = HCCL_SUCCESS;
166 :
167 4 : if (qpHandle_ != nullptr) {
168 0 : Hccl::HrtRaQpDestroy(qpHandle_);
169 0 : qpHandle_ = nullptr;
170 : }
171 :
172 4 : if (cqHandle_ != nullptr) {
173 4 : ret = Hccl::HrtRaNdaCqDestroy(rdmaHandle_, cqHandle_);
174 4 : if (ret != HCCL_SUCCESS) {
175 0 : HCCL_ERROR("[DevRdmaConnectionV2::%s] HrtRaNdaCqDestroy failed, ret[%d]", __func__, ret);
176 : }
177 4 : cqHandle_ = nullptr;
178 : }
179 :
180 4 : SqPiMem_ = hccl::DeviceMem();
181 4 : SqCiMem_ = hccl::DeviceMem();
182 4 : CqPiMem_ = hccl::DeviceMem();
183 4 : CqCiMem_ = hccl::DeviceMem();
184 :
185 4 : rdmaConnStatus_ = RdmaConnStatus::CLOSED;
186 4 : return ret;
187 : }
188 :
189 4 : HcclResult DevRdmaConnectionV2::GetExchangeDto(std::unique_ptr<Hccl::Serializable> &locQpAttrserial)
190 : {
191 4 : if (rdmaConnStatus_ != RdmaConnStatus::QP_CREATED && rdmaConnStatus_ != RdmaConnStatus::QP_MODIFIED) {
192 0 : HCCL_ERROR("[DevRdmaConnectionV2][%s] status[%s] is not expected.",
193 : __func__, rdmaConnStatus_.Describe().c_str());
194 0 : return HCCL_E_AGAIN;
195 : }
196 :
197 : struct QpAttr localQpAttr;
198 4 : s32 ret = RaGetQpAttr(qpHandle_, &localQpAttr);
199 4 : if (ret != 0) {
200 0 : HCCL_ERROR("[DevRdmaConnectionV2::%s]RaGetQpAttr failed, ret[%d]", __func__, ret);
201 0 : return HCCL_E_ROCE_CONNECT;
202 : }
203 4 : std::unique_ptr<ExchangeRdmaConnDto> dto= nullptr;
204 4 : EXCEPTION_CATCH(
205 : dto = std::make_unique<ExchangeRdmaConnDto>(localQpAttr.qpn, localQpAttr.psn, localQpAttr.gidIdx),
206 : return HCCL_E_PTR
207 : );
208 4 : CHK_SAFETY_FUNC_RET(memcpy_s(dto->gid_, HCCP_GID_RAW_LEN, localQpAttr.gid, HCCP_GID_RAW_LEN));
209 4 : locQpAttrserial = std::unique_ptr<Hccl::Serializable>(std::move(dto));
210 4 : return HCCL_SUCCESS;
211 4 : }
212 :
213 5 : HcclResult DevRdmaConnectionV2::ParseRmtExchangeDto(const Hccl::Serializable &rmtDto)
214 : {
215 5 : auto dto = dynamic_cast<const ExchangeRdmaConnDto &>(rmtDto);
216 5 : HCCL_INFO("[DevRdmaConnectionV2][%s] remoteConnDto[%s]", __func__, dto.Describe().c_str());
217 5 : rmtQpAttr_.psn = dto.psn_;
218 5 : rmtQpAttr_.qpn = dto.qpn_;
219 5 : rmtQpAttr_.gid_idx = dto.gid_idx_;
220 5 : CHK_SAFETY_FUNC_RET(memcpy_s(rmtQpAttr_.gid, HCCP_GID_RAW_LEN, dto.gid_, HCCP_GID_RAW_LEN));
221 5 : return HCCL_SUCCESS;
222 5 : }
223 :
224 1 : HcclResult DevRdmaConnectionV2::ModifyQp()
225 : {
226 1 : if (rdmaConnStatus_ == RdmaConnStatus::QP_MODIFIED) {
227 0 : HCCL_WARNING("[DevRdmaConnectionV2][%s] modify qp already, status[%s].",
228 : __func__, rdmaConnStatus_.Describe().c_str());
229 0 : return HCCL_SUCCESS;
230 : }
231 1 : if (rdmaConnStatus_ != RdmaConnStatus::QP_CREATED) {
232 0 : HCCL_ERROR("[DevRdmaConnectionV2][%s] status[%s] is not expected.", __func__,
233 : rdmaConnStatus_.Describe().c_str());
234 0 : return HCCL_E_AGAIN;
235 : }
236 :
237 1 : if (!rmtQpAttr_.IsValid()) {
238 0 : HCCL_ERROR("[DevRdmaConnectionV2][%s] romate Qp Attr is empty, exchange qp attr first", __func__);
239 0 : return HCCL_E_INTERNAL;
240 : }
241 :
242 : struct QpAttr localQpAttr;
243 1 : s32 ret = RaGetQpAttr(qpHandle_, &localQpAttr);
244 1 : if (ret != 0) {
245 0 : HCCL_ERROR("[DevRdmaConnectionV2::%s]RaGetQpAttr failed, ret[%d]", __func__, ret);
246 0 : return HCCL_E_ROCE_CONNECT;
247 : }
248 :
249 : struct TypicalQp localQp;
250 : struct TypicalQp rmtQp;
251 1 : localQp.sl = qpInfo_.serviceLevel;
252 1 : localQp.tc = qpInfo_.trafficClass;
253 1 : localQp.retryCnt = qpInfo_.retryCnt;
254 1 : localQp.retryTime = qpInfo_.retryInterval;
255 1 : localQp.qpn = localQpAttr.qpn;
256 1 : localQp.psn = localQpAttr.psn;
257 1 : localQp.gidIdx = localQpAttr.gidIdx;
258 1 : (void)memcpy_s(localQp.gid, HCCP_GID_RAW_LEN, localQpAttr.gid, HCCP_GID_RAW_LEN);
259 1 : rmtQp.sl = qpInfo_.serviceLevel;
260 1 : rmtQp.tc = qpInfo_.trafficClass;
261 1 : rmtQp.retryCnt = qpInfo_.retryCnt;
262 1 : rmtQp.retryTime = qpInfo_.retryInterval;
263 1 : rmtQp.qpn = rmtQpAttr_.qpn;
264 1 : rmtQp.psn = rmtQpAttr_.psn;
265 1 : rmtQp.gidIdx = rmtQpAttr_.gid_idx;
266 1 : (void)memcpy_s(rmtQp.gid, HCCP_GID_RAW_LEN, rmtQpAttr_.gid, HCCP_GID_RAW_LEN);
267 1 : ret = RaTypicalQpModify(qpHandle_, &localQp, &rmtQp);
268 1 : if (ret != 0) {
269 0 : HCCL_ERROR("[modify][ra_qp]modify qp failed, ret(%d)", ret);
270 0 : return HCCL_E_ROCE_CONNECT;
271 : }
272 1 : rdmaConnStatus_ = RdmaConnStatus::QP_MODIFIED;
273 1 : return HCCL_SUCCESS;
274 : }
275 :
276 9 : HcclResult DevRdmaConnectionV2::BuildSqContext(SqContext* context)
277 : {
278 9 : if (context == nullptr) {
279 0 : HCCL_ERROR("[GetSqContext] Invalid null pointer for context.");
280 0 : return HCCL_E_PTR;
281 : }
282 :
283 : // 零初始化roceSq, 确保不同dmaMode下未使用字段有确定值
284 9 : (void)memset_s(&context->contextInfo.roceSq, sizeof(context->contextInfo.roceSq), 0,
285 : sizeof(context->contextInfo.roceSq));
286 :
287 : struct QpAttr localQpAttr;
288 9 : s32 ret = RaGetQpAttr(qpHandle_, &localQpAttr);
289 9 : if (ret != 0) {
290 0 : HCCL_ERROR("[DevRdmaConnectionV2::%s]RaGetQpAttr failed, ret[%d]", __func__, ret);
291 0 : return HCCL_E_ROCE_CONNECT;
292 : }
293 9 : s32 mtuShift = localQpAttr.pathMtu - 1;
294 :
295 9 : context->type = SQ_CONTEXT_TYPE_ROCE;
296 9 : context->contextInfo.roceSq.qpn = localQpAttr.qpn;
297 9 : context->contextInfo.roceSq.sqVa = ndaQpInfo_.sqInfo.qBuf.base;
298 9 : context->contextInfo.roceSq.wqeSize = ndaQpInfo_.sqInfo.qBuf.entrySize;
299 9 : context->contextInfo.roceSq.depth = ndaQpInfo_.sqInfo.qBuf.entryCnt;
300 9 : context->contextInfo.roceSq.headAddr = reinterpret_cast<uint64_t >(SqPiMem_.ptr());
301 9 : context->contextInfo.roceSq.tailAddr = reinterpret_cast<uint64_t >(SqCiMem_.ptr());
302 9 : context->contextInfo.roceSq.sl = qpInfo_.serviceLevel;
303 9 : context->contextInfo.roceSq.dbHwVa = reinterpret_cast<uint64_t >(ndaQpInfo_.sqInfo.dbHwVa.iovBase);
304 :
305 9 : if (dmaMode_ == QBUF_DMA_MODE_INDEP_UB) {
306 0 : context->contextInfo.roceSq.dbSwVa = reinterpret_cast<uint64_t >(ndaQpInfo_.sqInfo.dbrPiVa.iovBase);
307 0 : context->contextInfo.roceSq.mtuShift = static_cast<uint8_t>(mtuShift);
308 : }
309 :
310 9 : HCCL_INFO(
311 : "[DevRdmaConnectionV2][%s] type=%u, QPN=%u, SQ_VA=0x%llx, WQE_SIZE=%u, "
312 : "SQ_DEPTH=%u, SQ_HEAD_ADDR=0x%llx, SQ_TAIL_ADDR=0x%llx, "
313 : "SL=%u, DB_HW_VA=0x%llx, DB_SW_VA=0x%llx, MTU_SHIFT=%u", __func__, context->type,
314 : context->contextInfo.roceSq.qpn, context->contextInfo.roceSq.sqVa, context->contextInfo.roceSq.wqeSize,
315 : context->contextInfo.roceSq.depth, context->contextInfo.roceSq.headAddr, context->contextInfo.roceSq.tailAddr,
316 : context->contextInfo.roceSq.sl, context->contextInfo.roceSq.dbHwVa,
317 : context->contextInfo.roceSq.dbSwVa, context->contextInfo.roceSq.mtuShift
318 : );
319 9 : return HCCL_SUCCESS;
320 : }
321 :
322 9 : HcclResult DevRdmaConnectionV2::BuildCqContext(CqContext* context)
323 : {
324 9 : if (context == nullptr) {
325 0 : HCCL_ERROR("[GetCqContext] Invalid null pointer for context.");
326 0 : return HCCL_E_PTR;
327 : }
328 :
329 : // 零初始化roceCq, 确保不同dmaMode下未使用字段有确定值
330 9 : (void)memset_s(&context->contextInfo.roceCq, sizeof(context->contextInfo.roceCq), 0,
331 : sizeof(context->contextInfo.roceCq));
332 :
333 9 : context->type = CQ_CONTEXT_TYPE_ROCE;
334 9 : context->contextInfo.roceCq.cqVa = ndaCqInfo_.cqInfo.qBuf.base;
335 9 : context->contextInfo.roceCq.cqeSize = ndaCqInfo_.cqInfo.qBuf.entrySize;
336 9 : context->contextInfo.roceCq.cqDepth = ndaCqInfo_.cqInfo.qBuf.entryCnt;
337 9 : context->contextInfo.roceCq.headAddr = reinterpret_cast<uint64_t >(CqPiMem_.ptr());
338 9 : context->contextInfo.roceCq.tailAddr = reinterpret_cast<uint64_t >(CqCiMem_.ptr());
339 : // PCIe模式(DEFAULT): 仅使用硬DB; UBNIC模式(INDEP_UB): 仅使用软DB
340 9 : if (dmaMode_ == QBUF_DMA_MODE_DEFAULT) {
341 9 : context->contextInfo.roceCq.cqn = ndaCqInfo_.resv[0]; // 云脉网卡NDA直驱，协商ndaCqInfo_.resv[0]字段为CQN
342 9 : context->contextInfo.roceCq.dbHwVa = reinterpret_cast<uint64_t >(ndaCqInfo_.cqInfo.dbHwVa.iovBase);
343 : } else {
344 0 : context->contextInfo.roceCq.cqn = DEFAULT_CQN;
345 0 : context->contextInfo.roceCq.dbSwVa = reinterpret_cast<uint64_t >(ndaCqInfo_.cqInfo.dbrCiVa.iovBase);
346 : }
347 :
348 9 : HCCL_INFO(
349 : "[DevRdmaConnectionV2][%s] type=%u, CQN=%u, CQ_VA=0x%llx, CQE_SIZE=%u, CQ_DEPTH=%u, "
350 : "CQ_HEAD_ADDR=0x%llx, CQ_TAIL_ADDR=0x%llx, DB_HW_VA=0x%llx, DB_SW_VA=0x%llx]",
351 : __func__, context->type,
352 : context->contextInfo.roceCq.cqn, context->contextInfo.roceCq.cqVa, context->contextInfo.roceCq.cqeSize,
353 : context->contextInfo.roceCq.cqDepth, context->contextInfo.roceCq.headAddr, context->contextInfo.roceCq.tailAddr,
354 : context->contextInfo.roceCq.dbHwVa, context->contextInfo.roceCq.dbSwVa
355 : );
356 :
357 9 : return HCCL_SUCCESS;
358 : }
359 :
360 4 : std::vector<char> DevRdmaConnectionV2::GetSqUniqueId() const
361 : {
362 4 : HCCL_DEBUG("start packing sq uniqueId");
363 : struct QpAttr localQpAttr;
364 4 : s32 ret = RaGetQpAttr(qpHandle_, &localQpAttr);
365 4 : if (ret != 0) {
366 0 : HCCL_ERROR("[DevRdmaConnectionV2::%s]RaGetQpAttr failed, ret[%d]", __func__, ret);
367 0 : return {};
368 : }
369 4 : s32 mtuShift = localQpAttr.pathMtu - 1;
370 :
371 4 : Hccl::BinaryStream binaryStream;
372 : // 打包1825网卡NDA直驱资源
373 4 : binaryStream << localQpAttr.qpn;
374 4 : binaryStream << ndaQpInfo_.sqInfo.qBuf.base;
375 4 : binaryStream << ndaQpInfo_.sqInfo.qBuf.entrySize;
376 4 : binaryStream << ndaQpInfo_.sqInfo.qBuf.entryCnt;
377 4 : binaryStream << reinterpret_cast<uint64_t >(SqPiMem_.ptr());
378 4 : binaryStream << reinterpret_cast<uint64_t >(SqCiMem_.ptr());
379 4 : binaryStream << reinterpret_cast<uint64_t >(ndaQpInfo_.sqInfo.dbHwVa.iovBase);
380 4 : binaryStream << reinterpret_cast<uint64_t >(ndaQpInfo_.sqInfo.dbrPiVa.iovBase);
381 4 : binaryStream << static_cast<uint8_t>(qpInfo_.serviceLevel);
382 4 : binaryStream << static_cast<uint8_t>(mtuShift);
383 :
384 4 : std::vector<char> result;
385 4 : binaryStream.Dump(result);
386 4 : return result;
387 4 : }
388 :
389 4 : std::vector<char> DevRdmaConnectionV2::GetCqUniqueId() const
390 : {
391 4 : HCCL_DEBUG("start packing cq uniqueId");
392 4 : Hccl::BinaryStream binaryStream;
393 : // 打包1825网卡NDA直驱资源
394 4 : binaryStream << DEFAULT_CQN;
395 4 : binaryStream << ndaCqInfo_.cqInfo.qBuf.base;
396 4 : binaryStream << ndaCqInfo_.cqInfo.qBuf.entrySize;
397 4 : binaryStream << ndaCqInfo_.cqInfo.qBuf.entryCnt;
398 4 : binaryStream << reinterpret_cast<uint64_t >(CqPiMem_.ptr());
399 4 : binaryStream << reinterpret_cast<uint64_t >(CqCiMem_.ptr());
400 4 : binaryStream << reinterpret_cast<uint64_t >(ndaCqInfo_.cqInfo.dbrCiVa.iovBase);
401 :
402 4 : std::vector<char> result;
403 4 : binaryStream.Dump(result);
404 4 : return result;
405 4 : }
406 :
407 4 : std::vector<char> DevRdmaConnectionV2::GetUniqueId() const
408 : {
409 4 : HCCL_DEBUG("start packing conn uniqueId");
410 4 : Hccl::BinaryStream binaryStream;
411 4 : binaryStream << dmaMode_;
412 4 : binaryStream << GetSqUniqueId();
413 4 : binaryStream << GetCqUniqueId();
414 :
415 4 : std::vector<char> result;
416 4 : binaryStream.Dump(result);
417 4 : return result;
418 4 : }
419 :
420 : } // namespace hcomm
|
