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