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 : #ifndef TASK_PARAM_H
11 : #define TASK_PARAM_H
12 :
13 : #include <vector>
14 : #include <string>
15 : #include <memory>
16 : #include "securec.h"
17 : #include "hccl/base.h"
18 : #include "const_val.h"
19 : #include "enum_factory_legacy.h"
20 : #include "ip_address.h"
21 : #include "op_type.h"
22 :
23 : namespace Hccl {
24 :
25 181 : MAKE_ENUM(DmaOp, HCCL_DMA_READ, HCCL_DMA_WRITE, HCCL_DMA_NOTIFY_WAIT)
26 :
27 117 : MAKE_ENUM(AlgType, NOT_SPECIFIED, RING, MULTI_RING, MESH, RECURSIVE_HD, BINARY_HD, PAIR_WISE, INVALID_VAL)
28 :
29 436378 : MAKE_ENUM(
30 : TaskParamType, TASK_SDMA, TASK_RDMA, TASK_REDUCE_INLINE, TASK_REDUCE_TBE, TASK_NOTIFY_RECORD, TASK_NOTIFY_WAIT,
31 : TASK_SEND_NOTIFY, TASK_SEND_PAYLOAD, TASK_WRITE_WITH_NOTIFY, TASK_WRITE_REDUCE_WITH_NOTIFY, TASK_CCU,
32 : TASK_AICPU_KERNEL, TASK_AICPU_REDUCE, TASK_AIV, TASK_UB_INLINE_WRITE, TASK_UB_REDUCE_INLINE, TASK_UB,
33 : TASK_DPU_KERNEL, TASK_DPU_THREAD_FENCE, TASK_DPU_CHANNEL_FENCE, TASK_DPU_INLINE_WRITE, TASK_DPU_NOTIFY_WAIT,
34 : TASK_DPU_WRITE_WITH_NOTIFY)
35 :
36 247 : MAKE_ENUM(DfxLinkType, ONCHIP, HCCS, PCIE, ROCE, SIO, HCCS_SW, STANDARD_ROCE, UB, UBoE, RESERVED)
37 :
38 : MAKE_ENUM(CcuProfilinType, CCU_TASK_PROFILING, CCU_WAITCKE_PROFILING, CCU_LOOPGROUP_PROFILING, CCU_MAP_PROFILING)
39 :
40 : constexpr uint16_t CCU_MAX_CHANNEL_NUM = 16; // 最多16条link
41 : constexpr uint16_t INVALID_CKE_ID = 0xFFFF; // CKE ID非法值
42 : constexpr uint16_t INVALID_VALUE_CHANNELID = 0xFFFF; // channel id非法值
43 : constexpr u64 INVALID_VALUE_NOTIFYID = 0xFFFFFFFFFFFFFFFF; // NOTIFY id非法值
44 : constexpr u32 INVALID_VALUE_RANKID = 0xFFFFFFFF; // rank id非法值
45 : struct CcuProfilingInfo {
46 : std::string name; // CCU任务名或微码名
47 : uint8_t type; // 枚举，0为Task粒度，1为WaitCKE，2为LoopGroup，3为channelId->RemoteRankId的映射
48 : uint8_t dieId; // CCU任务执行的DieId
49 : uint8_t missionId; // CCU任务执行的MissionId
50 : uint16_t instrId;
51 : uint8_t reduceOpType; // 与HcclReduceOp类型保持一致
52 : uint8_t inputDataType; // 与HcclDataType类型保持一致
53 : uint8_t outputDataType; // 与HcclDataType类型保持一致
54 : uint64_t dataSize; // 输入数据大小
55 : uint32_t ckeId;
56 : uint32_t mask;
57 : uint16_t channelId[CCU_MAX_CHANNEL_NUM]; // LoopGroup所包含的搬运指令使用的ChannelId
58 : uint32_t remoteRankId[CCU_MAX_CHANNEL_NUM]; // LoopGroup所包含的搬运指令的对端
59 : uint64_t channelHandle[CCU_MAX_CHANNEL_NUM]; // channelhandle句柄
60 :
61 295 : CcuProfilingInfo()
62 590 : : name(""),
63 295 : type(0),
64 295 : dieId(0),
65 295 : missionId(0),
66 295 : instrId(0),
67 295 : reduceOpType(0),
68 295 : inputDataType(0),
69 295 : outputDataType(0),
70 295 : dataSize(0),
71 295 : ckeId(0),
72 295 : mask(0)
73 : {
74 295 : (void)memset_s(channelId, sizeof(channelId), INVALID_VALUE_CHANNELID, sizeof(channelId));
75 5015 : for (u32 i = 0; i < CCU_MAX_CHANNEL_NUM; i++) {
76 4720 : remoteRankId[i] = INVALID_VALUE_RANKID;
77 : }
78 5015 : for (u32 i = 0; i < CCU_MAX_CHANNEL_NUM; i++) {
79 4720 : channelHandle[i] = INVALID_VALUE_NOTIFYID;
80 : }
81 295 : }
82 : };
83 : constexpr u32 ADD_LEN = 128;
84 : struct ParaDMA {
85 : const void* src;
86 : const void* dst;
87 : std::size_t size;
88 : u64 notifyID;
89 : u32 notifyValue;
90 : DfxLinkType linkType;
91 : DmaOp dmaOp;
92 : Eid locEid{};
93 : Eid rmtEid{};
94 : char locAddr[ADD_LEN]{};
95 : char rmtAddr[ADD_LEN]{};
96 : uint64_t jettyHandle{0};
97 : uint32_t jettyId{0};
98 : };
99 :
100 : struct ParaReduce {
101 : const void* src;
102 : const void* dst;
103 : std::size_t size;
104 : u64 notifyID;
105 : u32 notifyValue;
106 : DfxLinkType linkType;
107 : HcclReduceOp reduceOp{HcclReduceOp::HCCL_REDUCE_RESERVED};
108 : HcclDataType dataType{HcclDataType::HCCL_DATA_TYPE_RESERVED};
109 : Eid locEid{};
110 : Eid rmtEid{};
111 : uint64_t jettyHandle{0};
112 : uint32_t jettyId{0};
113 : };
114 :
115 : struct ParaNotify {
116 : u64 notifyID;
117 : u32 value;
118 : };
119 :
120 : struct ParaCcu {
121 : u8 dieId;
122 : u8 missionId;
123 : u8 execMissionId;
124 : u32 instrId;
125 : u64 executeId;
126 : u64 ccuKernelHandle{0};
127 : };
128 :
129 : struct ParaAiv {
130 : HcclCMDType cmdType;
131 : u32 tag;
132 : u64 count;
133 : u32 numBlocks;
134 : u32 rankSize;
135 : void* flagMem;
136 : u64 flagMemSize;
137 : u32 rank;
138 : u32 sendRecvRemoteRank;
139 : HcclDataType dataType;
140 : };
141 :
142 : struct TaskParam {
143 : TaskParamType taskType;
144 : u64 beginTime;
145 : u64 endTime;
146 : u64 aicpuTaskId{0};
147 : uint16_t npuDevId{0};
148 : bool isMaster{false};
149 : union {
150 : ParaDMA DMA; // taskType = SDMA/RDMA使用, 包括rtRDMASend写notify
151 : ParaReduce Reduce; // taskType = inline/CCE Reduce使用
152 : ParaNotify Notify; // taskType = Noitfy Record/Wait使用
153 : ParaCcu Ccu;
154 : ParaAiv Aiv; // aiv param
155 : } taskPara;
156 : std::shared_ptr<std::vector<CcuProfilingInfo>> ccuDetailInfo; // taskType为TASK_CCU时，ParaCcu的补充profiling信息
157 24 : std::string Describe() const
158 : {
159 48 : return StringFormat(
160 : "TaskParam[taskType[%s] beginTime[%llu] endTime[%llu] aicpuTaskId[%llu]",
161 48 : taskType.Describe().c_str(), beginTime, endTime, aicpuTaskId)
162 72 : + DescribeDetail(*this) + "]";
163 : }
164 :
165 : private:
166 24 : static std::string DescribeDetail(const TaskParam& param)
167 : {
168 24 : std::string result;
169 24 : switch (param.taskType) {
170 2 : case TaskParamType::TASK_SDMA:
171 : case TaskParamType::TASK_RDMA:
172 : case TaskParamType::TASK_SEND_PAYLOAD:
173 : case TaskParamType::TASK_UB_INLINE_WRITE:
174 : case TaskParamType::TASK_UB:
175 : case TaskParamType::TASK_WRITE_WITH_NOTIFY:
176 : case TaskParamType::TASK_WRITE_REDUCE_WITH_NOTIFY:
177 : case TaskParamType::TASK_DPU_INLINE_WRITE:
178 : case TaskParamType::TASK_DPU_WRITE_WITH_NOTIFY:
179 6 : result += StringFormat(
180 : " src[%p] dst[%p] size[%zu] notifyID[%llu] dmaOp[%s] linkType[%s] jettyHandle[%llu] jettyId[%u]",
181 2 : param.taskPara.DMA.src, param.taskPara.DMA.dst, param.taskPara.DMA.size,
182 6 : param.taskPara.DMA.notifyID, param.taskPara.DMA.dmaOp.Describe().c_str(),
183 2 : param.taskPara.DMA.linkType.Describe().c_str(), param.taskPara.DMA.jettyHandle,
184 4 : param.taskPara.DMA.jettyId);
185 2 : break;
186 2 : case TaskParamType::TASK_REDUCE_INLINE:
187 : case TaskParamType::TASK_UB_REDUCE_INLINE:
188 : case TaskParamType::TASK_REDUCE_TBE:
189 4 : result += StringFormat(
190 : " src[%p] dst[%p] size[%zu] notifyID[%llu] reduceOp[%d] dataType[%d] linkType[%s] "
191 : "jettyHandle[%llu] "
192 : "jettyId[%u]",
193 2 : param.taskPara.Reduce.src, param.taskPara.Reduce.dst, param.taskPara.Reduce.size,
194 2 : param.taskPara.Reduce.notifyID, static_cast<int>(param.taskPara.Reduce.reduceOp),
195 4 : static_cast<int>(param.taskPara.Reduce.dataType), param.taskPara.Reduce.linkType.Describe().c_str(),
196 4 : param.taskPara.DMA.jettyHandle, param.taskPara.DMA.jettyId);
197 2 : break;
198 13 : case TaskParamType::TASK_NOTIFY_RECORD:
199 : case TaskParamType::TASK_NOTIFY_WAIT:
200 : case TaskParamType::TASK_SEND_NOTIFY:
201 : case TaskParamType::TASK_DPU_NOTIFY_WAIT:
202 : case TaskParamType::TASK_DPU_CHANNEL_FENCE:
203 13 : result += StringFormat(
204 13 : " notifyID[%llu] value[%u]", param.taskPara.Notify.notifyID, param.taskPara.Notify.value);
205 13 : break;
206 0 : case TaskParamType::TASK_AIV:
207 0 : result += StringFormat(
208 : " cmdType[%d] tag[%u] count[%llu] numBlocks[%u] rankSize[%u]"
209 : " rank[%u] remoteRank[%u] dataType[%d]",
210 0 : static_cast<int>(param.taskPara.Aiv.cmdType), param.taskPara.Aiv.tag, param.taskPara.Aiv.count,
211 0 : param.taskPara.Aiv.numBlocks, param.taskPara.Aiv.rankSize, param.taskPara.Aiv.rank,
212 0 : param.taskPara.Aiv.sendRecvRemoteRank, static_cast<int>(param.taskPara.Aiv.dataType));
213 0 : break;
214 0 : case TaskParamType::TASK_CCU:
215 0 : result += StringFormat(
216 0 : " dieId[%u] missionId[%u] execMissionId[%u] instrId[%u] executeId[%llu]", param.taskPara.Ccu.dieId,
217 0 : param.taskPara.Ccu.missionId, param.taskPara.Ccu.execMissionId, param.taskPara.Ccu.instrId,
218 0 : param.taskPara.Ccu.executeId);
219 0 : break;
220 7 : default:
221 7 : break;
222 : }
223 24 : return result;
224 0 : }
225 : };
226 :
227 : const std::map<HcclCMDType, std::pair<Hccl::OpType, std::string>> CMD_OP_TYPE_INFO_MAP = {
228 : {HcclCMDType::HCCL_CMD_ALLREDUCE, {Hccl::OpType::ALLREDUCE, "OpType::ALLREDUCE"}},
229 : {HcclCMDType::HCCL_CMD_ALLGATHER, {Hccl::OpType::ALLGATHER, "OpType::ALLGATHER"}},
230 : {HcclCMDType::HCCL_CMD_REDUCE_SCATTER, {Hccl::OpType::REDUCESCATTER, "OpType::REDUCESCATTER"}},
231 : {HcclCMDType::HCCL_CMD_SEND, {Hccl::OpType::SEND, "OpType::SEND"}},
232 : {HcclCMDType::HCCL_CMD_RECEIVE, {Hccl::OpType::RECV, "OpType::RECV"}},
233 : {HcclCMDType::HCCL_CMD_ALLTOALL, {Hccl::OpType::ALLTOALL, "OpType::ALLTOALL"}},
234 : {HcclCMDType::HCCL_CMD_ALLTOALLV, {Hccl::OpType::ALLTOALLV, "OpType::ALLTOALLV"}},
235 : {HcclCMDType::HCCL_CMD_BROADCAST, {Hccl::OpType::BROADCAST, "OpType::BROADCAST"}},
236 : {HcclCMDType::HCCL_CMD_ALLGATHER_V, {Hccl::OpType::ALLGATHERV, "OpType::ALLGATHERV"}},
237 : {HcclCMDType::HCCL_CMD_REDUCE_SCATTER_V, {Hccl::OpType::REDUCESCATTERV, "OpType::REDUCESCATTERV"}},
238 : {HcclCMDType::HCCL_CMD_REDUCE, {Hccl::OpType::REDUCE, "OpType::REDUCE"}},
239 : {HcclCMDType::HCCL_CMD_ALLTOALLVC, {Hccl::OpType::ALLTOALLVC, "OpType::ALLTOALLVC"}},
240 : {HcclCMDType::HCCL_CMD_SCATTER, {Hccl::OpType::SCATTER, "OpType::SCATTER"}},
241 : {HcclCMDType::HCCL_CMD_BATCH_SEND_RECV, {Hccl::OpType::BATCHSENDRECV, "OpType::BATCHSENDRECV"}},
242 : {HcclCMDType::HCCL_CMD_HALF_ALLTOALLV, {Hccl::OpType::HALFALLTOALLV, "OpType::HALFALLTOALLV"}},
243 : {HcclCMDType::HCCL_CMD_BARRIER, {Hccl::OpType::BARRIER, "OpType::BARRIER"}},
244 : {HcclCMDType::HCCL_CMD_GATHER, {Hccl::OpType::GATHER, "OpType::GATHER"}},
245 : {HcclCMDType::HCCL_CMD_BATCH_GET, {Hccl::OpType::BATCHGET, "OpType::BATCHGET"}},
246 : {HcclCMDType::HCCL_CMD_BATCH_PUT, {Hccl::OpType::BATCHPUT, "OpType::BATCHPUT"}},
247 : };
248 :
249 : } // namespace Hccl
250 :
251 : #endif
|
