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