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 AICPU_OPERATOR_PUB_H
12 : #define AICPU_OPERATOR_PUB_H
13 : #include <stdlib.h>
14 : #include <chrono>
15 : #include <hccl/hccl_types.h>
16 : #include "hccl_common.h"
17 : #include "common.h"
18 : #include "hdc_pub.h"
19 : #include <transport_pub.h>
20 : #include "dispatcher_task_types.h"
21 : #include "externalinput_pub.h"
22 : #include "hccl_mem_defs.h"
23 : #include "hccl/hccl_res.h"
24 :
25 : using RankId = u32;
26 :
27 : namespace {
28 : constexpr u32 RANK_NUM = 32;
29 :
30 : constexpr u32 POS_DATA_PLANE_MODE_HOST = 0; // HOST调度RoCE模式
31 : constexpr u32 POS_DATA_PLANE_MODE_AICPU = 1; // AICPU直调RoCE模式
32 : constexpr u32 POS_DATA_PLANE_MODE_AIV = 2; // AIV直调RoCE模式
33 : }
34 :
35 : enum class AicpuNotifyMode : u32 {
36 : OPBASE_MODE = 0, // 单算子场景
37 : ACLGRAPH_MODE = 1, // Aclgraph 场景
38 : HCOM_MODE = 2 // 图下沉场景
39 : };
40 :
41 : struct HcclStreamInfo {
42 : s32 streamIds;
43 : u32 sqIds;
44 : u32 cqIds; // 记录物理cqId
45 : u32 logicCqids; // 记录逻辑cqId
46 : };
47 :
48 : // 记录aicpu-custom共享的stream信息
49 : struct HcclStreamParam {
50 : HcclStreamInfo streamInfo;
51 : u64 sqCqContextAddr = 0; // 记录sqeContext地址
52 : u64 sqCqContextSize = 0; // 记录sqeContext大小
53 : };
54 :
55 : struct HcclMC2WorkSpace {
56 : u64 workSpace;
57 : u64 workSpaceSize;
58 : };
59 :
60 : struct HcclOpConfig {
61 : u8 deterministic; // 确定性计算开关
62 : u8 retryEnable; // 是否重执行
63 : u8 highPerfEnable; // deprecate
64 : u8 isSupportAtomicWrite = 0;
65 : u8 padding[4]; // 大小需要64By对齐，未来添加参数时减小padding
66 : std::chrono::milliseconds linkTimeOut; //发送超时时长
67 : u32 taskMonitorInterval;
68 : u32 notifyWaitTime; // 超时时长，同HCCL_EXEC_TIMEOUT
69 : u32 retryHoldTime;
70 : u32 retryIntervalTime;
71 : bool interHccsDisable = false; // 使能rdma开关
72 : aclrtFloatOverflowMode floatOverflowMode = ACL_RT_OVERFLOW_MODE_UNDEF;
73 : u32 multiQpThreshold{HCCL_MULTI_QP_THRESHOLD_DEFAULT}; // 多QP每个QP分担数据量最小阈值
74 : };
75 :
76 : // TP8卡
77 : struct HcclCombinOpSignalParam {
78 : HcclSignalInfo noIpcNotifys[RANK_NUM*2];
79 : HcclSignalInfo ipcNotifys[RANK_NUM*4];
80 : HcclSignalInfo noIpcEvents[RANK_NUM];
81 : HcclSignalInfo aicpuNotify;
82 : HcclSignalInfo aicpuOpNotify[2]; // 集合通信AICPU展开资源
83 : };
84 :
85 30 : struct BatchSendRecvInfo {
86 : uint8_t bsrTag[128];
87 : uint32_t index;
88 : uint32_t tpQpn;
89 : uint32_t srcRank;
90 : uint32_t detRank;
91 : uint32_t streamId = ~0u;
92 : };
93 39 : using HcclOpIdentifier = struct HcclOpIdentifierDef {
94 : uint8_t tag[128]; // 通信算子的标签
95 : uint8_t newTag[256];
96 : uint32_t index; // 集合通信算子在通信域内的编号
97 : uint32_t srcRank;
98 : uint32_t detRank;
99 : bool isSendRecv = false;
100 : u32 streamId = ~0u;
101 : HcclCMDType opType = HcclCMDType::HCCL_CMD_INVALID;
102 : BatchSendRecvInfo bsrInfo[2];
103 : bool isBsrTaskStart = false; //batchsendrecv 主流start task是否完成
104 : };
105 :
106 : struct CombinedCapability {
107 : u64 dataplaneModeBitmap = 0;
108 : };
109 :
110 : struct HcclCombinOpParam {
111 : HcclMC2WorkSpace mc2WorkSpace;
112 : u32 rankId = 0; // 当前卡rankId
113 : u32 rankNum = 0;
114 : u64 winSize = 0; // 每个win大小
115 : u64 windowsIn[RANK_NUM];
116 : u64 windowsOut[RANK_NUM];
117 : char hcomId[128] = "\0";
118 : HcclStreamInfo streamInfo[RANK_NUM];
119 : HcclCombinOpSignalParam signalInfo;
120 : HcclOpConfig config; // 配置参数
121 : u64 overFlowAddr = 0;
122 : u8 onlyRead = 0; // 只使用读模式，不使用写模式
123 :
124 : // communicate retry
125 : hccl::HDCommunicateParams kfcControlTransferH2DParams;
126 : hccl::HDCommunicateParams kfcStatusTransferD2HParams;
127 :
128 : u8 padding[16]; // 大小需要64By对齐，未来添加参数时减小padding
129 : u64 winExpSize = 0;
130 : u64 windowsExp[RANK_NUM];
131 :
132 : u8 multiServerFlag = 0;
133 : u64 ibverbsData = 0; // TransportDeviceNormalIbverbsData数组的首地址
134 : u64 ibverbsDataSize = 0; // TransportDeviceNormalIbverbsData数组的字节长度
135 :
136 : u64 sizeOfAiRMAInfo = 0; // sizeof(HcclAiRMAInfo), 用于内存校验
137 : void* aiRMAInfo = nullptr; // HcclAiRMAInfo* 单个结构体指针
138 :
139 : u64 capabilityPtr = 0; // 通信能力信息结构体在Device上的地址
140 : u64 capabilitySize = 0; // 通信能力信息结构体size
141 : };
142 :
143 : struct HcclKFCTilingData {
144 : u32 preparePosition; // 任务准备位置：0表示在host完成所有通信任务的准备，1表示在kernel侧完成
145 : u64 sendOff; // 发送数据地址偏移，count * dataTypeSize
146 : u64 recvOff; // 接收数据地址偏移, count * dataTypeSize
147 : u64 tailSendOff; // 尾块发送数据地址偏移，count * dataTypeSize
148 : u64 tailRecvOff; // 尾块发送数据地址偏移，count * dataTypeSize
149 : u64 sendCnt; // 整块发送数据个数
150 : u64 recvCnt; // 整块接收数据个数
151 : u64 tailSendCnt; // 尾块发送数据个数
152 : u64 tailRecvCnt; // 尾块接收数据个数
153 : u64 totalCnt; // 总数据个数
154 : u32 turnNum; // 总轮次
155 : u32 tailNum; // 尾块的轮次
156 : u32 stride; // 跳写间隔
157 : u32 workspaceOff; // 使用workspace作为recvbuf时的workspace偏移
158 : u32 notifyOff; // device notify write/read value偏移
159 : u16 notifyBeginCnt; // notify write value的使用个数
160 : u16 notifyEndCnt; // notify read value的使用个数
161 : u8 useBufferType; // 是否使用workspace作为recvbuf
162 : u8 funID; // function ID
163 : u8 dataType; // hccl 数据类型
164 : u8 groupNum; // groupNum
165 : u8 reuseMode; // tiling，填msgCnt，内存优化选择复用的内存块个数
166 : u8 commType; // 通信类型
167 : u8 reduceOp; // reduce op type
168 : u8 commOrder; // 通信顺序，0表示通信在前，1表示通信在后
169 : u8 waitPolicy; // 等待任务启动的阻塞策略
170 : // 2、首轮等待，1、每轮等待。KFC根据此标记在主流任务前面加wait，AIC需要按策略发对应record才能触发执行
171 : u8 rspPolicy; // 任务执行结束时的响应策略， 2、最后通知一次，
172 : // 1、每轮通知一次。KFC根据此标记在主流任务后面加record
173 : u8 exitPolicy; // 退出策略，0，一次通信任务下发完成直接退出；1. 通信任务执行完成退出；2.
174 : // 等待AIC通知退出(可以多次执行任务)。
175 : u8 commAlg; // 用于指定具体通信算法。
176 : u8 taskType; // 用于识别不同任务。参考KfcTaskType定义
177 : u8 debugMode; // 调测模式
178 : // 1:单独执行CUBE
179 : // 2:单独执行Vector
180 : // 4:单独执行AICPU KFC算子
181 : // 8:KFC等待通信结束
182 : // 16:KFC统计各阶段耗时
183 : u8 stepSize; // 用于指定通算频率步长
184 : u8 sendArgIndex; // 发送数据参数索引，对应算子原型的参数顺序
185 : u8 recvArgIndex; // 接收数据参数索引，对应算子原型的参数顺序
186 : u8 commOutArgIndex; // 通信输出参数索引，对应算子原型的参数顺序
187 : u8 hasCommOut; // 是否有通信输出
188 : };
189 :
190 : enum HcclKfcTaskType {
191 : HCCL_KFC_TASK_HCC_RES_INIT = 1, // 集合通信资源下发&校验
192 : HCCL_KFC_TASK_HCC_START_SERVER = 2, // 只启动KFC server，从msg queue接收任务
193 : HCCL_KFC_TASK_HCC_TASK_PREPARE = 3, // 从参数获取通信任务，完成准备，待AIC通知消息再激活
194 : HCCL_KFC_TASK_HCC_TASK_DELIVER = 4, // 从参数获取通信任务，直接下发。AIC自己发Record激活
195 : HCCL_KFC_TASK_COMMON_CMD_EXE = 5, // 预留，通用任务执行，具体任务信息可以在参数中描述。
196 : HCCL_KFC_TASK_HCCL_ONLY_EXE = 6, // 通信任务单独执行
197 : KFC_TASK_TYPE_END
198 : };
199 :
200 : #define list_entry(ptr, type, member) (reinterpret_cast<type *>(reinterpret_cast<char *>(ptr) - offsetof(type, member)))
201 :
202 : constexpr u64 COMM_P2P = 1UL << 0;
203 : constexpr u64 COMM_RDMA = 1UL << 1;
204 :
205 : constexpr u32 LINK_P2P_MAX_NUM = 64;
206 : constexpr u32 MEM_DETAILS_NUM = 2; // link信息中memDetails的大小：0对应INPUT，1对应OUTPUT
207 : constexpr u32 RDMA_QP_MAX_NUM = 33;
208 : constexpr u32 RDMA_NOTIFY_MAX_NUM = 8 * 3;
209 : constexpr u32 LOCAL_STREAM_MAX_NUM = 40U;
210 : constexpr u32 LOCAL_NOTIFY_MAX_NUM = 64;
211 : using RANK_TYPE = u32;
212 : using TAG_TYPE = u32;
213 : using LENGTH_TYPE = u32;
214 : constexpr u32 TOP_COMM_LEVEL0_SHIFT = 16;
215 : constexpr u32 TOP_COMM_LEVEL0_LOCATION = 0xFFFF0000;
216 : constexpr u32 TOP_COMM_LEVEL1_LOCATION = 0xFFFF;
217 : constexpr u32 TOP_HIERARCHICAL_COMM_LEVEL0_SHIFT = 12;
218 : constexpr u32 TOP_HIERARCHICAL_COMM_LEVEL1_SHIFT = 16;
219 : constexpr u32 TOP_HIERARCHICAL_COMM_LEVEL0_LOCATION = 0xF0000000;
220 : constexpr u32 TOP_HIERARCHICAL_COMM_LEVEL1_LOCATION = 0xFFF0000;
221 : constexpr u32 TOP_HIERARCHICAL_COMM_LEVEL2_LOCATION = 0xFFFF;
222 : constexpr u32 TOP_HIERARCHICAL_CONF_SIZE = 32;
223 : constexpr u32 TOP_HIERARCHICAL_CONF_lENGTH_INDEX = 0;
224 : constexpr u32 TOP_HIERARCHICAL_CONF_INFO_INDEX = 1;
225 : constexpr u32 TOP_HIERARCHICAL_CONF_LEVEL_SHIFT = 0;
226 : constexpr u32 TOP_HIERARCHICAL_CONF_CONC_TYPE_SHIFT = 4;
227 : constexpr u32 TOP_HIERARCHICAL_CONF_OP_TYPE_SHIFT = 8;
228 : constexpr u32 TOP_HIERARCHICAL_CONF_TEMPLATE_TYPE_SHIFT = 16;
229 : constexpr u32 TOP_HIERARCHICAL_CONF_LEVEL_LOCATION = 0x0000000F;
230 : constexpr u32 TOP_HIERARCHICAL_CONF_CONC_TYPE_LOCATION = 0x000000F0;
231 : constexpr u32 TOP_HIERARCHICAL_CONF_OP_TYPE_LOCATION = 0x0000FF00;
232 : constexpr u32 TOP_HIERARCHICAL_CONF_TEMPLATE_TYPE_LOCATION = 0xFFFF0000;
233 : constexpr u32 TOP_COMM_RING_LOCATION = 0;
234 : constexpr u32 TAG_MAX_LENGTH = 256;
235 : constexpr u32 AICPU_OP_NOTIFY_MAX_NUM = 2;
236 : constexpr u32 AICPU_ORDER_NOTIFY_MAX_NUM = 3;
237 : constexpr u32 AICPU_MAX_RANK_NUM = 128 * 1024;
238 : constexpr u32 MAX_RANK_NUM_A3 = 768;
239 : constexpr u32 HCOMID_MAX_LENGTH = 256;
240 :
241 : // aclgraph 销毁场景下从 host 端投递到 aicpu 端的清理任务 payload，与 HcclKFCTilingData 独立；host 端通过 RunAicpuKfcClearOpRes 投递，aicpu 端按 group 定位 HcclCommAicpu 后批量清 tags
242 : constexpr u32 HCCL_KFC_CLEAR_OP_RES_MAGIC = 0x484B4346U; // 'HKCF'，aicpu 端校验防误投
243 : constexpr u32 HCCL_KFC_CLEAR_OP_RES_MAX_BATCH = 10240U; // 单次 launch 最多清的 tag 数；10240×256B ≈ 2.5MB
244 : struct HcclKfcClearOpResTilingData {
245 : u32 magic; // 必须等于HCCL_KFC_CLEAR_OP_RES_MAGIC
246 : u32 tagCount; // 本批实际有效 tag 数 (1..MAX_BATCH)
247 : char group[HCOMID_MAX_LENGTH]; // communicator identifier
248 : char tags[HCCL_KFC_CLEAR_OP_RES_MAX_BATCH][TAG_MAX_LENGTH]; // 待清理 op tag 列表，含_Capture后缀
249 : };
250 :
251 : struct HcclOpConfigV2 {
252 : u8 deterministic; // 确定性计算开关
253 : };
254 :
255 : struct HcclMC2WorkSpaceV2 {
256 : u64 workSpace;
257 : u64 workSpaceSize;
258 : };
259 :
260 : struct HcclStreamInfoV2 {
261 : s32 streamIds;
262 : u32 sqIds;
263 : };
264 :
265 : struct ListCommon {
266 : u64 nextHost;
267 : u64 preHost;
268 : u64 nextDevice;
269 : u64 preDevice;
270 : };
271 :
272 825 : static inline void ListCommonInit(struct ListCommon *deviceList, struct ListCommon *hostList)
273 : {
274 824 : if (hostList == nullptr) {
275 0 : HCCL_ERROR("hostList[%p] is nullptr", hostList);
276 0 : return;
277 : }
278 825 : hostList->nextHost = reinterpret_cast<u64>(hostList);
279 825 : hostList->preHost = reinterpret_cast<u64>(hostList);
280 825 : hostList->nextDevice = reinterpret_cast<u64>(deviceList);
281 825 : hostList->preDevice = reinterpret_cast<u64>(deviceList);
282 : }
283 :
284 227 : static inline void ListCommonAddHead(struct ListCommon *newDeviceL, struct ListCommon *newHostL,
285 : struct ListCommon *headHostL, struct ListCommon *headDeviceL)
286 : {
287 227 : if (newHostL == nullptr || headHostL == nullptr) {
288 0 : HCCL_ERROR("input ptr is nullptr, newHostL[%p], headHostL[%p]", newHostL, headHostL);
289 0 : return;
290 : }
291 227 : ListCommon *headHostLNextHost = reinterpret_cast<ListCommon *>(headHostL->nextHost);
292 227 : headHostLNextHost->preHost = reinterpret_cast<u64>(newHostL);
293 227 : newHostL->nextHost = headHostL->nextHost;
294 227 : newHostL->preHost = reinterpret_cast<u64>(headHostL);
295 227 : headHostL->nextHost = reinterpret_cast<u64>(newHostL);
296 :
297 227 : headHostLNextHost->preDevice = reinterpret_cast<u64>(newDeviceL);
298 227 : newHostL->nextDevice = headHostL->nextDevice;
299 227 : newHostL->preDevice = reinterpret_cast<u64>(headDeviceL);
300 227 : headHostL->nextDevice = reinterpret_cast<u64>(newDeviceL);
301 : }
302 :
303 : // 跟 ListCommonAddHead 对称的双链表 unlink，同时维护 host 和 device 两套 prev/next 指针
304 4 : static inline void ListCommonRemove(struct ListCommon *nodeHostL)
305 : {
306 4 : if (nodeHostL == nullptr) {
307 1 : HCCL_ERROR("nodeHostL is nullptr");
308 1 : return;
309 : }
310 3 : ListCommon *prevHost = reinterpret_cast<ListCommon *>(nodeHostL->preHost);
311 3 : ListCommon *nextHost = reinterpret_cast<ListCommon *>(nodeHostL->nextHost);
312 3 : if (prevHost == nullptr || nextHost == nullptr) {
313 0 : HCCL_ERROR("nodeHostL link broken, preHost[%p] nextHost[%p]", prevHost, nextHost);
314 0 : return;
315 : }
316 3 : prevHost->nextHost = nodeHostL->nextHost;
317 3 : nextHost->preHost = nodeHostL->preHost;
318 3 : prevHost->nextDevice = nodeHostL->nextDevice;
319 3 : nextHost->preDevice = nodeHostL->preDevice;
320 : // 自指向，避免悬空指针被误访问（跟 ListCommonInit 后空链表状态一致）
321 3 : nodeHostL->nextHost = reinterpret_cast<u64>(nodeHostL);
322 3 : nodeHostL->preHost = reinterpret_cast<u64>(nodeHostL);
323 3 : nodeHostL->nextDevice = nodeHostL->nextHost;
324 3 : nodeHostL->preDevice = nodeHostL->preHost;
325 : }
326 :
327 : // KFC控制命令
328 : enum class KfcCommand : int64_t {
329 : kNone = 0, // 空命令
330 : kStopLaunch, // 停止算子下发
331 : kStopExec, // 停止算子执行
332 : kClear, // 清理算子状态&资源
333 : kChangeLink, // 切换主备链路
334 : kRetry, // 重新执行算子
335 : kExit, // 退出算子执行
336 : NsStopLaunch, // N秒快恢下的停止算子下发
337 : NsStopExec, // N秒快恢下的停止算子执行
338 : NsClear, // N秒快恢下的清理算子状态&资源
339 : NsChangeLink, // N秒快恢下的切换主备链路
340 : kDestroyComm, // 销毁AICPU通信域
341 : kSwitchNic, // 发起主动借轨
342 : kWaitSwitchNic, // 等待主动借轨完成
343 : kAllSwitched, // 通信域内的所有卡完成主动借轨
344 : kSwitchFail, // 主动借轨失败，回退借轨操作
345 : kReportRetryErr, // 退出算子执行，但支持step重计算
346 : };
347 :
348 : // AICPU背景线程控制
349 : enum class BackgroundCommand : int64_t {
350 : kNone = 0, // 空命令
351 : kStop,
352 : };
353 :
354 : // device侧感知目前通信域的状态
355 : enum class HcclComSuspendingFlag : int64_t {
356 : isNull = 0,
357 : isResume, // device侧感知是resume状态
358 : isSuspending, // device侧感知是suspending状态
359 : };
360 :
361 : // host向aicpu发送link状态
362 3 : using ChangeLinkInfo = struct ChangeLinkInfoDef {
363 : u32 remoteRankNum = 0;
364 : u32 remoteRankList[AICPU_MAX_RANK_NUM] = {};
365 : bool isUseDefaultPort[AICPU_MAX_RANK_NUM] = {};
366 : bool isChangeLinkFlag = false;
367 : };
368 :
369 : // host向aicpu发送的命令
370 : using KfcExecControl = struct KfcExecControlDef {
371 : KfcCommand kfcCmd; // 控制KFC执行
372 : BackgroundCommand bgCmd; // 控制背景线程执行
373 : HcclComSuspendingFlag suspendingStatus; // KFC状态
374 : HcclOpIdentifier targetOp;
375 : ChangeLinkInfo changeLinkInfo;
376 : };
377 :
378 : // KFC的执行状态
379 : enum class KfcStatus : int64_t {
380 : kNull = 0 , // 算子的执行状态还没有initOpStatus前的状态
381 : kRuning,
382 : kEnd,
383 : kStoplaunch,
384 : kStopExec,
385 : kClear,
386 : kChanged,
387 : kError,
388 : kDestroyComm,
389 : kPlanSwitch,
390 : kSwitchError,
391 : kWaitSwitchRes,
392 : kSwitchSuccess,
393 : kSwitchFail,
394 : kRetryError, // 重执行失败状态
395 : kResumeError, // 恢复执行失败状态
396 : kResumeChanged, // 恢复过程借轨成功
397 : };
398 :
399 : // KFC的执行错误码
400 : enum class KfcError : int64_t {
401 : kNone = 0, // 无异常
402 : kSdma, // SDMA task执行失败
403 : kRdma, // RDMA task执行失败
404 : kTimeout, // task执行超时
405 : kInner, // 通信算子展开、task下发失败
406 : kExec, // 算子执行失败
407 : kExit, // 算子强行终止
408 : kExecConstraint, // 进入约束的算子重执行失败
409 : };
410 :
411 : enum class PollStatus : int64_t {
412 : kDefault = 0,
413 : kStopAsException,
414 : };
415 :
416 : enum class BackgroundStatus : int64_t {
417 : kNone = 0, // 正常状态
418 : kStop, //背景线程停止状态
419 : };
420 :
421 : using KfcTaskException = struct KfcTaskExceptionDef {
422 : uint16_t streamId = 0;
423 : uint16_t taskId = 0;
424 : uint32_t errorCode = 0;
425 : uint8_t errorType = 0;
426 : uint8_t sqeType = 0;
427 : uint16_t sqId = 0;
428 : };
429 : using KfcRetryInfo = struct KfcRetryStatusDef {
430 : uint32_t retryCount = 0; // 已重试次数;
431 : };
432 :
433 : struct ErrorMessageReport {
434 : char tag[TAG_MAX_LENGTH] = {0};
435 : char group[GROUP_NAME_MAX_LEN + 1] = {0};
436 : u32 remoteUserRank = 0;
437 : s32 streamId = 0;
438 : u32 taskId = 0;
439 : u32 notifyId = 0;
440 : s32 stage = 0;
441 : u32 rankId = 0;
442 : u32 rankSize = 0;
443 : AlgType algType;
444 : hccl::TaskType taskType = hccl::TaskType::TASK_SDMA;
445 : uint64_t count = 0;
446 : uint64_t dstAddr = 0;
447 : uint64_t srcAddr = 0;
448 : uint32_t opIndex = 0; // 记录index
449 : uint32_t reduceType = 255; // 255 为 HcclReduceOp::HCCL_REDUCE_RESERVED
450 : uint8_t dataType = 0;
451 : };
452 :
453 : struct ExecStatusDef {
454 : KfcStatus kfcStatus; // KFC状态
455 : KfcError kfcError; // KFC错误码
456 : KfcRetryInfo retryInfo;
457 : KfcTaskException taskException;
458 : PollStatus pollStatus; // 背景线程状态
459 : BackgroundStatus backgroundStatus;
460 : };
461 :
462 : #pragma pack(push)
463 : #pragma pack(1)
464 : // aicpu向host提供的状态查询
465 : using KfcExecStatus = struct KfcExecStatusDef {
466 : HcclOpIdentifier opId;
467 : ExecStatusDef execStatus;
468 : ErrorMessageReport emrReport;
469 : };
470 : #pragma pack(pop)
471 :
472 : // P2P同步资源
473 : struct HcclLinkP2pV2 {
474 : MemDetails localMem[MEM_DETAILS_NUM];
475 : MemDetails remoteMem[MEM_DETAILS_NUM];
476 : HcclSignalInfo localIpcSignal[LINK_P2P_MAX_NUM]; // localnotify
477 : HcclSignalInfo remoteIpcSignal[LINK_P2P_MAX_NUM];
478 : hccl::TransportAttr transportAttr;
479 : };
480 :
481 : struct HcclLinkRoceV2 {
482 : MemDetails localMem[MEM_DETAILS_NUM];
483 : MemDetails remoteMem[MEM_DETAILS_NUM];
484 : u64 notifyValue{0}; // notify record的src地址value存储位置
485 : u32 notifyValueKey{0};
486 : u32 singleQPNotifyNum{0}; // one link multi notify resources nums obtained via alg
487 : u64 localNotifyList{0}; // devicePtrValue type:HcclSignalInfo size: [3,8192]
488 : u64 remoteNotifyList{0}; // devicePtrValue type:u64 size: [3,8192]
489 : u32 remoteNotifyKey{0}; // deprecated
490 : s64 chipId{LLONG_MAX}; // deprecated
491 : HcclQpInfoV2 QpInfo[RDMA_QP_MAX_NUM]; // ayyay size: [1, 1 + HCCL_RDMA_QPS_PER_CONNECTION_MAX]
492 : u32 qpsPerConnection{1}; // current link actual qp num obtained via env、workflowMode、qpMode
493 : bool useAtomicWrite{false}; // 是否使用atomic write
494 : };
495 :
496 : struct HccltagRemoteResV2 {
497 : ListCommon nextTagRes;
498 : char tag[TAG_MAX_LENGTH]; // newtag
499 : HcclLinkP2pV2 linkP2p;
500 : HcclLinkP2pV2 linkP2pSio;
501 : HcclLinkRoceV2 linkRoce[4];
502 : };
503 :
504 : struct HccltagRemoteResV3 {
505 : HccltagRemoteResV2 *tagRemoteResPtr;
506 : u64 p2pNotifyNum = 0; // 用于linkp2p添加notify信息，不能超过Max个，超过报错（不区分local&remote）
507 : u64 roceNotifyNum = 0; // 主链路：用于linkroce添加notify信息，不能超过Max个，超过报错（不区分local&remote）
508 : u64 roceNotifyNumBackup = 0; // 备链路：用于linkroce添加notify信息，不能超过Max个，超过报错（不区分local&remote）
509 : u64 qpNum = 0; // 主链路：QP计数，支持多个，用于linkroce添加QP信息
510 : u64 qpNumBackup = 0; // 备链路：QP计数，支持多个，用于linkroce添加QP信息
511 : };
512 :
513 : struct HcclRankRelationResV2 {
514 : u32 remoteUsrRankId = 0;
515 : u32 remoteWorldRank = 0;
516 : u64 windowsIn = 0;
517 : u64 windowsOut = 0;
518 : u64 windowsExp = 0;
519 : ListCommon nextTagRes = { 0 }; // HccltagRemoteResV2(根据tag区分)
520 : };
521 :
522 : struct HccltagLocalResV2 { // TAG专用,scratchmem，
523 : ListCommon nextTagRes; // 为0时，为尾节点
524 : char tag[TAG_MAX_LENGTH]; // 通信域内共享的资源则与通信域的hcomid相同
525 : u64 ScratchmemSize; // 为0时代表没有使用Scratchmem
526 : u64 Scratchmem;
527 : };
528 :
529 : // 预留占位内存
530 : struct ReservedStruct {
531 : u32 streamNum;
532 : u32 signalNum;
533 : HcclSignalInfo localSignals[LOCAL_NOTIFY_MAX_NUM];
534 : HcclStreamInfo streamInfo[19]; // 19为630版本数组的实际大小，不能使用已经变更为40的LOCAL_STREAM_MAX_NUM，否则会有兼容问题
535 : HcclStreamInfo mainStreamInfo;
536 : HcclSignalInfo aicpuOpNotify[AICPU_OP_NOTIFY_MAX_NUM]; // 集合通信AICPU展开资源
537 : ListCommon nextTagRes; // HccltagLocalResV2
538 : };
539 :
540 : // 卡内主从流同步，下沉图，单算子，通信域内复用
541 : struct LocalResInfoV2 {
542 : u32 streamNum;
543 : u32 signalNum;
544 : HcclSignalInfo localSignals[LOCAL_NOTIFY_MAX_NUM];
545 : HcclStreamParam streamParam[LOCAL_STREAM_MAX_NUM];
546 : HcclStreamParam mainStreamParam;
547 : HcclSignalInfo aicpuOpNotify[AICPU_OP_NOTIFY_MAX_NUM]; // 集合通信AICPU展开资源
548 : ListCommon nextTagRes; // HccltagLocalResV2
549 : };
550 :
551 : struct CommonTlv {
552 : TAG_TYPE type;
553 : LENGTH_TYPE length; // 本TLV总字节数，包括Type和length
554 : RANK_TYPE value;
555 : };
556 :
557 : struct AlgoTopoInfo {
558 : u32 userRank; // 通信域 RankID
559 : u32 userRankSize; // 通信域的 Rank数量
560 : s32 deviceLogicId;
561 : bool isSingleMeshAggregation;
562 : u32 deviceNumPerAggregation; // 每个module中的Device数量
563 : u32 superPodNum; // 集群中总的超节点数
564 : u32 devicePhyId;
565 : u32 topoType; // TopoType
566 : u32 deviceType;
567 : u32 serverNum;
568 : u32 meshAggregationRankSize;
569 : u32 multiModuleDiffDeviceNumMode;
570 : u32 multiSuperPodDiffServerNumMode;
571 : u32 realUserRank;
572 : bool isDiffDeviceModule;
573 : bool isDiffDeviceType;
574 : u32 gcdDeviceNumPerAggregation;
575 : u32 moduleNum;
576 : u32 isUsedRdmaRankPairNum;
577 : u64 isUsedRdmaRankPair;
578 : u32 pairLinkCounterNum;
579 : u64 pairLinkCounter;
580 : u32 nicNum;
581 : u64 nicList; // niclist数组指针
582 : u64 complanRankLength; // complanRank占用的字节数
583 : u64 complanRank; // 指针
584 : u64 bridgeRankNum; // bridgeRank占用的个数
585 : u64 bridgeRank; // 指针
586 : u64 serverAndsuperPodRankLength; // serverAndsuperPodRank占用的字节数
587 : u64 serverAndsuperPodRank; // 指针
588 : };
589 : struct RemoteResPtr {
590 : u64 nextHostPtr;
591 : u64 nextDevicePtr;
592 : };
593 :
594 : constexpr u32 ZERO_COPY_BUFFER_MAX_MAP_COUNT = 16 * 32 * 1024; // 16卡，一次每卡最多32k个映射修改
595 : constexpr u32 ZERO_COPY_IPC_BUFFER_LENGTH = 4096; // 跨进程交换地址所需buffer长度
596 : struct LocalIpc2RemoteAddr {
597 : u32 devicePhyId = 0;
598 : u64 localIpcAddr = 0;
599 : u64 remoteAddr = 0;
600 : u64 length = 0;
601 : };
602 :
603 : enum class ZeroCopyItemType : u32 {
604 : SET_MEMORY,
605 : UNSET_MEMORY,
606 : ACTIVATE_MEMORY,
607 : DEACTIVATE_MEMORY
608 : };
609 :
610 : struct ZeroCopyRingBufferItem {
611 : ZeroCopyItemType type;
612 : LocalIpc2RemoteAddr addr;
613 : };
614 :
615 : // 层次化算法信息
616 : struct HierarchicalAlgInfo {
617 : u64 commplaneSubGroupRankLength; // complanSubGroupRank占用的字节数
618 : u64 commplaneSubGroupRank; // 指针
619 : u32 hierarchicalAlgOptionNum;
620 : u64 hierarchicalAlgOptionVec; // hierarchicalAlgOptionVec数组指针
621 : };
622 :
623 : constexpr u32 HCCL_TAG_SIZE = 256;
624 : constexpr u32 OPINFO_RING_BUFFER_MAX = 2048;
625 : struct AicpuOpInfo {
626 : char tagBuff[HCCL_TAG_SIZE] {0}; //记录tag信息
627 : uint32_t opIndex = 0; // 记录算子下发index
628 : uint64_t count = 0;
629 : uint8_t dataType = 0;
630 : uint8_t opType = 0; // 算子类型
631 : uint32_t rootId;
632 : uint64_t dstAddr = 0;
633 : uint64_t srcAddr = 0;
634 : uint32_t reduceType = 255; // 255 为 HcclReduceOp::HCCL_REDUCE_RESERVED
635 : uint32_t opExecIndex = 0; // 记录算子执行index
636 : bool isCustom = false;
637 : };
638 :
639 : struct TaskExceptionParam {
640 : u32 opRingBufferIdx = 0; // 记录算子信息在AicpuOpInfo数组里的下标
641 : AicpuOpInfo opInfo[OPINFO_RING_BUFFER_MAX]; // 用于记录每个task对应的算子入参信息
642 : };
643 :
644 : // aicpu和custom进程需要交互的部分信息
645 : struct AicpuCustomParam {
646 : TaskExceptionParam taskExceptionParam; // 故障上报信息
647 : };
648 :
649 : // 注意，本数据结构整体均被MC2不同算子使用
650 : // MC2使用偏移量访问整个数据结构，不能调整任意的位置，长度等信息
651 : struct HcclOpResParam {
652 : // 本地资源
653 : HcclMC2WorkSpace mc2WorkSpace;
654 : u32 localUsrRankId; // usrrankid
655 : u32 rankSize; // 通信域内total rank个数
656 : u64 winSize; // 每个win大小，静态图时，可能为0，如果通信域内也有动态图，则可能为非0
657 : u64 localWindowsIn; // 全F为无效值
658 : u64 localWindowsOut; // 全F为无效值
659 : char hcomId[128];
660 : u64 winExpSize;
661 : u64 localWindowsExp;
662 : // aicore识别remote window
663 : u32 rWinStart; // 为HcclRankRelationRes起始位置
664 : u32 rWinOffset; // 为HcclRemoteRes的大小
665 : u64 version;
666 : ReservedStruct reservedStrcut;
667 : AlgoTopoInfo topoInfo;
668 :
669 : // 外部配置参数
670 : HcclOpConfig config;
671 : u64 hostStateInfo;
672 : u64 aicpuStateInfo;
673 : u64 lockAddr;
674 : u32 rsv[16];
675 : u32 notifysize; // RDMA场景使用，910B/910_93为4B，其余芯片为8B
676 : u32 remoteResNum; // 有效的remoteResNum
677 : RemoteResPtr remoteRes[AICPU_MAX_RANK_NUM]; // 数组指针，指向HcclRankRelationResV2，下标为remoteUserRankId
678 :
679 : // communicate retry
680 : hccl::HDCommunicateParams kfcControlTransferH2DParams;
681 : hccl::HDCommunicateParams kfcStatusTransferD2HParams;
682 :
683 : u64 tinyMem; // for all2all
684 : u64 tinyMemSize;
685 :
686 : // 零拷贝场景使用
687 : u64 zeroCopyHeadPtr;
688 : u64 zeroCopyTailPtr;
689 : u64 zeroCopyRingBuffer;
690 : u64 zeroCopyIpcPtrs[AICPU_ZERO_COPY_MAX_DEVICE_NUM_A3]; // 保存集合通信时每个对端的输入输出内存地址
691 : u32 zeroCopyDevicePhyId[AICPU_ZERO_COPY_MAX_DEVICE_NUM_A3]; // 保存每个rank对应的物理卡Id
692 :
693 : bool utraceStatusFlag;
694 :
695 : OpCounterInfo opCounterInfo;
696 :
697 : HierarchicalAlgInfo hierarchicalAlgInfo;
698 : LocalResInfoV2 localRes;
699 : u64 debugConfig = 0; // 环境变量HCCL_DEBUG_CONFIG, 考虑兼容性放在结构体末尾
700 :
701 : // aicpu和custom进程需要交互的部分信息
702 : u64 aicpuCustomParamAddr;
703 : u64 aicpuCustomParamSize;
704 :
705 : // 外部mc2等算子使用偏移量访问
706 : MemDetails userMemRes[MAX_RANK_NUM_A3]; // 下标为rank id
707 : u32 userMemType = 0; // 0:CCL Buffer; 1:user Mem
708 :
709 : HcclStreamParam aicpuOrderStreamParam; // 按序下发的stream
710 : u64 aicpuOrderNotifyAddr;
711 : u64 aicpuOrderNotifySize;
712 : // ARS算法属性
713 : u32 multiSuperPodDiffDeviceNumMode;
714 : bool isARSDoubleRing;
715 : // 读取HCCL_ENTRY_LOG_ENABLE环境变量，用于增加算子kernel展开信息
716 : bool opEntry{false};
717 : uint32_t hcclSdmaQos; //HCCL SDMA QOS TAG
718 : // 外部mc2等算子跨框AIV场景使用
719 : u64 sizeOfAiRMAInfo = 0; // sizeof(HcclAiRMAInfo), 用于内存校验
720 : u64 aiRMAInfo = 0; // HcclAiRMAInfo* 单个结构体指针
721 : };
722 :
723 : struct OpTilingData {
724 : char tag[128];
725 : char newTag[256];
726 : char algName[128];
727 : u32 index; // 集合通信算子在通信域内的编号，aicpu侧使用时区分算子类型(bsr、sendrecv、其他)单独计数
728 : u64 algType;
729 : u8 floatOverflowMode;
730 : u8 dumpDebug;
731 : u8 debugMode;
732 : u8 workflowMode;
733 : u64 inputPtr;
734 : u64 outputPtr;
735 : u8 reduceType; // HcclReduceOp ::HCCL_REDUCE_RESERVED
736 : u8 syncMode; // SyncMode::DEFAULT_TIMEWAITSYNCMODE;
737 : RankId root = INVALID_VALUE_RANKID;
738 : RankId dstRank = 0;
739 : RankId srcRank = 0;
740 : u8 opType; // HcclCMDType::HCCL_CMD_INVALID;
741 : u8 inplaceSupportRetry;
742 : u8 retryEnable;
743 : u8 inPlaceSupportRetryStatus;
744 : u8 isInplacePreSync;
745 : u8 isPostSync;
746 : u8 isZeroCopy = 0;
747 : u64 version = 0;
748 : s32 userStreamId;
749 : u32 ahcConfInfo[TOP_HIERARCHICAL_CONF_SIZE] = {0};
750 : uint8_t aicpuCacheEnable = 0; // 是否开启aicpu cache
751 : u8 isSymmetricMemory = 0;
752 : u64 inputSymWindow;
753 : u64 inputOffset = 0;
754 : u64 outputSymWindow;
755 : u64 outputOffset = 0;
756 :
757 : /******************可变长度数据区，如需新增字段请在这之前增加*******************/
758 : u64 length; // 可变长度数据区长度
759 : u64 customDataLength; // 用户自定义预留可变长度数据区长度，预期在aicpu侧做数据块校验
760 : u8 isCapture = 0; // 算子是否aclgraph模式
761 : u8 orderLaunchMode = 0; // 对应AicpuNotifyMode的枚举值
762 : u8 needIncreLink = 0; // 是否需要增量建链
763 :
764 : /* 不同算子，长度不同，依据opType决定选择使用
765 : * (1)batchsendrcv
766 : * struct {
767 : * u32 itemNum;
768 : * HcclSendRecvItem orderedList[itemNum];
769 : * } OpTilingBatchSendRecvDataDes;
770 : * (2)alltoallv
771 : * struct {
772 : * u8 sendType; // HcclDataType
773 : * u8 recvType; // HcclDataType
774 : * u32 rankSize;
775 : * u64 sendCounts[rankSize];
776 : * u64 recvCounts[rankSize];
777 : * u64 sdispls[rankSize];
778 : * u64 rdispls[rankSize];
779 : * };
780 : * (3)alltoallvc
781 : * struct {
782 : * u8 sendType; // HcclDataType
783 : * u8 recvType; // HcclDataType
784 : * u32 rankSize;
785 : * u64 sendCountMatrix[rankSize * rankSize];
786 : * };
787 : * (4)alltoall
788 : * struct {
789 : * u8 sendType; // HcclDataType
790 : * u8 recvType; // HcclDataType
791 : * u64 sendCount;
792 : * u64 recvCount;
793 : * };
794 : * (5)other operators
795 : * struct {
796 : * u64 count;
797 : * u8 datatype; // HcclDataType
798 : * }; */
799 : };
800 : struct OpTilingDataDes {
801 : u64 count;
802 : u8 dataType;
803 : };
804 : struct OpTilingVDataDes {
805 : u8 dataType; // HcclDataType
806 : u64 vDataLen; // TLV: T is opType in OpTilingData, L is vData length
807 : u64 vData[]; // counts/displs
808 : };
809 : struct OpTilingBatchSendRecvDataDes {
810 : u32 itemNum;
811 : HcclSendRecvItem batchSendRecvItem[];
812 : };
813 : struct OpTilingAllToAllDataDes{
814 : u8 sendType; // HcclDataType
815 : u8 recvType; // HcclDataType
816 : u64 sendCount;
817 : };
818 : struct OpTilingAlltoallvDataDes {
819 : u8 sendType; // HcclDataType
820 : u8 recvType; // HcclDataType
821 : u64 sendRecvInfos[];
822 : };
823 : struct OpTilingAlltoallvcDataDes {
824 : u8 sendType; // HcclDataType
825 : u8 recvType; // HcclDataType
826 : u64 sendCountMatrix[];
827 : };
828 : struct HcclOneSideCommResParam { // 单边通信使用的Stream和Notify资源
829 : HcclStreamParam execStreamParam; // HOST侧申请传递给AICPU侧使用的执行流
830 : HcclSignalInfo aicpuOpNotify[AICPU_OP_NOTIFY_MAX_NUM]; // 用于HOST和AICPU侧同步的Notify资源，HOST侧申请传递给AICPU侧
831 : };
832 : struct HcclOneSideOpDescParam {
833 : u64 localAddr; // 本端VA
834 : u64 remoteAddr; // 远端VA
835 : u32 lkey; // 本端内存对应的key
836 : u32 rkey; // 远端内存对应的key
837 : u64 count; // 数据的个数
838 : u8 dataType; // 数据的类型
839 : };
840 : struct OpTilingOneSideCommDataDes {
841 : u64 commResParaAddr; // 记录HcclOneSideCommResParam地址
842 : u64 commResParaSize; // 记录HcclOneSideCommResParam大小
843 : u64 transportDataAddr; // 记录TransportDeviceNormalData地址
844 : u64 transportDataSize; // 记录TransportDeviceNormalData大小
845 : u32 rankSize;
846 : u32 linkTimeout; // RDMA发送重试超时时间
847 : u8 linkType; // 单边通信链路类型 LinkType, rdma: LinkType::LINK_ROCE sdma: LinkType::LINK_HCCS
848 : bool finalize; // 通信域销毁标志位
849 : u32 descNum; // 单边通信接口传入的descNum加1，最后1个为OpFence的位置
850 : u64 descDataLen; // TLV: T is opType in OpTilingData, L is descDataLen
851 : u64 desc[]; // desc的占位
852 : };
853 : #endif
|
