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 : #ifndef HCCLV2_ADAPTER_HCCP_H
12 : #define HCCLV2_ADAPTER_HCCP_H
13 : #include <vector>
14 : #include <unordered_set>
15 : #include "hccp_common.h"
16 : #include "ip_address.h"
17 : #include "data_type.h"
18 : #include "reduce_op.h"
19 : #include "hccp_tlv.h"
20 : #include <mutex>
21 : #include "hccp_async_ctx.h"
22 : #include "hccp_nda.h"
23 :
24 : namespace Hccl {
25 : using namespace std;
26 :
27 : /// 与 `Hccl::UB_QOS_DEFAULT`（legacy/framework/env_config/env_config_v2.h）及 Next `EnvConfig::UB_QOS_DEFAULT`
28 : /// 数值一致； 本头文件不 include env_config，避免经 base_config_legacy.h 拉入 dma_mode.h 导致 platform
29 : /// 等目标缺头编译失败。
30 : constexpr u32 kRaUbGetTpInfoParamDefaultQos = 4U;
31 :
32 : /// 单次向管控面查询 TP 列表条数上限（异步接口传入/返回 num；与 buffer 中 HccpTpInfo 条数一致）。
33 : constexpr uint32_t TP_HANDLE_REQUEST_NUM = 1U;
34 :
35 : constexpr u32 DEFAULT_INIT_PHY_ID = 0;
36 : constexpr u32 DEFAULT_INIT_NIC_POS = 0;
37 : constexpr u32 DEFAULT_HDC_TYPE = 6;
38 : constexpr u32 PID_HDC_TYPE = 18;
39 :
40 : constexpr u32 SOCKET_NOT_CONNECTED = 0;
41 : constexpr u32 SOCKET_CONNECTED = 1;
42 : constexpr u32 SOCKET_CONNECT_TIMEOUT = 2;
43 : constexpr u32 SOCKET_CONNECTING = 3;
44 :
45 : // QP CQ default attr
46 : constexpr u32 DEFAULT_OPBASE_MAX_SEND_WR = 32768;
47 : constexpr u32 DEFAULT_OFFLINE_MAX_SEND_WR = 128;
48 : constexpr u32 DEFAULT_MAX_RECV_WR = 128;
49 : constexpr u32 DEFAULT_MAX_SEND_SGE = 1;
50 : constexpr u32 DEFAULT_MAX_RECV_SGE = 1;
51 : constexpr u32 DEFAULT_MAX_SEND_CQ_DEPTH = 32768;
52 : constexpr u32 DEFAULT_MAX_RECV_CQ_DEPTH = 128;
53 : constexpr u32 DEFAULT_MAX_INLINE_DATA = 32;
54 : constexpr u32 HETEROG_OFFLINE_EXT_MAX_SEND_WR = 512;
55 :
56 : // 适配URMA，直接组装WQE的TOKENID需要进行移位，包括CCU与AICPU
57 : constexpr u32 URMA_TOKEN_ID_RIGHT_SHIFT = 8;
58 :
59 : // HCCL 默认无效端口号
60 : constexpr u32 HCCL_INVALID_PORT = 65536;
61 :
62 : using RdmaHandle = void*;
63 : using QpHandle = void*;
64 : using CqHandle = void*;
65 :
66 : using SocketHandle = void*;
67 : using FdHandle = void*;
68 :
69 : using MrHandle = void*;
70 :
71 678 : MAKE_ENUM(HrtNetworkMode, PEER, HDC)
72 : enum class DeviceIdType { DEVICE_ID_TYPE_PHY_ID = 0, DEVICE_ID_TYPE_SDID };
73 :
74 : inline s32 EnvLinkTimeoutGet();
75 :
76 : struct HRaInitConfig {
77 : HrtNetworkMode mode;
78 : uint32_t phyId;
79 : uint32_t hdcType{DEFAULT_HDC_TYPE};
80 : };
81 :
82 : void HrtRaInit(HRaInitConfig& cfg);
83 : void HrtRaDeInit(HRaInitConfig& cfg);
84 :
85 : struct HRaTlvInitConfig {
86 : HrtNetworkMode mode;
87 : uint32_t phyId;
88 : int32_t version;
89 : };
90 :
91 : void* HrtRaTlvInit(HRaTlvInitConfig& cfg);
92 : HcclResult HrtRaTlvRequest(void* tlv_handle, u32 tlv_module_type, u32 tlv_ccu_msg_type);
93 : void HrtRaTlvRequestForCustomChannel(void* tlvHandle, u32 msgType, void* customIn, void* customOut);
94 : void HrtRaTlvDeInit(void* tlv_handle);
95 :
96 : u32 HrtRaGetInterfaceVersion(u32 phyId, u32 interfaceOpcode);
97 :
98 : enum class TlsStatus : int {
99 : UNKNOWN = -1, // 不支持查询
100 : DISABLE = 0, // 未使能
101 : ENABLE, // 使能
102 : };
103 :
104 : HcclResult HrtRaGetTlsStatus(struct RaInfo* info, TlsStatus& tlsStatus);
105 :
106 : struct RaInterface {
107 : uint32_t phyId;
108 : IpAddress address;
109 : };
110 :
111 : SocketHandle HrtRaSocketInit(HrtNetworkMode netMode, RaInterface& in);
112 : void HrtRaSocketDeInit(SocketHandle socketHandle);
113 :
114 : struct RaSocketListenParam {
115 : SocketHandle socketHandle; /**< socket handle */
116 : unsigned int port; /**< Socket listening port number */
117 : IpAddress localIp; /**< local IP address */
118 26 : RaSocketListenParam(SocketHandle handle, u32 port, IpAddress ip) : socketHandle(handle), port(port), localIp(ip) {}
119 : };
120 :
121 : using QpConfig = struct QpConfigDef {
122 : IpAddress selfIp;
123 : IpAddress peerIp;
124 : u32 maxWr;
125 : u32 maxSendSge;
126 : u32 maxRecvSge;
127 : s32 sqEvent;
128 : s32 rqEvent;
129 :
130 : QpConfigDef(
131 : IpAddress& selfIp, IpAddress& peerIp, u32 maxWr, u32 maxSendSge, u32 maxRecvSge, s32 sqEvent, s32 rqEvent)
132 : : selfIp(selfIp),
133 : peerIp(peerIp),
134 : maxWr(maxWr),
135 : maxSendSge(maxSendSge),
136 : maxRecvSge(maxRecvSge),
137 : sqEvent(sqEvent),
138 : rqEvent(rqEvent)
139 : {}
140 0 : QpConfigDef(u32 maxWr, u32 maxSendSge, u32 maxRecvSge, s32 sqEvent, s32 rqEvent)
141 0 : : maxWr(maxWr),
142 0 : maxSendSge(maxSendSge),
143 0 : maxRecvSge(maxRecvSge),
144 0 : sqEvent(sqEvent),
145 0 : rqEvent(rqEvent)
146 0 : {}
147 101 : QpConfigDef() : maxWr(0), maxSendSge(0), maxRecvSge(0), sqEvent(0), rqEvent(0) {}
148 : };
149 :
150 : using QpInfo = struct QpInfoDef {
151 : QpConfig attr;
152 : RdmaHandle rdmaHandle;
153 : QpHandle qpHandle;
154 : struct ibv_qp* qp;
155 : void* context;
156 : struct ibv_cq* sendCq;
157 : struct ibv_cq* recvCq;
158 : struct ibv_srq* srq;
159 : struct ibv_cq* srqCq;
160 : void* srqContext;
161 : struct ibv_comp_channel* sendChannel;
162 : struct ibv_comp_channel* recvChannel;
163 : s32 flag = 0;
164 : s32 qpMode = 0;
165 : u32 trafficClass = 0;
166 : u32 serviceLevel = 0;
167 : u32 retryCnt = 0;
168 : u32 retryInterval = 0;
169 : s32 lbValue = -1; // 支持负载均衡（lbmax > 0）的网卡才会更新该值
170 : u32 udpSport = 0;
171 101 : QpInfoDef()
172 202 : : rdmaHandle(nullptr),
173 101 : qpHandle(nullptr),
174 101 : qp(nullptr),
175 101 : context(nullptr),
176 101 : sendCq(nullptr),
177 101 : recvCq(nullptr),
178 101 : srq(nullptr),
179 101 : srqCq(nullptr),
180 101 : srqContext(nullptr),
181 101 : sendChannel(nullptr),
182 101 : recvChannel(nullptr),
183 101 : trafficClass(HCCL_COMM_TRAFFIC_CLASS_CONFIG_NOT_SET),
184 101 : serviceLevel(HCCL_COMM_SERVICE_LEVEL_CONFIG_NOT_SET)
185 101 : {}
186 : QpInfoDef(
187 : QpConfig attr, RdmaHandle rdmaHandle, QpHandle qpHandle, struct ibv_qp* qp, void* context,
188 : struct ibv_cq* sendCq, struct ibv_cq* recvCq, struct ibv_srq* srq, struct ibv_cq* srqCq,
189 : void* srqContext = nullptr, struct ibv_comp_channel* sendChannel = nullptr,
190 : struct ibv_comp_channel* recvChannel = nullptr, u32 tc = HCCL_COMM_TRAFFIC_CLASS_CONFIG_NOT_SET,
191 : u32 sl = HCCL_COMM_SERVICE_LEVEL_CONFIG_NOT_SET)
192 : : attr(attr),
193 : rdmaHandle(rdmaHandle),
194 : qpHandle(qpHandle),
195 : qp(qp),
196 : context(context),
197 : sendCq(sendCq),
198 : recvCq(recvCq),
199 : srq(srq),
200 : srqCq(srqCq),
201 : srqContext(srqContext),
202 : sendChannel(sendChannel),
203 : recvChannel(recvChannel),
204 : trafficClass(tc),
205 : serviceLevel(sl)
206 : {}
207 : };
208 :
209 : using CqInfo = struct CqInfoDef {
210 : struct ibv_cq* sq;
211 : struct ibv_cq* rq;
212 : void* context;
213 : u32 depth;
214 : u32 used;
215 : s32 sqEvent;
216 : s32 rqEvent;
217 : void* srqContext;
218 : struct ibv_comp_channel* sendChannel;
219 : struct ibv_comp_channel* recvChannel;
220 : std::vector<QpInfo> qps;
221 0 : CqInfoDef()
222 0 : : sq(nullptr),
223 0 : rq(nullptr),
224 0 : context(nullptr),
225 0 : depth(0),
226 0 : used(0),
227 0 : sqEvent(-1),
228 0 : rqEvent(-1),
229 0 : srqContext(nullptr),
230 0 : sendChannel(nullptr),
231 0 : recvChannel(nullptr)
232 0 : {}
233 0 : CqInfoDef(
234 : struct ibv_cq* sq, struct ibv_cq* rq, void* context, u32 depth, s32 sqEvent, s32 rqEvent,
235 : void* srqContext = nullptr, struct ibv_comp_channel* sendChannel = nullptr,
236 : struct ibv_comp_channel* recvChannel = nullptr)
237 0 : : sq(sq),
238 0 : rq(rq),
239 0 : context(context),
240 0 : depth(depth),
241 0 : used(0),
242 0 : sqEvent(sqEvent),
243 0 : rqEvent(rqEvent),
244 0 : srqContext(srqContext),
245 0 : sendChannel(sendChannel),
246 0 : recvChannel(recvChannel)
247 0 : {}
248 : };
249 :
250 : void HrtRaSocketListenOneStart(RaSocketListenParam& in, HrtNetworkMode netMode);
251 : void HrtRaSocketListenOneStop(RaSocketListenParam& in);
252 : bool HrtRaSocketTryListenOneStart(RaSocketListenParam& in, HrtNetworkMode netMode);
253 :
254 : void HrtRaSocketSetWhiteListStatus(u32 enable);
255 : u32 HrtRaSocketGetWhiteListStatus();
256 :
257 : struct RaSocketWhitelist {
258 : IpAddress remoteIp; /**< IP address of remote */
259 : uint32_t connLimit; /**< limit of whilte list */
260 : std::string tag;
261 : };
262 :
263 : void HrtRaSocketWhiteListAdd(SocketHandle socketHandle, vector<RaSocketWhitelist>& wlists);
264 : void HrtRaSocketWhiteListDel(SocketHandle socketHandle, vector<RaSocketWhitelist>& wlists);
265 : void HrtRaSocketGetVnicIpInfos(u32 phyId, DeviceIdType deviceIdType, u32 deviceId, IpAddress& vnicIP);
266 :
267 : struct RaSocketConnectParam {
268 : SocketHandle socketHandle; /**< socket handle */
269 : IpAddress remoteIp; /**< IP address of remote socket, [0-7] is reserved for vnic */
270 : unsigned int port; /**< Socket listening port number */
271 : std::string tag;
272 6 : RaSocketConnectParam(SocketHandle handle, IpAddress& remoteIp, u32 port, const std::string& tag)
273 6 : : socketHandle(handle),
274 6 : remoteIp(remoteIp),
275 6 : port(port),
276 6 : tag(tag)
277 6 : {}
278 : };
279 :
280 : struct RaSocketCloseParam {
281 : SocketHandle socketHandle;
282 : FdHandle fdHandle;
283 16 : RaSocketCloseParam(SocketHandle socketHandle, FdHandle fdHandle) : socketHandle(socketHandle), fdHandle(fdHandle) {}
284 : };
285 :
286 : void HrtRaSocketConnectOne(RaSocketConnectParam& in);
287 : void HrtRaSocketCloseOne(RaSocketCloseParam& in);
288 :
289 : struct RaSocketGetParam {
290 : SocketHandle socketHandle; /**< socket handle */
291 : IpAddress remoteIp; /**< IP address of remote socket */
292 : std::string tag;
293 : FdHandle fdHandle;
294 21 : RaSocketGetParam(SocketHandle handle, IpAddress& remoteIp, const std::string& tag, FdHandle fdHandle)
295 21 : : socketHandle(handle),
296 21 : remoteIp(remoteIp),
297 21 : tag(tag),
298 21 : fdHandle(fdHandle)
299 21 : {}
300 : };
301 :
302 : struct RaSocketFdHandleParam {
303 : FdHandle fdHandle; /**< fd handle */
304 : int status; /**< socket status:0 not connected 1:connected 2:connect timeout 3:connecting */
305 40 : RaSocketFdHandleParam(FdHandle fdHandle, int status) : fdHandle(fdHandle), status(status) {}
306 : };
307 : RaSocketFdHandleParam HrtRaBlockGetOneSocket(u32 role, RaSocketGetParam& param, u32 timeout = 0);
308 :
309 : void HrtRaSocketBlockSend(const FdHandle fdHandle, const void* data, u32 sendSize);
310 : bool HrtRaSocketNonBlockSend(const FdHandle fdHandle, void* data, u64 size, u64* sentSize);
311 : void HrtRaSocketBlockRecv(const FdHandle fdHandle, void* data, u32 size);
312 : HcclResult HrtRaSocketNonBlockSendHeart(const FdHandle fdHandle, void* data, u64 size, u64* sentSize);
313 : HcclResult HrtRaSocketNonBlockRecvHeart(const FdHandle fdHandle, void* data, u64 size, u64* recvSize);
314 :
315 : vector<std::pair<std::string, IpAddress>> HrtGetHostIf(u32 devPhyId);
316 : vector<IpAddress> HrtGetDeviceIp(u32 devicePhyId, NetworkMode netWorkMode = NetworkMode::NETWORK_OFFLINE);
317 :
318 : constexpr u32 RDMA_MEM_KEY_MAX_LEN = 64; // 最大的memKey长度
319 : constexpr u32 RDMA_MEM_KEY_LEN_ROCE = 4; // 暂定ROCE k的ey长度为4， 未来从HCCP新接口获取key真实长度
320 :
321 : RdmaHandle HrtRaRdmaInit(HrtNetworkMode netMode, RaInterface& in);
322 : void HrtRaRdmaDeInit(RdmaHandle rdmaHandle, HrtNetworkMode netMode);
323 :
324 : void HrtRaGetNotifyBaseAddr(RdmaHandle rdmaHandle, u64* va, u64* size);
325 :
326 : constexpr s32 QP_FLAG_RC = 0; // flag: 0 = RC, 1= UD，其它预留
327 : constexpr s32 OFFLINE_QP_MODE = 1; // 下沉模式的QP(80)
328 : constexpr s32 OPBASE_QP_MODE = 2; // 单算子模式的QP(80)
329 : constexpr s32 OFFLINE_QP_MODE_EXT = 3; // 下沉模式(81)QP
330 : constexpr s32 OPBASE_QP_MODE_EXT = 4; // 单算子模式(81)的QP
331 :
332 : QpHandle HrtRaQpCreate(RdmaHandle rdmaHandle, int flag, int qpMode);
333 :
334 : void HrtRaQpDestroy(QpHandle qpHandle);
335 : void HrtRaQpConnectAsync(QpHandle qpHandle, FdHandle fdHandle);
336 : int HrtGetRaQpStatus(QpHandle qpHandle);
337 :
338 : struct RaMrInfo {
339 : void* addr; /**< starting address of mr */
340 : unsigned long long size; /**< size of mr */
341 : int access; /**< access of mr, reference to ra_access_flags */
342 : unsigned int lkey; /**< local addr access key */
343 : };
344 :
345 : void HrtRaMrReg(QpHandle qpHandle, RaMrInfo& info);
346 : void HrtRaMrDereg(QpHandle qpHandle, RaMrInfo& info);
347 :
348 : struct HRaSendWr {
349 : uint64_t locAddr; /**< address of buf */
350 : uint32_t len; /**< len of buf */
351 : uint64_t rmtAddr; /**< destination address */
352 : uint32_t op; /**< operations of RDMA supported:RDMA_WRITE:0 */
353 : int sendFlag; /**< reference to ra_send_flags */
354 3 : HRaSendWr(uint64_t locAddr, uint32_t len, uint64_t rmtAddr, uint32_t op, int sendFlag)
355 3 : : locAddr(locAddr),
356 3 : len(len),
357 3 : rmtAddr(rmtAddr),
358 3 : op(op),
359 3 : sendFlag(sendFlag)
360 3 : {}
361 : };
362 :
363 : struct RaSendWrResp {
364 : unsigned int sqIndex; /**< index of sq */
365 : unsigned int wqeIndex; /**< index of wqe */
366 : unsigned int dbIndex; /**< index of db */
367 : unsigned long dbInfo; /**< db content */
368 3 : RaSendWrResp(unsigned int sqIndex, unsigned int wqeIndex, unsigned int dbIndex, unsigned long dbInfo)
369 3 : : sqIndex(sqIndex),
370 3 : wqeIndex(wqeIndex),
371 3 : dbIndex(dbIndex),
372 3 : dbInfo(dbInfo)
373 3 : {}
374 : };
375 :
376 : RaSendWrResp HrtRaSendOneWr(QpHandle qpHandle, HRaSendWr& in);
377 :
378 : string HrtRaGetKeyDescribe(const u8* key, u32 len);
379 :
380 : using LocMemHandle = u64;
381 : using RemMemHandle = u64;
382 : using JfcHandle = u64;
383 : using JettyHandle = u64;
384 : using TargetJettyHandle = u64;
385 : using NotifyHandle = u64;
386 : using TokenIdHandle = u64;
387 :
388 : using HrtRaUbCtxInitParam = struct HrtRaUbCtxInitParamDef {
389 : HrtNetworkMode mode;
390 : u32 phyId;
391 : const IpAddress& addr;
392 30 : HrtRaUbCtxInitParamDef(HrtNetworkMode mode, u32 phyId, const IpAddress& addr) : mode(mode), phyId(phyId), addr(addr)
393 30 : {}
394 : };
395 :
396 : RdmaHandle HrtRaUbCtxInit(const HrtRaUbCtxInitParam& in);
397 :
398 : void HrtRaUbCtxDestroy(RdmaHandle handle);
399 :
400 : std::pair<TokenIdHandle, uint32_t> RaUbAllocTokenIdHandle(RdmaHandle handle);
401 : void RaUbFreeTokenIdHandle(RdmaHandle handle, TokenIdHandle tokenIdHandle);
402 :
403 : using HrtRaUbLocMemRegParam = struct HrtRaUbLocalMemRegParamDef {
404 : u64 addr;
405 : u64 size;
406 : u32 tokenValue;
407 : TokenIdHandle tokenIdHandle;
408 : u32 nonPin{1}; // 1: 寄存器(notify和cntNotify、CCU), 0: Memory(rtMalloc)
409 641 : HrtRaUbLocalMemRegParamDef(u64 addr, u64 size, u32 tokenValue, TokenIdHandle tokenIdHandle, u32 nonPin = 1)
410 641 : : addr(addr),
411 641 : size(size),
412 641 : tokenValue(tokenValue),
413 641 : tokenIdHandle(tokenIdHandle),
414 641 : nonPin(nonPin)
415 641 : {}
416 : };
417 :
418 : constexpr u32 HRT_UB_MEM_KEY_MAX_LEN = 64; // UB 最大的memKey长度
419 :
420 : using HrtRaUbLocalMemRegOutParam = struct HrtRaUbLocMemHandleParamDef {
421 : LocMemHandle handle{0};
422 : u8 key[HRT_UB_MEM_KEY_MAX_LEN]{};
423 : u32 tokenId{0};
424 : u64 targetSegVa{0};
425 : u32 keySize{0};
426 : };
427 :
428 : HrtRaUbLocalMemRegOutParam HrtRaUbLocalMemReg(RdmaHandle handle, const HrtRaUbLocMemRegParam& in);
429 :
430 : std::pair<u64, u64> BufAlign(u64 addr, u64 size);
431 :
432 : void HrtRaUbLocalMemUnreg(RdmaHandle rdmaHandle, LocMemHandle lmemHandle);
433 :
434 : using HrtRaUbRemMemImportedOutParam = struct HrtRaUbRemMemHandleParamDef {
435 : RemMemHandle handle{0};
436 : u64 targetSegVa{0};
437 : };
438 :
439 : HrtRaUbRemMemImportedOutParam HrtRaUbRemoteMemImport(RdmaHandle handle, u8* key, u32 keyLen, u32 tokenValue);
440 :
441 : void HrtRaUbRemoteMemUnimport(RdmaHandle rdmaHandle, RemMemHandle rmemHandle);
442 :
443 6239 : MAKE_ENUM(HrtUbJfcMode, NORMAL, STARS_POLL, CCU_POLL, USER_CTL)
444 :
445 : struct CqCreateInfo {
446 : uint64_t va;
447 : uint32_t id;
448 : uint64_t bufAddr;
449 : uint32_t cqeSize;
450 : uint32_t cqDepth;
451 : uint64_t swdbAddr;
452 : };
453 :
454 : JfcHandle HrtRaUbCreateJfc(RdmaHandle handle, CqCreateInfo& cqInfo, HrtUbJfcMode mode);
455 :
456 : JfcHandle HrtRaUbCreateJfcUserCtl(RdmaHandle handle, CqCreateInfo& cqInfo);
457 :
458 : void HrtRaUbDestroyJfc(RdmaHandle handle, JfcHandle jfcHandle);
459 :
460 2040 : MAKE_ENUM(HrtTransportMode, RM);
461 2743 : MAKE_ENUM(TpProtocol, CTP, TP, UBOE, UB_RTP);
462 :
463 : // STANDARD: URMA标准CreateJetty
464 : // HOST_OFFLOAD: HOST侧展开下沉算子，需要指定sqeBbNum
465 : // HOST_OPBASE: Host展开单算子，需要指定sqeBbNum,
466 : // DEV_USED: 在Dev的APICPU展开算子，STARS不能使用UB DirectWQE的task，可以使用UB DbSend task，不需要指定sqeBbNum
467 : // CACHE_LOCK_DWQE: 该模式下， STARS仅能使用UB DirectWQE的task，不能使用UB DbSend task,，需要指定sqeBbNum
468 : // CCU_CCUM_CACHE: 不需要指定sqeBbNum
469 2839 : MAKE_ENUM(HrtJettyMode, STANDARD, HOST_OFFLOAD, HOST_OPBASE, DEV_USED, CACHE_LOCK_DWQE, CCU_CCUM_CACHE)
470 : using HrtRaUbCreateJettyParam = struct HrtRaUbJettyCreateParamDef {
471 : JfcHandle sjfcHandle{0};
472 : JfcHandle rjfcHandle{0};
473 :
474 : // CCU的DB需要注册，填写tokenValue
475 : u32 tokenValue{0};
476 : TokenIdHandle tokenIdHandle{0};
477 :
478 : HrtJettyMode jettyMode{HrtJettyMode::STANDARD};
479 :
480 : // 如果jettyId为0，则代表UB自行申请jetty,如果jettyId不为0，则代表使用预留jetty id
481 : // [1024, 1024 +127]为ccuJetty预留的id
482 : // [1024 + 192, 1024 + 192 + 4K - 1]为starsJetty预留的id
483 : u32 jettyId{0};
484 :
485 : // 指定内存，需要填写的参数，CCU类型需要填写,即HrtJettyMode::CCU_CCUM_CACHE
486 : u64 sqBufVa{0};
487 : u32 sqBufSize{0};
488 : // 指定sqeBB资源起始id，当前预留
489 : u32 sqeBufIndex{0};
490 :
491 : // HOST_OFFLOAD / HOST_OPBASE / CACHE_LOCK_DWQE 类型的Jetty ，需要指定WQEBB的数目
492 : // STADARD 类型Jetty，该参数代表SQ深度
493 : u32 sqDepth{0};
494 : /// UB Jetty priority（低 4bit）；GetQpCreateAttr 写入 attr.ub.priority
495 : u8 qos{2};
496 : u32 rqDepth{64};
497 : HrtTransportMode transMode{HrtTransportMode::RM}; // 仅能使用RM模式的Jetty
498 : u8 errTimeout{16};
499 :
500 808 : HrtRaUbJettyCreateParamDef() {}
501 :
502 954 : HrtRaUbJettyCreateParamDef(
503 : JfcHandle sjfcHandle, JfcHandle rjfcHandle, u32 tokenValue, TokenIdHandle tokenIdHandle, HrtJettyMode jettyMode,
504 : u32 jettyId, u64 sqBufVa, u32 sqBufSize, u32 sqeBufIndex, u32 sqDepth, u8 errTimeout = 16)
505 954 : : sjfcHandle(sjfcHandle),
506 954 : rjfcHandle(rjfcHandle),
507 954 : tokenValue(tokenValue),
508 954 : tokenIdHandle(tokenIdHandle),
509 954 : jettyMode(jettyMode),
510 954 : jettyId(jettyId),
511 954 : sqBufVa(sqBufVa),
512 954 : sqBufSize(sqBufSize),
513 954 : sqeBufIndex(sqeBufIndex),
514 954 : sqDepth(sqDepth),
515 954 : errTimeout(errTimeout)
516 954 : {}
517 : };
518 :
519 : constexpr u32 HRT_UB_QP_KEY_MAX_LEN = 64; // UB 最大的QpKey长度
520 :
521 : using HrtRaUbJettyCreatedOutParam = struct HrtRaUbJettyCreatedOutParamDef {
522 : JettyHandle handle{0};
523 : u8 key[HRT_UB_QP_KEY_MAX_LEN]{0};
524 : u64 jettyVa{0};
525 : u32 uasid{0};
526 : u32 id{0};
527 : u32 keySize{0};
528 : u64 dbVa{0};
529 : u32 dbTokenId{0};
530 : uint64_t sqBuffVa{0}; // 适配HCCP修改，jettybufva由HCCP提供，不再由HCCL分配
531 : };
532 :
533 : HrtRaUbJettyCreatedOutParam HrtRaUbCreateJetty(RdmaHandle handle, const HrtRaUbCreateJettyParam& in);
534 :
535 : void HrtRaUbDestroyJetty(JettyHandle jettyHandle);
536 :
537 : struct JettyImportCfg {
538 : u64 localTpHandle{0};
539 : u64 remoteTpHandle{0};
540 : u64 localTag{0}; // tag是hccp预留字段，暂不需要赋值
541 : u32 localPsn{0};
542 : u32 remotePsn{0};
543 : TpProtocol protocol{TpProtocol::INVALID};
544 : };
545 :
546 : using HrtRaUbJettyImportedInParam = struct HrtRaUbJettyImportedInParamDef {
547 : u8* key{nullptr};
548 : u32 keyLen{0};
549 : u32 tokenValue{0};
550 : JettyImportCfg jettyImportCfg{};
551 : };
552 :
553 : using HrtRaUbJettyImportedOutParam = struct HrtRaUbJettyImportedOutParamDef {
554 : TargetJettyHandle handle{0};
555 : u64 targetJettyVa{0};
556 : u32 tpn{0};
557 : };
558 :
559 : HrtRaUbJettyImportedOutParam RaUbImportJetty(RdmaHandle handle, u8* key, u32 keyLen, u32 tokenValue);
560 : HrtRaUbJettyImportedOutParam
561 : RaUbTpImportJetty(RdmaHandle handle, u8* key, u32 keyLen, u32 tokenValue, const JettyImportCfg& jettyImportCfg);
562 :
563 : void HrtRaUbUnimportJetty(RdmaHandle handle, TargetJettyHandle targetJettyHandle);
564 :
565 : void HrtRaUbJettyBind(JettyHandle jettyHandle, TargetJettyHandle targetJettyHandle);
566 :
567 : void HrtRaUbJettyUnbind(JettyHandle jettyHandle);
568 :
569 : // 参照hccp做opcode定义
570 739 : MAKE_ENUM(HrtUbSendWrOpCode, WRITE, WRITE_WITH_NOTIFY, READ, NOP)
571 :
572 : using HrtRaUbSendWrReqParam = struct HrtRaUbSendWrParamDef {
573 : HrtUbSendWrOpCode opcode;
574 : bool cqeEn{true};
575 :
576 : bool inlineFlag{false};
577 : u8* inlineData;
578 :
579 : bool inlineReduceFlag{false};
580 : DataType dataType;
581 : ReduceOp reduceOp;
582 :
583 : u64 notifyData;
584 : u64 notifyAddr;
585 : NotifyHandle notifyHandle;
586 :
587 : u64 localAddr;
588 : u64 remoteAddr;
589 : u32 size;
590 :
591 : LocMemHandle lmemHandle;
592 : RemMemHandle rmemHandle;
593 :
594 : TargetJettyHandle handle; // valid when RM mode
595 : };
596 :
597 : using HrtRaUbSendWrRespParam = struct HrtRaUbDbInfoParamDef {
598 : u32 jettyId{0};
599 : u32 funcId{0};
600 : u32 dieId{0};
601 : u32 piVal{0};
602 : u8 dwqe[128]{0};
603 : u32 dwqeSize{0};
604 : };
605 :
606 : HrtRaUbSendWrRespParam HrtRaUbPostSend(JettyHandle jettyHandle, HrtRaUbSendWrReqParam& in);
607 : void HrtRaUbPostNops(JettyHandle jettyHandle, JettyHandle remoteJettyHandle, const u32 numNop);
608 :
609 : std::pair<uint32_t, uint32_t> HraGetDieAndFuncId(RdmaHandle handle);
610 : bool HraGetRtpEnable(RdmaHandle handle);
611 :
612 : struct HRaInfo {
613 : HrtNetworkMode mode;
614 : uint32_t phyId;
615 24 : HRaInfo(HrtNetworkMode mode, uint32_t phyId) : mode(mode), phyId(phyId) {}
616 : };
617 :
618 : void RaUbUpdateCi(JettyHandle jettyHandle, u32 ci);
619 :
620 : struct HrtDevEidInfo {
621 : #ifdef HCCL_ALG_ANALYZER_DAVID
622 : std::string portId{0};
623 : #endif
624 : std::string name{0};
625 : IpAddress ipAddress{0};
626 : uint32_t eidIndex{0};
627 : uint32_t type{0};
628 : uint32_t dieId{0};
629 : uint32_t chipId{0};
630 : uint32_t funcId{0};
631 : uint32_t devFeature{0};
632 : };
633 : std::vector<HrtDevEidInfo> HrtRaGetDevEidInfoList(const HRaInfo& raInfo);
634 :
635 : RaSocketFdHandleParam RaGetOneSocket(u32 role, RaSocketGetParam& param);
636 :
637 : using RequestHandle = u64;
638 :
639 10415873 : MAKE_ENUM(ReqHandleResult, COMPLETED, NOT_COMPLETED, SOCK_E_AGAIN, INVALID_PARA);
640 :
641 : ReqHandleResult HrtRaGetAsyncReqResult(RequestHandle& reqHandle);
642 :
643 : RequestHandle RaSocketConnectOneAsync(RaSocketConnectParam& in);
644 : RequestHandle RaSocketCloseOneAsync(RaSocketCloseParam& in);
645 : RequestHandle RaSocketListenOneStartAsync(SocketListenInfoT* listenInfo);
646 : RequestHandle RaSocketListenOneStopAsync(RaSocketListenParam& in);
647 :
648 : RequestHandle HrtRaSocketSendAsync(const FdHandle fdHandle, const void* data, u32 size, unsigned long long& sentSize);
649 : RequestHandle HrtRaSocketRecvAsync(const FdHandle fdHandle, void* data, u32 size, unsigned long long& recvSize);
650 :
651 : RequestHandle
652 : RaUbLocalMemRegAsync(RdmaHandle handle, const HrtRaUbLocMemRegParam& in, vector<char_t>& out, void*& lmemHandle);
653 : RequestHandle RaUbLocalMemUnregAsync(RdmaHandle rdmaHandle, LocMemHandle lmemHandle);
654 :
655 : RequestHandle RaUbCreateJettyAsync(
656 : const RdmaHandle handle, const HrtRaUbCreateJettyParam& in, vector<char_t>& out, void*& jettyHandle);
657 : RequestHandle RaUbDestroyJettyAsync(void* jettyHandle);
658 :
659 : using RaUbGetTpInfoParam = struct RaUbGetTpInfoParamDef {
660 : IpAddress locAddr{};
661 : IpAddress rmtAddr{};
662 : TpProtocol tpProtocol{TpProtocol::CTP};
663 : /// 与 Next TpMgr 一致：参与 SL→jetty priority 映射（0–7）；默认见 kRaUbGetTpInfoParamDefaultQos
664 : uint32_t qos{kRaUbGetTpInfoParamDefaultQos};
665 : uint32_t slLevelCount{0U};
666 : bool loopFirstTpLowestSl{false};
667 : /// 与 Next `GetTpInfoParam::ccuLoopbackGetTpInfo` 对齐：标识 CCU 设备环回 GetTpInfo（便于日志/后续分支）
668 : bool ccuLoopbackGetTpInfo{false};
669 : /// UBOE SetTpAttr sip/dip 用 IPv4 地址（GetTpInfo 写回 SL/DSCP 后再设置）
670 : IpAddress locIpv4Addr{};
671 : IpAddress rmtIpv4Addr{};
672 :
673 27 : explicit RaUbGetTpInfoParamDef() = default;
674 53 : RaUbGetTpInfoParamDef(const IpAddress& locAddr, const IpAddress& rmtAddr, TpProtocol tpProtocol)
675 53 : : locAddr(locAddr),
676 53 : rmtAddr(rmtAddr),
677 53 : tpProtocol(tpProtocol)
678 53 : {}
679 :
680 77 : std::string Describe() const
681 : {
682 : return StringFormat(
683 : "RaUbGetTpInfoParam[locAddr=%s, rmtAddr=%s, tpProtocol=%s, qos=%u, loopFirstTpLowestSl=%d, ccuLoop=%d]",
684 231 : locAddr.Describe().c_str(), rmtAddr.Describe().c_str(), tpProtocol.Describe().c_str(),
685 77 : static_cast<unsigned>(qos & 0xFFU), static_cast<int>(loopFirstTpLowestSl),
686 308 : static_cast<int>(ccuLoopbackGetTpInfo));
687 : }
688 : };
689 :
690 : RequestHandle
691 : RaUbGetTpInfoAsync(const RdmaHandle rdmaHandle, const RaUbGetTpInfoParam& param, vector<char_t>& out, uint32_t& num);
692 :
693 : void RaUbGetTpInfo(const RdmaHandle rdmaHandle, const RaUbGetTpInfoParam& param, vector<char_t>& out, uint32_t& num);
694 :
695 : RequestHandle RaUbImportJettyAsync(
696 : const RdmaHandle rdmaHandle, const HrtRaUbJettyImportedInParam& in, vector<char_t>& out, void*& remQpHandle);
697 : RequestHandle RaUbTpImportJettyAsync(
698 : const RdmaHandle rdmaHandle, const HrtRaUbJettyImportedInParam& in, vector<char_t>& out, void*& remQpHandle);
699 : RequestHandle RaUbUnimportJettyAsync(void* targetJettyHandle);
700 :
701 : struct SocketEventInfo {
702 : u32 event;
703 : FdHandle fdHandle;
704 : };
705 :
706 : HcclResult HrtRaWaitEventHandle(
707 : int event_handle, std::vector<SocketEventInfo>& event_infos, int timeout, unsigned int maxevents, u32& events_num);
708 : void HrtRaGetSecRandom(u32* value, u32& devPhyId);
709 :
710 : HcclResult HrtRaCreateQpWithCq(
711 : RdmaHandle rdmaHandle, s32 sqEvent, s32 rqEvent, void* sendChannel, void* recvChannel, QpInfo& info,
712 : bool isHdcMode);
713 : HcclResult HrtRaDestroyQpWithCq(const QpInfo& info, bool isHdcMode);
714 : HcclResult HrtRaCreateCq(RdmaHandle rdmaHandle, CqInfo& cq);
715 : HcclResult HrtRaDestroyCq(RdmaHandle rdmaHandle, CqInfo& cq);
716 : HcclResult ConstructQpDefaultAttrs(s32 qpMode, struct qp_ext_attrs& attrs, bool isWorkFlowLib);
717 : HcclResult HrtRaNormalQpCreate(RdmaHandle rdmaHandle, QpInfo& qp);
718 : HcclResult HrtRaNormalQpDestroy(QpHandle qpHandle);
719 : HcclResult HrtRaNdaQpCreate(
720 : RdmaHandle rdmaHandle, NdaOps* ndaOps, uint32_t dmaMode, NdaCqInfo* cqInfo, NdaQpInfo* qpInfo, QpHandle* qpHandle);
721 : HcclResult HrtRaNdaCqCreate(
722 : RdmaHandle rdmaHandle, NdaOps* ndaOps, uint32_t dmaMode, uint32_t cqAttrFlags, NdaCqInfo* cqInfo,
723 : CqHandle* cqHandle);
724 : HcclResult HrtRaNdaCqDestroy(RdmaHandle rdmaHandle, CqHandle cqHandle);
725 :
726 0 : MAKE_ENUM(AuxInfoInType, AUX_INFO_IN_TYPE_CQE, AUX_INFO_IN_TYPE_AE, AUX_INFO_IN_TYPE_MAX);
727 : struct AuxInfoIn {
728 : AuxInfoInType auxInfoInType;
729 : union {
730 : struct {
731 : uint32_t status;
732 : uint8_t sR;
733 : } cqe;
734 : struct {
735 : uint32_t eventType;
736 : } ae;
737 : };
738 : u8 resv[7];
739 : };
740 :
741 : constexpr u32 MAX_AUX_INFO_NUM = 256;
742 : struct AuxInfoOut {
743 : uint32_t auxInfoTypes[MAX_AUX_INFO_NUM];
744 : uint32_t auxInfoValues[MAX_AUX_INFO_NUM];
745 : uint32_t auxInfoNum{0};
746 : };
747 : HcclResult RaGetAuxInfo(const RdmaHandle rdmaHandle, AuxInfoIn auxInfoIn, AuxInfoOut& auxInfoOut);
748 :
749 0 : MAKE_ENUM(JettyStatus, RESET, READY, SUSPENDED, ERROR);
750 : constexpr u32 MAX_JETTY_QUERY_NUM = 128;
751 : HcclResult
752 : RaBatchQueryJettyStatus(const std::vector<JettyHandle>& jettyHandles, std::vector<JettyStatus>& jettyAttrs, u32& num);
753 :
754 : struct ConnJettyInfo {
755 : RdmaHandle rdmaHandle{nullptr};
756 : JettyHandle remoteJetty{0};
757 : JettyHandle localJetty{0};
758 : };
759 :
760 : struct BatchDeleteJettyInfo {
761 : std::unordered_map<RdmaHandle, std::unordered_set<JettyHandle>> unimportJettyList;
762 : std::unordered_map<RdmaHandle, std::unordered_set<JettyHandle>> deleteJettyList;
763 : };
764 : constexpr u32 MAX_DELETE_JETTY_NUMS = 768;
765 : HcclResult HrtRaCtxQpDestoryBatch(
766 : const RdmaHandle handle, const std::unordered_set<JettyHandle>& jettyHandles,
767 : std::vector<JettyHandle>& failJettyHandles);
768 :
769 : enum CcuMemTypeBitmap : uint64_t {
770 : CCU_MEMTYPE_INVALID = 0,
771 : CCU_MEMTYPE_INS = 1ULL << 0,
772 : CCU_MEMTYPE_GSA = 1ULL << 1,
773 : CCU_MEMTYPE_XN = 1ULL << 2,
774 : CCU_MEMTYPE_CKE = 1ULL << 3,
775 : CCU_MEMTYPE_LOOP_CKE = 1ULL << 4,
776 : CCU_MEMTYPE_PFE = 1ULL << 5,
777 : CCU_MEMTYPE_CHN = 1ULL << 6,
778 : CCU_MEMTYPE_JETTY_CTX = 1ULL << 7,
779 : CCU_MEMTYPE_MISSION_CTX = 1ULL << 8,
780 : CCU_MEMTYPE_LOOP_CTX = 1ULL << 9,
781 : CCU_MEMTYPE_MISSION_SQE = 1ULL << 10,
782 : CCU_MEMTYPE_CQE_BLOCK0 = 1ULL << 11,
783 : CCU_MEMTYPE_CQE_BLOCK1 = 1ULL << 12,
784 : CCU_MEMTYPE_CQE_BLOCK2 = 1ULL << 13,
785 : CCU_MEMTYPE_WQEBB = 1ULL << 14,
786 : CCU_MEMTYPE_MS_BLOCK0 = 1ULL << 32,
787 : CCU_MEMTYPE_MS_BLOCK1 = 1ULL << 33,
788 : CCU_MEMTYPE_MS_BLOCK2 = 1ULL << 34,
789 : CCU_MEMTYPE_MS_BLOCK3 = 1ULL << 35
790 : };
791 :
792 : struct CcuMemInfo {
793 : CcuMemTypeBitmap memType{CcuMemTypeBitmap::CCU_MEMTYPE_INVALID};
794 : uint64_t memVa{0};
795 : uint32_t memSize{0};
796 : uint32_t resv[1];
797 : };
798 :
799 : void HrtSetMemInfoList(struct CcuMemInfo* memInfoList, uint32_t count, struct ccu_mem_info* recvMemList);
800 : HcclResult HrtGetCcuMemInfo(
801 : void* tlv_handle, uint32_t udieIdx, uint64_t memTypeBitmap, struct CcuMemInfo* memInfoList, uint32_t count);
802 :
803 : HcclResult HrtRaGetEidByIp(RdmaHandle handle, const vector<IpAddress>& ipV4AddrList, vector<IpAddress>& eidAddrList);
804 :
805 : /// 同步 Get/Set TpAttr（HOST_NET ctx 路径，包装 RaCtxGetTpAttr / RaCtxSetTpAttr）。
806 : HcclResult HrtRaGetTpAttr(RdmaHandle handle, uint64_t tpHandle, uint32_t& attrBitmap, TpAttr& attr);
807 : HcclResult HrtRaSetTpAttr(RdmaHandle handle, uint64_t tpHandle, uint32_t attrBitmap, TpAttr& attr);
808 : /// 设备侧是否支持 GetTpAttr（接口版本探测）。
809 : bool HrtRaSupportsGetTpAttr(u32 phyId);
810 :
811 : /// 发起 RaSetTpAttrAsync 后 WaitRequestResult 阻塞至完成；对调用方为同步语义。
812 : HcclResult
813 : HrtRaSetTpAttrAsync(RdmaHandle handle, uint64_t tpHandle, uint32_t attrBitmap, TpAttr& attr, RequestHandle& reqHandle);
814 : /// 发起 RaGetTpAttrAsync 后 WaitRequestResult 阻塞至完成；对调用方为同步语义。
815 : HcclResult HrtRaGetTpAttrAsync(
816 : u32 phyId, RdmaHandle handle, uint64_t tpHandle, uint32_t& attrBitmap, TpAttr& attr, RequestHandle& reqHandle);
817 : /// 仅发起 RaGetTpAttrAsync，不 Wait；供轮询路径使用。
818 : /// 调用方须先确认 HrtRaSupportsGetTpAttr(phyId) 为 true（本接口无 phyId，不做设备支持校验）。
819 : HcclResult HrtRaStartGetTpAttrAsync(
820 : RdmaHandle handle, uint64_t tpHandle, uint32_t& attrBitmap, TpAttr& attr, RequestHandle& reqHandle);
821 :
822 : constexpr u32 GET_UBOE_FLAG_ENABLE_OPCODE = 57;
823 : constexpr u32 GET_UBOE_FLAG_ENABLE_VERSION = 2;
824 : constexpr u32 UBOE_DEV_FLAG_RIGHT_SHIFT = 19;
825 :
826 : HcclResult HrtGetUboeFlagEnable(const u32 devPhyId);
827 :
828 4 : inline bool HrtCheckUboeSupported(const u32 devFeature)
829 : {
830 : // 设备特性位掩码, 右移取UBOE标志位, 值为1表示支持
831 4 : return (devFeature >> UBOE_DEV_FLAG_RIGHT_SHIFT) & 1;
832 : }
833 :
834 : } // namespace Hccl
835 : #endif // HCCLV2_ADAPTER_HCCP_H
|
