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 FFTS_COMMON_PUB_H
12 : #define FFTS_COMMON_PUB_H
13 :
14 : #include <cstdint>
15 : #include <map>
16 : #include <vector>
17 : #include <memory>
18 :
19 : #include "hccl/base.h"
20 : #include "adapter_rts_common.h"
21 : #include "hccl_common.h"
22 : #include "common.h"
23 : #include "device_capacity.h"
24 :
25 : namespace hccl {
26 : enum class ReduceType { INLINE_REDUCE = 0, TBE_REDUCE };
27 :
28 : enum class CopyPattern { ZCOPY = 0, BCOPY };
29 :
30 : using HcclOpMetaInfo = struct HcclOpMetaInfoDef {
31 : HcclCMDType opType = HcclCMDType::HCCL_CMD_INVALID;
32 : bool isRootRank = false;
33 : bool isSmallCount = false;
34 : uint32_t rootRank = INVALID_UINT;
35 : uint32_t KEY_SIZE = 100;
36 : bool isDefaultPath = true; // 是否为默认子图路径
37 : ReduceType reduceType = ReduceType::INLINE_REDUCE;
38 : CopyPattern copyPattern = CopyPattern::BCOPY;
39 : u64 alltoallvSendDataSize = 0;
40 : u64 alltoallvcSendDataSize = 0;
41 : u32 piplineSliceNum = 1;
42 : HcclDataType dataType = HCCL_DATA_TYPE_RESERVED;
43 : u32 algolevel1Type = 0;
44 : bool hugeData = false;
45 : u64 sliceNum = 1;
46 : bool dataSplit = false;
47 : bool isAivMode = false;
48 : bool isEnableCache = true;
49 : u8 deterministic = 0;
50 : bool preloadCopyOpt = false;
51 :
52 56 : static bool CheckEnableCache(const HcclOpMetaInfoDef& opMetaInfo)
53 : {
54 56 : if (opMetaInfo.opType == HcclCMDType::HCCL_CMD_BATCH_SEND_RECV
55 56 : || opMetaInfo.opType == HcclCMDType::HCCL_CMD_SEND || opMetaInfo.opType == HcclCMDType::HCCL_CMD_RECEIVE
56 56 : || opMetaInfo.hugeData) {
57 0 : return false;
58 : }
59 :
60 56 : if (opMetaInfo.alltoallvSendDataSize > RDMA_SEND_MAX_SIZE
61 56 : || opMetaInfo.alltoallvcSendDataSize > RDMA_SEND_MAX_SIZE) {
62 0 : return false;
63 : }
64 56 : return !(
65 56 : (opMetaInfo.opType == HcclCMDType::HCCL_CMD_ALLTOALLV || opMetaInfo.opType == HcclCMDType::HCCL_CMD_ALLTOALL
66 56 : || opMetaInfo.opType == HcclCMDType::HCCL_CMD_ALLTOALLVC)
67 56 : && (opMetaInfo.copyPattern == CopyPattern::BCOPY));
68 : }
69 :
70 22 : static HcclOpMetaInfoDef GetOneForAllReduce(
71 : u32 algolevel1Type = 0, HcclDataType dataType = HCCL_DATA_TYPE_RESERVED,
72 : ReduceType reduceType = ReduceType::INLINE_REDUCE, bool isSmallCount = false, u32 piplineSliceNum = 1,
73 : bool hugeData = false, CopyPattern copyPattern = CopyPattern::BCOPY, u64 sliceNum = 1,
74 : bool isAivModeConfig = false, bool isDefaultPathConfig = true, bool dataSplitConfig = false,
75 : u8 deterministicConfig = 0)
76 : {
77 22 : HcclOpMetaInfoDef meta;
78 22 : meta.opType = HcclCMDType::HCCL_CMD_ALLREDUCE;
79 22 : meta.copyPattern = copyPattern;
80 22 : meta.reduceType = reduceType;
81 22 : meta.dataType = dataType;
82 22 : meta.isSmallCount = isSmallCount;
83 22 : meta.piplineSliceNum = piplineSliceNum;
84 22 : meta.algolevel1Type = algolevel1Type;
85 22 : meta.hugeData = hugeData;
86 22 : meta.sliceNum = sliceNum;
87 22 : meta.isAivMode = isAivModeConfig;
88 22 : meta.isEnableCache = CheckEnableCache(meta);
89 22 : meta.isDefaultPath = isDefaultPathConfig;
90 22 : meta.dataSplit = dataSplitConfig;
91 22 : meta.deterministic = deterministicConfig;
92 22 : return meta;
93 : }
94 :
95 18 : static HcclOpMetaInfoDef GetOneForAllGather(
96 : u32 algolevel1Type = 0, bool hugeData = false, bool smallCount = false,
97 : CopyPattern copyPattern = CopyPattern::BCOPY, bool dataSplit = false, bool isAivMode = false)
98 : {
99 18 : HcclOpMetaInfoDef meta;
100 18 : meta.opType = HcclCMDType::HCCL_CMD_ALLGATHER;
101 18 : meta.copyPattern = copyPattern;
102 18 : meta.algolevel1Type = algolevel1Type;
103 18 : meta.hugeData = hugeData;
104 18 : meta.isSmallCount = smallCount;
105 18 : meta.isEnableCache = CheckEnableCache(meta);
106 18 : meta.dataSplit = dataSplit;
107 18 : meta.isAivMode = isAivMode;
108 18 : return meta;
109 : }
110 :
111 0 : static HcclOpMetaInfoDef GetOneForAllGatherV(
112 : u32 algolevel1Type = 0, bool hugeData = false, bool smallCount = false,
113 : CopyPattern copyPattern = CopyPattern::BCOPY, bool dataSplit = false)
114 : {
115 0 : HcclOpMetaInfoDef meta;
116 0 : meta.opType = HcclCMDType::HCCL_CMD_ALLGATHER_V;
117 0 : meta.copyPattern = copyPattern;
118 0 : meta.algolevel1Type = algolevel1Type;
119 0 : meta.hugeData = hugeData;
120 0 : meta.isSmallCount = smallCount;
121 0 : meta.isEnableCache = CheckEnableCache(meta);
122 0 : meta.dataSplit = dataSplit;
123 0 : return meta;
124 : }
125 :
126 0 : static HcclOpMetaInfoDef GetOneForBroadcast(
127 : bool isRootRank, uint32_t rootRank, bool hugeData = false, bool isSmallCount = false, u64 sliceNum = 1,
128 : CopyPattern copyPattern = CopyPattern::BCOPY)
129 : {
130 0 : HcclOpMetaInfoDef meta;
131 0 : meta.opType = HcclCMDType::HCCL_CMD_BROADCAST;
132 0 : meta.isSmallCount = isSmallCount; // 是否小数据
133 0 : meta.isRootRank = isRootRank;
134 0 : meta.rootRank = rootRank;
135 0 : meta.hugeData = hugeData;
136 0 : meta.sliceNum = sliceNum;
137 0 : meta.copyPattern = copyPattern;
138 0 : meta.isEnableCache = CheckEnableCache(meta);
139 0 : return meta;
140 : }
141 :
142 0 : static HcclOpMetaInfoDef GetOneForScatter(uint32_t rootRank, bool hugeData = false)
143 : {
144 0 : HcclOpMetaInfoDef meta;
145 0 : meta.opType = HcclCMDType::HCCL_CMD_SCATTER;
146 0 : meta.rootRank = rootRank;
147 0 : meta.hugeData = hugeData;
148 0 : meta.isEnableCache = CheckEnableCache(meta);
149 0 : return meta;
150 : }
151 :
152 16 : static HcclOpMetaInfoDef GetOneForReduceScatter(
153 : u32 algolevel1Type = 0, HcclDataType dataType = HCCL_DATA_TYPE_RESERVED,
154 : ReduceType reduceType = ReduceType::INLINE_REDUCE, bool hugeData = false, bool isSmallCount = false,
155 : CopyPattern copyPattern = CopyPattern::BCOPY, bool dataSplit = false, u8 deterministicConfig = 0,
156 : bool isAivModeConfig = false, bool preloadCopyFlag = false)
157 : {
158 16 : HcclOpMetaInfoDef meta;
159 16 : meta.opType = HcclCMDType::HCCL_CMD_REDUCE_SCATTER;
160 16 : meta.reduceType = reduceType;
161 16 : meta.dataType = dataType;
162 16 : meta.algolevel1Type = algolevel1Type;
163 16 : meta.hugeData = hugeData;
164 16 : meta.isSmallCount = isSmallCount; // 是否小数据
165 16 : meta.copyPattern = copyPattern;
166 16 : meta.isEnableCache = CheckEnableCache(meta);
167 16 : meta.dataSplit = dataSplit;
168 16 : meta.deterministic = deterministicConfig;
169 16 : meta.isAivMode = isAivModeConfig;
170 16 : meta.preloadCopyOpt = preloadCopyFlag;
171 16 : return meta;
172 : }
173 :
174 0 : static HcclOpMetaInfoDef GetOneForReduceScatterV(
175 : u32 algolevel1Type = 0, HcclDataType dataType = HCCL_DATA_TYPE_RESERVED,
176 : ReduceType reduceType = ReduceType::INLINE_REDUCE, bool hugeData = false, bool isSmallCount = false,
177 : CopyPattern copyPattern = CopyPattern::BCOPY, bool dataSplit = false, u8 deterministicConfig = 0)
178 : {
179 0 : HcclOpMetaInfoDef meta;
180 0 : meta.opType = HcclCMDType::HCCL_CMD_REDUCE_SCATTER_V;
181 0 : meta.reduceType = reduceType;
182 0 : meta.dataType = dataType;
183 0 : meta.algolevel1Type = algolevel1Type;
184 0 : meta.hugeData = hugeData;
185 0 : meta.isSmallCount = isSmallCount; // 是否小数据
186 0 : meta.copyPattern = copyPattern;
187 0 : meta.isEnableCache = CheckEnableCache(meta);
188 0 : meta.dataSplit = dataSplit;
189 0 : meta.deterministic = deterministicConfig;
190 0 : return meta;
191 : }
192 :
193 : static HcclOpMetaInfoDef
194 0 : GetOneForAllToAll(CopyPattern copyPattern, u64 dataSize, bool hugeData = false, bool isAivMode = false)
195 : {
196 0 : HcclOpMetaInfoDef meta;
197 0 : meta.opType = HcclCMDType::HCCL_CMD_ALLTOALL;
198 0 : meta.copyPattern = copyPattern;
199 0 : meta.alltoallvcSendDataSize = dataSize;
200 0 : meta.hugeData = hugeData;
201 0 : meta.isAivMode = isAivMode;
202 0 : meta.isEnableCache = CheckEnableCache(meta);
203 0 : return meta;
204 : }
205 :
206 : static HcclOpMetaInfoDef
207 0 : GetOneForAllToAllV(CopyPattern copyPattern, u64 dataSize, bool hugeData = false, bool isSmallCount = false)
208 : {
209 0 : HcclOpMetaInfoDef meta;
210 0 : meta.opType = HcclCMDType::HCCL_CMD_ALLTOALLV;
211 0 : meta.copyPattern = copyPattern;
212 0 : meta.alltoallvSendDataSize = dataSize;
213 0 : meta.hugeData = hugeData;
214 0 : meta.isSmallCount = isSmallCount; // 是否小数据
215 0 : meta.isEnableCache = CheckEnableCache(meta);
216 0 : return meta;
217 : }
218 :
219 0 : static HcclOpMetaInfoDef GetOneForAllToAllVC(CopyPattern copyPattern, u64 dataSize, bool hugeData = false)
220 : {
221 0 : HcclOpMetaInfoDef meta;
222 0 : meta.opType = HcclCMDType::HCCL_CMD_ALLTOALLVC;
223 0 : meta.copyPattern = copyPattern;
224 0 : meta.alltoallvcSendDataSize = dataSize;
225 0 : meta.hugeData = hugeData;
226 0 : meta.isEnableCache = CheckEnableCache(meta);
227 0 : return meta;
228 : }
229 :
230 0 : static HcclOpMetaInfoDef GetOneForSend()
231 : {
232 0 : HcclOpMetaInfoDef meta;
233 0 : meta.opType = HcclCMDType::HCCL_CMD_SEND;
234 0 : meta.isEnableCache = CheckEnableCache(meta);
235 0 : return meta;
236 : }
237 :
238 0 : static HcclOpMetaInfoDef GetOneForRecieve()
239 : {
240 0 : HcclOpMetaInfoDef meta;
241 0 : meta.opType = HcclCMDType::HCCL_CMD_RECEIVE;
242 0 : meta.isEnableCache = CheckEnableCache(meta);
243 0 : return meta;
244 : }
245 :
246 0 : static HcclOpMetaInfoDef GetOneForBatchSendRecv()
247 : {
248 0 : HcclOpMetaInfoDef meta;
249 0 : meta.opType = HcclCMDType::HCCL_CMD_BATCH_SEND_RECV;
250 0 : meta.isEnableCache = CheckEnableCache(meta);
251 0 : return meta;
252 : }
253 :
254 0 : static HcclOpMetaInfoDef GetOneForReduce(
255 : bool isRootRank, uint32_t rootRank, u32 algolevel1Type = 0, HcclDataType dataType = HCCL_DATA_TYPE_RESERVED,
256 : ReduceType reduceType = ReduceType::INLINE_REDUCE, bool hugeDataConfig = false, u8 deterministicConfig = 0)
257 : {
258 0 : HcclOpMetaInfoDef meta;
259 0 : meta.opType = HcclCMDType::HCCL_CMD_REDUCE;
260 0 : meta.isRootRank = isRootRank;
261 0 : meta.rootRank = rootRank;
262 0 : meta.reduceType = reduceType;
263 0 : meta.dataType = dataType;
264 0 : meta.algolevel1Type = algolevel1Type;
265 0 : meta.hugeData = hugeDataConfig;
266 0 : meta.isEnableCache = CheckEnableCache(meta);
267 0 : meta.deterministic = deterministicConfig;
268 0 : return meta;
269 : }
270 :
271 56 : std::string GetCacheKey() const
272 : {
273 : #ifndef CCL_KERNEL_AICPU
274 56 : std::string key;
275 56 : key.reserve(KEY_SIZE);
276 56 : key.append(std::to_string(static_cast<int>(opType)));
277 56 : key.append(1, '_');
278 56 : key.append(1, isRootRank ? '1' : '0');
279 56 : key.append(1, '_');
280 56 : key.append(std::to_string(static_cast<int>(reduceType)));
281 56 : key.append(1, '_');
282 56 : key.append(std::to_string(rootRank));
283 56 : key.append(1, '_');
284 56 : key.append(std::to_string(sliceNum));
285 56 : key.append(1, '_');
286 56 : key.append(std::to_string(static_cast<int>(dataType)));
287 56 : key.append(1, '_');
288 56 : key.append(1, isSmallCount ? '1' : '0');
289 56 : key.append(1, '_');
290 56 : key.append(1, isDefaultPath ? '1' : '0');
291 56 : key.append(1, '_');
292 56 : key.append(std::to_string(piplineSliceNum));
293 56 : key.append(1, '_');
294 56 : key.append(std::to_string(algolevel1Type));
295 56 : key.append(1, '_');
296 56 : key.append(std::to_string(static_cast<int>(copyPattern)));
297 56 : key.append(1, '_');
298 56 : key.append(1, dataSplit ? '1' : '0');
299 56 : key.append(1, '_');
300 56 : key.append(1, isAivMode ? '1' : '0');
301 56 : key.append(1, '_');
302 56 : key.append(std::to_string(deterministic));
303 56 : key.append(1, '_');
304 56 : key.append(std::to_string(preloadCopyOpt));
305 56 : return key;
306 : #else
307 : return "";
308 : #endif
309 0 : }
310 : };
311 : } // namespace hccl
312 : #endif // FFTS_COMMON_PUB_H
|
