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 : } // namespace
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 端通过
242 : // RunAicpuKfcClearOpRes 投递，aicpu 端按 group 定位 HcclCommAicpu 后批量清 tags
243 : constexpr u32 HCCL_KFC_CLEAR_OP_RES_MAGIC = 0x484B4346U; // 'HKCF'，aicpu 端校验防误投
244 : constexpr u32 HCCL_KFC_CLEAR_OP_RES_MAX_BATCH = 10240U; // 单次 launch 最多清的 tag 数；10240×256B ≈ 2.5MB
245 : struct HcclKfcClearOpResTilingData {
246 : u32 magic; // 必须等于HCCL_KFC_CLEAR_OP_RES_MAGIC
247 : u32 tagCount; // 本批实际有效 tag 数 (1..MAX_BATCH)
248 : char group[HCOMID_MAX_LENGTH]; // communicator identifier
249 : char tags[HCCL_KFC_CLEAR_OP_RES_MAX_BATCH][TAG_MAX_LENGTH]; // 待清理 op tag 列表，含_Capture后缀
250 : };
251 :
252 : struct HcclOpConfigV2 {
253 : u8 deterministic; // 确定性计算开关
254 : };
255 :
256 : struct HcclMC2WorkSpaceV2 {
257 : u64 workSpace;
258 : u64 workSpaceSize;
259 : };
260 :
261 : struct HcclStreamInfoV2 {
262 : s32 streamIds;
263 : u32 sqIds;
264 : };
265 :
266 : struct ListCommon {
267 : u64 nextHost;
268 : u64 preHost;
269 : u64 nextDevice;
270 : u64 preDevice;
271 : };
272 :
273 828 : static inline void ListCommonInit(struct ListCommon* deviceList, struct ListCommon* hostList)
274 : {
275 827 : if (hostList == nullptr) {
276 0 : HCCL_ERROR("hostList[%p] is nullptr", hostList);
277 0 : return;
278 : }
279 828 : hostList->nextHost = reinterpret_cast<u64>(hostList);
280 828 : hostList->preHost = reinterpret_cast<u64>(hostList);
281 828 : hostList->nextDevice = reinterpret_cast<u64>(deviceList);
282 828 : hostList->preDevice = reinterpret_cast<u64>(deviceList);
283 : }
284 :
285 227 : static inline void ListCommonAddHead(
286 : struct ListCommon* newDeviceL, struct ListCommon* newHostL, struct ListCommon* headHostL,
287 : struct ListCommon* headDeviceL)
288 : {
289 227 : if (newHostL == nullptr || headHostL == nullptr) {
290 0 : HCCL_ERROR("input ptr is nullptr, newHostL[%p], headHostL[%p]", newHostL, headHostL);
291 0 : return;
292 : }
293 227 : ListCommon* headHostLNextHost = reinterpret_cast<ListCommon*>(headHostL->nextHost);
294 227 : headHostLNextHost->preHost = reinterpret_cast<u64>(newHostL);
295 227 : newHostL->nextHost = headHostL->nextHost;
296 227 : newHostL->preHost = reinterpret_cast<u64>(headHostL);
297 227 : headHostL->nextHost = reinterpret_cast<u64>(newHostL);
298 :
299 227 : headHostLNextHost->preDevice = reinterpret_cast<u64>(newDeviceL);
300 227 : newHostL->nextDevice = headHostL->nextDevice;
301 227 : newHostL->preDevice = reinterpret_cast<u64>(headDeviceL);
302 227 : headHostL->nextDevice = reinterpret_cast<u64>(newDeviceL);
303 : }
304 :
305 : // 跟 ListCommonAddHead 对称的双链表 unlink，同时维护 host 和 device 两套 prev/next 指针
306 4 : static inline void ListCommonRemove(struct ListCommon* nodeHostL)
307 : {
308 4 : if (nodeHostL == nullptr) {
309 1 : HCCL_ERROR("nodeHostL is nullptr");
310 1 : return;
311 : }
312 3 : ListCommon* prevHost = reinterpret_cast<ListCommon*>(nodeHostL->preHost);
313 3 : ListCommon* nextHost = reinterpret_cast<ListCommon*>(nodeHostL->nextHost);
314 3 : if (prevHost == nullptr || nextHost == nullptr) {
315 0 : HCCL_ERROR("nodeHostL link broken, preHost[%p] nextHost[%p]", prevHost, nextHost);
316 0 : return;
317 : }
318 3 : prevHost->nextHost = nodeHostL->nextHost;
319 3 : nextHost->preHost = nodeHostL->preHost;
320 3 : prevHost->nextDevice = nodeHostL->nextDevice;
321 3 : nextHost->preDevice = nodeHostL->preDevice;
322 : // 自指向，避免悬空指针被误访问（跟 ListCommonInit 后空链表状态一致）
323 3 : nodeHostL->nextHost = reinterpret_cast<u64>(nodeHostL);
324 3 : nodeHostL->preHost = reinterpret_cast<u64>(nodeHostL);
325 3 : nodeHostL->nextDevice = nodeHostL->nextHost;
326 3 : nodeHostL->preDevice = nodeHostL->preHost;
327 : }
328 :
329 : // KFC控制命令
330 : enum class KfcCommand : int64_t {
331 : kNone = 0, // 空命令
332 : kStopLaunch, // 停止算子下发
333 : kStopExec, // 停止算子执行
334 : kClear, // 清理算子状态&资源
335 : kChangeLink, // 切换主备链路
336 : kRetry, // 重新执行算子
337 : kExit, // 退出算子执行
338 : NsStopLaunch, // N秒快恢下的停止算子下发
339 : NsStopExec, // N秒快恢下的停止算子执行
340 : NsClear, // N秒快恢下的清理算子状态&资源
341 : NsChangeLink, // N秒快恢下的切换主备链路
342 : kDestroyComm, // 销毁AICPU通信域
343 : kSwitchNic, // 发起主动借轨
344 : kWaitSwitchNic, // 等待主动借轨完成
345 : kAllSwitched, // 通信域内的所有卡完成主动借轨
346 : kSwitchFail, // 主动借轨失败，回退借轨操作
347 : kReportRetryErr, // 退出算子执行，但支持step重计算
348 : };
349 :
350 : // AICPU背景线程控制
351 : enum class BackgroundCommand : int64_t {
352 : kNone = 0, // 空命令
353 : kStop,
354 : };
355 :
356 : // device侧感知目前通信域的状态
357 : enum class HcclComSuspendingFlag : int64_t {
358 : isNull = 0,
359 : isResume, // device侧感知是resume状态
360 : isSuspending, // device侧感知是suspending状态
361 : };
362 :
363 : // host向aicpu发送link状态
364 3 : using ChangeLinkInfo = struct ChangeLinkInfoDef {
365 : u32 remoteRankNum = 0;
366 : u32 remoteRankList[AICPU_MAX_RANK_NUM] = {};
367 : bool isUseDefaultPort[AICPU_MAX_RANK_NUM] = {};
368 : bool isChangeLinkFlag = false;
369 : };
370 :
371 : // host向aicpu发送的命令
372 : using KfcExecControl = struct KfcExecControlDef {
373 : KfcCommand kfcCmd; // 控制KFC执行
374 : BackgroundCommand bgCmd; // 控制背景线程执行
375 : HcclComSuspendingFlag suspendingStatus; // KFC状态
376 : HcclOpIdentifier targetOp;
377 : ChangeLinkInfo changeLinkInfo;
378 : };
379 :
380 : // KFC的执行状态
381 : enum class KfcStatus : int64_t {
382 : kNull = 0, // 算子的执行状态还没有initOpStatus前的状态
383 : kRuning,
384 : kEnd,
385 : kStoplaunch,
386 : kStopExec,
387 : kClear,
388 : kChanged,
389 : kError,
390 : kDestroyComm,
391 : kPlanSwitch,
392 : kSwitchError,
393 : kWaitSwitchRes,
394 : kSwitchSuccess,
395 : kSwitchFail,
396 : kRetryError, // 重执行失败状态
397 : kResumeError, // 恢复执行失败状态
398 : kResumeChanged, // 恢复过程借轨成功
399 : };
400 :
401 : // KFC的执行错误码
402 : enum class KfcError : int64_t {
403 : kNone = 0, // 无异常
404 : kSdma, // SDMA task执行失败
405 : kRdma, // RDMA task执行失败
406 : kTimeout, // task执行超时
407 : kInner, // 通信算子展开、task下发失败
408 : kExec, // 算子执行失败
409 : kExit, // 算子强行终止
410 : kExecConstraint, // 进入约束的算子重执行失败
411 : };
412 :
413 : enum class PollStatus : int64_t {
414 : kDefault = 0,
415 : kStopAsException,
416 : };
417 :
418 : enum class BackgroundStatus : int64_t {
419 : kNone = 0, // 正常状态
420 : kStop, // 背景线程停止状态
421 : };
422 :
423 : using KfcTaskException = struct KfcTaskExceptionDef {
424 : uint16_t streamId = 0;
425 : uint16_t taskId = 0;
426 : uint32_t errorCode = 0;
427 : uint8_t errorType = 0;
428 : uint8_t sqeType = 0;
429 : uint16_t sqId = 0;
430 : };
431 : using KfcRetryInfo = struct KfcRetryStatusDef {
432 : uint32_t retryCount = 0; // 已重试次数;
433 : };
434 :
435 : struct ErrorMessageReport {
436 : char tag[TAG_MAX_LENGTH] = {0};
437 : char group[GROUP_NAME_MAX_LEN + 1] = {0};
438 : u32 remoteUserRank = 0;
439 : s32 streamId = 0;
440 : u32 taskId = 0;
441 : u32 notifyId = 0;
442 : s32 stage = 0;
443 : u32 rankId = 0;
444 : u32 rankSize = 0;
445 : AlgType algType;
446 : hccl::TaskType taskType = hccl::TaskType::TASK_SDMA;
447 : uint64_t count = 0;
448 : uint64_t dstAddr = 0;
449 : uint64_t srcAddr = 0;
450 : uint32_t opIndex = 0; // 记录index
451 : uint32_t reduceType = 255; // 255 为 HcclReduceOp::HCCL_REDUCE_RESERVED
452 : uint8_t dataType = 0;
453 : };
454 :
455 : struct ExecStatusDef {
456 : KfcStatus kfcStatus; // KFC状态
457 : KfcError kfcError; // KFC错误码
458 : KfcRetryInfo retryInfo;
459 : KfcTaskException taskException;
460 : PollStatus pollStatus; // 背景线程状态
461 : BackgroundStatus backgroundStatus;
462 : };
463 :
464 : #pragma pack(push)
465 : #pragma pack(1)
466 : // aicpu向host提供的状态查询
467 : using KfcExecStatus = struct KfcExecStatusDef {
468 : HcclOpIdentifier opId;
469 : ExecStatusDef execStatus;
470 : ErrorMessageReport emrReport;
471 : };
472 : #pragma pack(pop)
473 :
474 : // P2P同步资源
475 : struct HcclLinkP2pV2 {
476 : MemDetails localMem[MEM_DETAILS_NUM];
477 : MemDetails remoteMem[MEM_DETAILS_NUM];
478 : HcclSignalInfo localIpcSignal[LINK_P2P_MAX_NUM]; // localnotify
479 : HcclSignalInfo remoteIpcSignal[LINK_P2P_MAX_NUM];
480 : hccl::TransportAttr transportAttr;
481 : };
482 :
483 : struct HcclLinkRoceV2 {
484 : MemDetails localMem[MEM_DETAILS_NUM];
485 : MemDetails remoteMem[MEM_DETAILS_NUM];
486 : u64 notifyValue{0}; // notify record的src地址value存储位置
487 : u32 notifyValueKey{0};
488 : u32 singleQPNotifyNum{0}; // one link multi notify resources nums obtained via alg
489 : u64 localNotifyList{0}; // devicePtrValue type:HcclSignalInfo size: [3,8192]
490 : u64 remoteNotifyList{0}; // devicePtrValue type:u64 size: [3,8192]
491 : u32 remoteNotifyKey{0}; // deprecated
492 : s64 chipId{LLONG_MAX}; // deprecated
493 : HcclQpInfoV2 QpInfo[RDMA_QP_MAX_NUM]; // ayyay size: [1, 1 + HCCL_RDMA_QPS_PER_CONNECTION_MAX]
494 : u32 qpsPerConnection{1}; // current link actual qp num obtained via env、workflowMode、qpMode
495 : bool useAtomicWrite{false}; // 是否使用atomic write
496 : };
497 :
498 : struct HccltagRemoteResV2 {
499 : ListCommon nextTagRes;
500 : char tag[TAG_MAX_LENGTH]; // newtag
501 : HcclLinkP2pV2 linkP2p;
502 : HcclLinkP2pV2 linkP2pSio;
503 : HcclLinkRoceV2 linkRoce[4];
504 : };
505 :
506 : struct HccltagRemoteResV3 {
507 : HccltagRemoteResV2* tagRemoteResPtr;
508 : u64 p2pNotifyNum = 0; // 用于linkp2p添加notify信息，不能超过Max个，超过报错（不区分local&remote）
509 : u64 roceNotifyNum = 0; // 主链路：用于linkroce添加notify信息，不能超过Max个，超过报错（不区分local&remote）
510 : u64 roceNotifyNumBackup = 0; // 备链路：用于linkroce添加notify信息，不能超过Max个，超过报错（不区分local&remote）
511 : u64 qpNum = 0; // 主链路：QP计数，支持多个，用于linkroce添加QP信息
512 : u64 qpNumBackup = 0; // 备链路：QP计数，支持多个，用于linkroce添加QP信息
513 : };
514 :
515 : struct HcclRankRelationResV2 {
516 : u32 remoteUsrRankId = 0;
517 : u32 remoteWorldRank = 0;
518 : u64 windowsIn = 0;
519 : u64 windowsOut = 0;
520 : u64 windowsExp = 0;
521 : ListCommon nextTagRes = {}; // HccltagRemoteResV2(根据tag区分)
522 : };
523 :
524 : struct HccltagLocalResV2 { // TAG专用,scratchmem，
525 : ListCommon nextTagRes; // 为0时，为尾节点
526 : char tag[TAG_MAX_LENGTH]; // 通信域内共享的资源则与通信域的hcomid相同
527 : u64 ScratchmemSize; // 为0时代表没有使用Scratchmem
528 : u64 Scratchmem;
529 : };
530 :
531 : // 预留占位内存
532 : struct ReservedStruct {
533 : u32 streamNum;
534 : u32 signalNum;
535 : HcclSignalInfo localSignals[LOCAL_NOTIFY_MAX_NUM];
536 : HcclStreamInfo
537 : streamInfo[19]; // 19为630版本数组的实际大小，不能使用已经变更为40的LOCAL_STREAM_MAX_NUM，否则会有兼容问题
538 : HcclStreamInfo mainStreamInfo;
539 : HcclSignalInfo aicpuOpNotify[AICPU_OP_NOTIFY_MAX_NUM]; // 集合通信AICPU展开资源
540 : ListCommon nextTagRes; // HccltagLocalResV2
541 : };
542 :
543 : // 卡内主从流同步，下沉图，单算子，通信域内复用
544 : struct LocalResInfoV2 {
545 : u32 streamNum;
546 : u32 signalNum;
547 : HcclSignalInfo localSignals[LOCAL_NOTIFY_MAX_NUM];
548 : HcclStreamParam streamParam[LOCAL_STREAM_MAX_NUM];
549 : HcclStreamParam mainStreamParam;
550 : HcclSignalInfo aicpuOpNotify[AICPU_OP_NOTIFY_MAX_NUM]; // 集合通信AICPU展开资源
551 : ListCommon nextTagRes; // HccltagLocalResV2
552 : };
553 :
554 : struct CommonTlv {
555 : TAG_TYPE type;
556 : LENGTH_TYPE length; // 本TLV总字节数，包括Type和length
557 : RANK_TYPE value;
558 : };
559 :
560 : struct AlgoTopoInfo {
561 : u32 userRank; // 通信域 RankID
562 : u32 userRankSize; // 通信域的 Rank数量
563 : s32 deviceLogicId;
564 : bool isSingleMeshAggregation;
565 : u32 deviceNumPerAggregation; // 每个module中的Device数量
566 : u32 superPodNum; // 集群中总的超节点数
567 : u32 devicePhyId;
568 : u32 topoType; // TopoType
569 : u32 deviceType;
570 : u32 serverNum;
571 : u32 meshAggregationRankSize;
572 : u32 multiModuleDiffDeviceNumMode;
573 : u32 multiSuperPodDiffServerNumMode;
574 : u32 realUserRank;
575 : bool isDiffDeviceModule;
576 : bool isDiffDeviceType;
577 : u32 gcdDeviceNumPerAggregation;
578 : u32 moduleNum;
579 : u32 isUsedRdmaRankPairNum;
580 : u64 isUsedRdmaRankPair;
581 : u32 pairLinkCounterNum;
582 : u64 pairLinkCounter;
583 : u32 nicNum;
584 : u64 nicList; // niclist数组指针
585 : u64 complanRankLength; // complanRank占用的字节数
586 : u64 complanRank; // 指针
587 : u64 bridgeRankNum; // bridgeRank占用的个数
588 : u64 bridgeRank; // 指针
589 : u64 serverAndsuperPodRankLength; // serverAndsuperPodRank占用的字节数
590 : u64 serverAndsuperPodRank; // 指针
591 : };
592 : struct RemoteResPtr {
593 : u64 nextHostPtr;
594 : u64 nextDevicePtr;
595 : };
596 :
597 : constexpr u32 ZERO_COPY_BUFFER_MAX_MAP_COUNT = 16 * 32 * 1024; // 16卡，一次每卡最多32k个映射修改
598 : constexpr u32 ZERO_COPY_IPC_BUFFER_LENGTH = 4096; // 跨进程交换地址所需buffer长度
599 : struct LocalIpc2RemoteAddr {
600 : u32 devicePhyId = 0;
601 : u64 localIpcAddr = 0;
602 : u64 remoteAddr = 0;
603 : u64 length = 0;
604 : };
605 :
606 : enum class ZeroCopyItemType : u32 { SET_MEMORY, UNSET_MEMORY, ACTIVATE_MEMORY, DEACTIVATE_MEMORY };
607 :
608 : struct ZeroCopyRingBufferItem {
609 : ZeroCopyItemType type;
610 : LocalIpc2RemoteAddr addr;
611 : };
612 :
613 : // 层次化算法信息
614 : struct HierarchicalAlgInfo {
615 : u64 commplaneSubGroupRankLength; // complanSubGroupRank占用的字节数
616 : u64 commplaneSubGroupRank; // 指针
617 : u32 hierarchicalAlgOptionNum;
618 : u64 hierarchicalAlgOptionVec; // hierarchicalAlgOptionVec数组指针
619 : };
620 :
621 : constexpr u32 HCCL_TAG_SIZE = 256;
622 : constexpr u32 OPINFO_RING_BUFFER_MAX = 2048;
623 : struct AicpuOpInfo {
624 : char tagBuff[HCCL_TAG_SIZE]{0}; // 记录tag信息
625 : uint32_t opIndex = 0; // 记录算子下发index
626 : uint64_t count = 0;
627 : uint8_t dataType = 0;
628 : uint8_t opType = 0; // 算子类型
629 : uint32_t rootId;
630 : uint64_t dstAddr = 0;
631 : uint64_t srcAddr = 0;
632 : uint32_t reduceType = 255; // 255 为 HcclReduceOp::HCCL_REDUCE_RESERVED
633 : uint32_t opExecIndex = 0; // 记录算子执行index
634 : bool isCustom = false;
635 : };
636 :
637 : struct TaskExceptionParam {
638 : u32 opRingBufferIdx = 0; // 记录算子信息在AicpuOpInfo数组里的下标
639 : AicpuOpInfo opInfo[OPINFO_RING_BUFFER_MAX]; // 用于记录每个task对应的算子入参信息
640 : };
641 :
642 : // aicpu和custom进程需要交互的部分信息
643 : struct AicpuCustomParam {
644 : TaskExceptionParam taskExceptionParam; // 故障上报信息
645 : };
646 :
647 : // 注意，本数据结构整体均被MC2不同算子使用
648 : // MC2使用偏移量访问整个数据结构，不能调整任意的位置，长度等信息
649 : struct HcclOpResParam {
650 : // 本地资源
651 : HcclMC2WorkSpace mc2WorkSpace;
652 : u32 localUsrRankId; // usrrankid
653 : u32 rankSize; // 通信域内total rank个数
654 : u64 winSize; // 每个win大小，静态图时，可能为0，如果通信域内也有动态图，则可能为非0
655 : u64 localWindowsIn; // 全F为无效值
656 : u64 localWindowsOut; // 全F为无效值
657 : char hcomId[128];
658 : u64 winExpSize;
659 : u64 localWindowsExp;
660 : // aicore识别remote window
661 : u32 rWinStart; // 为HcclRankRelationRes起始位置
662 : u32 rWinOffset; // 为HcclRemoteRes的大小
663 : u64 version;
664 : ReservedStruct reservedStrcut;
665 : AlgoTopoInfo topoInfo;
666 :
667 : // 外部配置参数
668 : HcclOpConfig config;
669 : u64 hostStateInfo;
670 : u64 aicpuStateInfo;
671 : u64 lockAddr;
672 : u32 rsv[16];
673 : u32 notifysize; // RDMA场景使用，910B/910_93为4B，其余芯片为8B
674 : u32 remoteResNum; // 有效的remoteResNum
675 : RemoteResPtr remoteRes[AICPU_MAX_RANK_NUM]; // 数组指针，指向HcclRankRelationResV2，下标为remoteUserRankId
676 :
677 : // communicate retry
678 : hccl::HDCommunicateParams kfcControlTransferH2DParams;
679 : hccl::HDCommunicateParams kfcStatusTransferD2HParams;
680 :
681 : u64 tinyMem; // for all2all
682 : u64 tinyMemSize;
683 :
684 : // 零拷贝场景使用
685 : u64 zeroCopyHeadPtr;
686 : u64 zeroCopyTailPtr;
687 : u64 zeroCopyRingBuffer;
688 : u64 zeroCopyIpcPtrs[AICPU_ZERO_COPY_MAX_DEVICE_NUM_A3]; // 保存集合通信时每个对端的输入输出内存地址
689 : u32 zeroCopyDevicePhyId[AICPU_ZERO_COPY_MAX_DEVICE_NUM_A3]; // 保存每个rank对应的物理卡Id
690 :
691 : bool utraceStatusFlag;
692 :
693 : OpCounterInfo opCounterInfo;
694 :
695 : HierarchicalAlgInfo hierarchicalAlgInfo;
696 : LocalResInfoV2 localRes;
697 : u64 debugConfig = 0; // 环境变量HCCL_DEBUG_CONFIG, 考虑兼容性放在结构体末尾
698 :
699 : // aicpu和custom进程需要交互的部分信息
700 : u64 aicpuCustomParamAddr;
701 : u64 aicpuCustomParamSize;
702 :
703 : // 外部mc2等算子使用偏移量访问
704 : MemDetails userMemRes[MAX_RANK_NUM_A3]; // 下标为rank id
705 : u32 userMemType = 0; // 0:CCL Buffer; 1:user Mem
706 :
707 : HcclStreamParam aicpuOrderStreamParam; // 按序下发的stream
708 : u64 aicpuOrderNotifyAddr;
709 : u64 aicpuOrderNotifySize;
710 : // ARS算法属性
711 : u32 multiSuperPodDiffDeviceNumMode;
712 : bool isARSDoubleRing;
713 : // 读取HCCL_ENTRY_LOG_ENABLE环境变量，用于增加算子kernel展开信息
714 : bool opEntry{false};
715 : uint32_t hcclSdmaQos; // HCCL SDMA QOS TAG
716 : // 外部mc2等算子跨框AIV场景使用
717 : u64 sizeOfAiRMAInfo = 0; // sizeof(HcclAiRMAInfo), 用于内存校验
718 : u64 aiRMAInfo = 0; // HcclAiRMAInfo* 单个结构体指针
719 : };
720 :
721 : struct OpTilingData {
722 : char tag[128];
723 : char newTag[256];
724 : char algName[128];
725 : u32 index; // 集合通信算子在通信域内的编号，aicpu侧使用时区分算子类型(bsr、sendrecv、其他)单独计数
726 : u64 algType;
727 : u8 floatOverflowMode;
728 : u8 dumpDebug;
729 : u8 debugMode;
730 : u8 workflowMode;
731 : u64 inputPtr;
732 : u64 outputPtr;
733 : u8 reduceType; // HcclReduceOp ::HCCL_REDUCE_RESERVED
734 : u8 syncMode; // SyncMode::DEFAULT_TIMEWAITSYNCMODE;
735 : RankId root = INVALID_VALUE_RANKID;
736 : RankId dstRank = 0;
737 : RankId srcRank = 0;
738 : u8 opType; // HcclCMDType::HCCL_CMD_INVALID;
739 : u8 inplaceSupportRetry;
740 : u8 retryEnable;
741 : u8 inPlaceSupportRetryStatus;
742 : u8 isInplacePreSync;
743 : u8 isPostSync;
744 : u8 isZeroCopy = 0;
745 : u64 version = 0;
746 : s32 userStreamId;
747 : u32 ahcConfInfo[TOP_HIERARCHICAL_CONF_SIZE] = {0};
748 : uint8_t aicpuCacheEnable = 0; // 是否开启aicpu cache
749 : u8 isSymmetricMemory = 0;
750 : u64 inputSymWindow;
751 : u64 inputOffset = 0;
752 : u64 outputSymWindow;
753 : u64 outputOffset = 0;
754 :
755 : /******************可变长度数据区，如需新增字段请在这之前增加*******************/
756 : u64 length; // 可变长度数据区长度
757 : u64 customDataLength; // 用户自定义预留可变长度数据区长度，预期在aicpu侧做数据块校验
758 : u8 isCapture = 0; // 算子是否aclgraph模式
759 : u8 orderLaunchMode = 0; // 对应AicpuNotifyMode的枚举值
760 : u8 needIncreLink = 0; // 是否需要增量建链
761 :
762 : /* 不同算子，长度不同，依据opType决定选择使用
763 : * (1)batchsendrcv
764 : * struct {
765 : * u32 itemNum;
766 : * HcclSendRecvItem orderedList[itemNum];
767 : * } OpTilingBatchSendRecvDataDes;
768 : * (2)alltoallv
769 : * struct {
770 : * u8 sendType; // HcclDataType
771 : * u8 recvType; // HcclDataType
772 : * u32 rankSize;
773 : * u64 sendCounts[rankSize];
774 : * u64 recvCounts[rankSize];
775 : * u64 sdispls[rankSize];
776 : * u64 rdispls[rankSize];
777 : * };
778 : * (3)alltoallvc
779 : * struct {
780 : * u8 sendType; // HcclDataType
781 : * u8 recvType; // HcclDataType
782 : * u32 rankSize;
783 : * u64 sendCountMatrix[rankSize * rankSize];
784 : * };
785 : * (4)alltoall
786 : * struct {
787 : * u8 sendType; // HcclDataType
788 : * u8 recvType; // HcclDataType
789 : * u64 sendCount;
790 : * u64 recvCount;
791 : * };
792 : * (5)other operators
793 : * struct {
794 : * u64 count;
795 : * u8 datatype; // HcclDataType
796 : * }; */
797 : };
798 : struct OpTilingDataDes {
799 : u64 count;
800 : u8 dataType;
801 : };
802 : struct OpTilingVDataDes {
803 : u8 dataType; // HcclDataType
804 : u64 vDataLen; // TLV: T is opType in OpTilingData, L is vData length
805 : u64 vData[]; // counts/displs
806 : };
807 : struct OpTilingBatchSendRecvDataDes {
808 : u32 itemNum;
809 : HcclSendRecvItem batchSendRecvItem[];
810 : };
811 : struct OpTilingAllToAllDataDes {
812 : u8 sendType; // HcclDataType
813 : u8 recvType; // HcclDataType
814 : u64 sendCount;
815 : };
816 : struct OpTilingAlltoallvDataDes {
817 : u8 sendType; // HcclDataType
818 : u8 recvType; // HcclDataType
819 : u64 sendRecvInfos[];
820 : };
821 : struct OpTilingAlltoallvcDataDes {
822 : u8 sendType; // HcclDataType
823 : u8 recvType; // HcclDataType
824 : u64 sendCountMatrix[];
825 : };
826 : struct HcclOneSideCommResParam { // 单边通信使用的Stream和Notify资源
827 : HcclStreamParam execStreamParam; // HOST侧申请传递给AICPU侧使用的执行流
828 : HcclSignalInfo aicpuOpNotify[AICPU_OP_NOTIFY_MAX_NUM]; // 用于HOST和AICPU侧同步的Notify资源，HOST侧申请传递给AICPU侧
829 : };
830 : struct HcclOneSideOpDescParam {
831 : u64 localAddr; // 本端VA
832 : u64 remoteAddr; // 远端VA
833 : u32 lkey; // 本端内存对应的key
834 : u32 rkey; // 远端内存对应的key
835 : u64 count; // 数据的个数
836 : u8 dataType; // 数据的类型
837 : };
838 : struct OpTilingOneSideCommDataDes {
839 : u64 commResParaAddr; // 记录HcclOneSideCommResParam地址
840 : u64 commResParaSize; // 记录HcclOneSideCommResParam大小
841 : u64 transportDataAddr; // 记录TransportDeviceNormalData地址
842 : u64 transportDataSize; // 记录TransportDeviceNormalData大小
843 : u32 rankSize;
844 : u32 linkTimeout; // RDMA发送重试超时时间
845 : u8 linkType; // 单边通信链路类型 LinkType, rdma: LinkType::LINK_ROCE sdma: LinkType::LINK_HCCS
846 : bool finalize; // 通信域销毁标志位
847 : u32 descNum; // 单边通信接口传入的descNum加1，最后1个为OpFence的位置
848 : u64 descDataLen; // TLV: T is opType in OpTilingData, L is descDataLen
849 : u64 desc[]; // desc的占位
850 : };
851 : #endif
|
