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 : #include "alg_configurator.h"
12 : #include "log.h"
13 : #include "hccl/base.h"
14 : #include "coll_alg_utils.h"
15 :
16 : namespace hccl {
17 :
18 : constexpr u32 DEVICE_EIGHT = 8;
19 : constexpr u32 DEVICE_FOUR = 4;
20 : constexpr u32 DEVICE_TWO = 2;
21 : constexpr u32 DEVICE_ONE = 1;
22 :
23 524 : AlgConfigurator::AlgConfigurator(HcclAlgoAttr& algoAttr, HcclTopoAttr& topoAttr)
24 524 : : algoAttr_(algoAttr),
25 524 : topoAttr_(topoAttr),
26 2096 : deterministic_(GetExternalInputHcclDeterministicV2())
27 524 : {}
28 :
29 524 : AlgConfigurator::~AlgConfigurator() {}
30 :
31 524 : HcclResult AlgConfigurator::Init(bool isHeterogComm)
32 : {
33 524 : if (!isHeterogComm) {
34 : // 获取算法类型
35 524 : CHK_RET(SelectAlgType(topoAttr_.moduleNum, topoAttr_.deviceType, algType_));
36 : // 获取拓扑类型，根据算法类型转化
37 524 : CHK_RET(GetTopoTypeByAlgType(algType_[HcclCMDType::HCCL_CMD_ALL], topoAttr_.deviceType, topoType_));
38 : } else {
39 0 : topoType_ = TopoType::TOPO_TYPE_HETEROG;
40 : }
41 :
42 523 : HCCL_INFO("alg configurator init success.");
43 523 : return HCCL_SUCCESS;
44 : }
45 :
46 : HcclResult
47 556 : AlgConfigurator::SelectAlgType(u32 moduleNum, const DevType deviceType, std::map<HcclCMDType, AlgType>& algType)
48 : {
49 58380 : for (u32 opType = 0; opType < static_cast<u32>(HcclCMDType::HCCL_CMD_MAX); opType++) {
50 57824 : CHK_RET(SelectCurrOpAlgType(moduleNum, deviceType, static_cast<HcclCMDType>(opType), algType));
51 : }
52 556 : return HCCL_SUCCESS;
53 : }
54 :
55 57824 : HcclResult AlgConfigurator::SelectCurrOpAlgType(
56 : u32 moduleNum, const DevType deviceType, HcclCMDType opType, std::map<HcclCMDType, AlgType>& algType)
57 : {
58 57824 : AlgTypeLevel0 algType0 = AlgTypeLevel0::ALG_LEVEL0_RESERVED;
59 57824 : AlgTypeLevel1 algType1 = AlgTypeLevel1::ALG_LEVEL1_RESERVED;
60 57824 : AlgTypeLevel2 algType2
61 : = AlgTypeLevel2::ALG_LEVEL2_RESERVED; // 第2层拓扑算法, 待梳理后考虑是否和第0层、第1层算法归一
62 :
63 57824 : std::vector<HcclAlgoType> algoCommConfig = algoAttr_.commAlgoConfig[opType];
64 57824 : HcclAlgoType algoConfigLevel0 = algoCommConfig[HCCL_ALGO_LEVEL_0];
65 57824 : HcclAlgoType algoConfigLevel1 = algoCommConfig[HCCL_ALGO_LEVEL_1];
66 57824 : HcclAlgoType algoConfigLevel2 = algoCommConfig[HCCL_ALGO_LEVEL_2];
67 :
68 57824 : bool isConfigAHC
69 : = (algoConfigLevel1 == HcclAlgoType::HCCL_ALGO_TYPE_AHC
70 57824 : || algoConfigLevel1 == HcclAlgoType::HCCL_ALGO_TYPE_AHC_BROKE);
71 :
72 57824 : bool isConfigNULL = algoConfigLevel0 == HcclAlgoType::HCCL_ALGO_TYPE_NULL;
73 :
74 57824 : HCCL_INFO(
75 : "[AlgConfigurator][SelectCurrOpAlgType] isConfigAHC[%u] isConfigNULL[%u] multiModuleDiffDeviceNumMode[%u] "
76 : "multiSuperPodDiffServerNumMode[%u] multiSuperPodDiffDeviceNumMode[%u]",
77 : isConfigAHC, isConfigNULL, topoAttr_.multiModuleDiffDeviceNumMode, topoAttr_.multiSuperPodDiffServerNumMode,
78 : topoAttr_.multiSuperPodDiffDeviceNumMode);
79 :
80 57824 : bool isSupportCmdARS
81 57268 : = (opType == HcclCMDType::HCCL_CMD_ALLGATHER || opType == HcclCMDType::HCCL_CMD_REDUCE_SCATTER
82 115092 : || opType == HcclCMDType::HCCL_CMD_ALLREDUCE);
83 :
84 57824 : bool isSupportCmdAHC
85 57268 : = (opType == HcclCMDType::HCCL_CMD_ALLGATHER || opType == HcclCMDType::HCCL_CMD_REDUCE_SCATTER
86 115092 : || opType == HcclCMDType::HCCL_CMD_ALLREDUCE || opType == HcclCMDType::HCCL_CMD_ALL);
87 :
88 : // server内卡数不对称，且不是ARS的情况
89 57824 : bool isNoARS
90 57824 : = (topoAttr_.multiModuleDiffDeviceNumMode
91 58656 : && !(
92 832 : isSupportCmdARS && deviceType == DevType::DEV_TYPE_910_93 && !topoAttr_.multiSuperPodDiffDeviceNumMode));
93 :
94 : // server内卡数对称, server内卡数不对称情况isNoARS已经讨论完毕；
95 : // 超节点server非对称，且不是AHC的情况
96 57824 : bool isNoAHC
97 56992 : = (!topoAttr_.multiModuleDiffDeviceNumMode && topoAttr_.multiSuperPodDiffServerNumMode
98 114816 : && !(isSupportCmdAHC && isConfigAHC));
99 :
100 57824 : if (Is310P3Common(algoAttr_.isHaveCpuRank, topoAttr_.deviceType)) {
101 416 : algType[opType].algoLevel0 = AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING;
102 416 : algType[opType].algoLevel1 = AlgTypeLevel1::ALG_LEVEL1_WHOLE_RING;
103 57408 : } else if (
104 57408 : !topoAttr_.multiModuleDiffDeviceNumMode && topoAttr_.multiSuperPodDiffServerNumMode
105 0 : && (opType == HcclCMDType::HCCL_CMD_ALLGATHER || opType == HcclCMDType::HCCL_CMD_ALLREDUCE
106 0 : || opType == HcclCMDType::HCCL_CMD_REDUCE_SCATTER || opType == HcclCMDType::HCCL_CMD_ALL)) {
107 0 : CHK_RET(SetAlgoLevel0(algoConfigLevel0, algType0));
108 0 : CHK_RET(SetAlgoLevel1(HcclAlgoType::HCCL_ALGO_TYPE_AHC, moduleNum, algType1, opType));
109 0 : CHK_RET(SetAlgoLevel2(algoConfigLevel2, algType2));
110 0 : algType[opType].algoLevel0 = algType0;
111 0 : algType[opType].algoLevel1 = algType1;
112 0 : if (!topoAttr_.isStandardCard && deviceType != DevType::DEV_TYPE_910B && !topoAttr_.isDiffDeviceType) {
113 0 : if (topoAttr_.nicList.size() != DEVICE_EIGHT && topoAttr_.deviceNumPerAggregation == DEVICE_EIGHT
114 0 : && algType0 != AlgTypeLevel0::ALG_LEVEL0_8P_RING) {
115 0 : HCCL_ERROR("[Set][AlgType]nicSize[%zu] error, algType is not 8P ring.", topoAttr_.nicList.size());
116 0 : return HCCL_E_PARA;
117 : }
118 : }
119 0 : HCCL_INFO("[AlgConfigurator][SelectCurrOpAlgType] multiModuleDiffDeviceNumMode is true, set ahc.");
120 0 : } else if (
121 57408 : !topoAttr_.multiModuleDiffDeviceNumMode && topoAttr_.multiSuperPodDiffServerNumMode
122 0 : && deviceType == DevType::DEV_TYPE_910_93
123 0 : && (opType == HcclCMDType::HCCL_CMD_ALLTOALL || opType == HcclCMDType::HCCL_CMD_ALLTOALLV
124 0 : || opType == HcclCMDType::HCCL_CMD_ALLTOALLVC)) {
125 : // A3 ALLTOALL非对称拓扑
126 0 : CHK_RET(SetAlgoLevel0(algoConfigLevel0, algType0));
127 0 : CHK_RET(SetAlgoLevel1(algoConfigLevel1, moduleNum, algType1, opType));
128 0 : CHK_RET(SetAlgoLevel2(algoConfigLevel2, algType2));
129 0 : algType[opType].algoLevel0 = algType0;
130 0 : algType[opType].algoLevel1 = algType1;
131 0 : algType[opType].algoLevel2 = algType2;
132 0 : if (algoConfigLevel0 == HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT
133 0 : && algoConfigLevel1 == HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT) {
134 0 : algType[opType].algoLevel0 = AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING;
135 0 : algType[opType].algoLevel1 = AlgTypeLevel1::ALG_LEVEL1_WHOLE_RING;
136 0 : isAlgoLevel1Default_[opType] = false;
137 : }
138 57408 : } else if ((isNoARS || isNoAHC) && !isConfigNULL) { // 多server不同卡模式，设置为单层拓扑类型
139 832 : algType[opType].algoLevel0 = AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING;
140 832 : algType[opType].algoLevel1 = AlgTypeLevel1::ALG_LEVEL1_WHOLE_RING;
141 832 : isAlgoLevel1Default_[opType] = false;
142 832 : if (algoConfigLevel0 != HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT
143 832 : || algoConfigLevel1 != HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT) {
144 0 : HCCL_WARNING(
145 : "multiModuleDiffDeviceNumMode[%d], multiSuperPodDiffServerNumMode_[%d], algorithm type [%d] is "
146 : "selected by force.",
147 : topoAttr_.multiModuleDiffDeviceNumMode, topoAttr_.multiSuperPodDiffServerNumMode,
148 : algType[opType].algoLevel0);
149 : }
150 832 : HCCL_INFO("[AlgConfigurator][SelectCurrOpAlgType] multiModuleDiffDeviceNumMode is true, set default ring.");
151 56576 : } else if (algoAttr_.isHaveCpuRank) {
152 0 : algType[opType].algoLevel0 = AlgTypeLevel0::ALG_LEVEL0_NP_STAR;
153 0 : algType[opType].algoLevel1 = AlgTypeLevel1::ALG_LEVEL1_STAR;
154 : } else {
155 56576 : CHK_RET(SetAlgoLevel0(algoConfigLevel0, algType0));
156 56576 : CHK_RET(SetAlgoLevel1(algoConfigLevel1, moduleNum, algType1, opType));
157 56576 : CHK_RET(SetAlgoLevel2(algoConfigLevel2, algType2));
158 56576 : algType[opType].algoLevel0 = algType0;
159 56576 : algType[opType].algoLevel1 = algType1;
160 56576 : algType[opType].algoLevel2 = algType2;
161 56576 : if (!topoAttr_.isStandardCard && deviceType != DevType::DEV_TYPE_910B && !topoAttr_.isDiffDeviceType) {
162 24648 : if (topoAttr_.nicList.size() != DEVICE_EIGHT && topoAttr_.deviceNumPerAggregation == DEVICE_EIGHT
163 24648 : && algType0 != AlgTypeLevel0::ALG_LEVEL0_8P_RING) {
164 0 : HCCL_ERROR("[Set][AlgType]nicSize[%zu] error, algType is not 8P ring.", topoAttr_.nicList.size());
165 0 : return HCCL_E_PARA;
166 : }
167 : }
168 : }
169 :
170 57824 : auto level0Iter = HCCL_ALGO_LEVEL0_NAME_MAP.find(algType0);
171 57824 : CHK_PRT_RET(
172 : level0Iter == HCCL_ALGO_LEVEL0_NAME_MAP.end(), HCCL_ERROR("level0: algType0[%u] is invalid.", algType0),
173 : HCCL_E_INTERNAL);
174 57824 : auto level1Iter = HCCL_ALGO_LEVEL1_NAME_MAP.find(algType1);
175 57824 : CHK_PRT_RET(
176 : level1Iter == HCCL_ALGO_LEVEL1_NAME_MAP.end(), HCCL_ERROR("level1: algType1[%u] is invalid.", algType1),
177 : HCCL_E_INTERNAL);
178 57824 : auto level2Iter = HCCL_ALGO_LEVEL2_NAME_MAP.find(algType2);
179 57824 : CHK_PRT_RET(
180 : level2Iter == HCCL_ALGO_LEVEL2_NAME_MAP.end(), HCCL_ERROR("level2: algType2[%u] is invalid.", algType2),
181 : HCCL_E_INTERNAL);
182 57824 : HCCL_RUN_INFO(
183 : "Device Type[%u], average device count[%u], HccsNum[%u], SIONum[%u], HCCS_SW_NUM[%u], optype[%u]", deviceType,
184 : topoAttr_.deviceNumPerAggregation, topoAttr_.pairLinkInfo[static_cast<u32>(LinkTypeInServer::HCCS_TYPE)].size(),
185 : topoAttr_.pairLinkInfo[static_cast<u32>(LinkTypeInServer::SIO_TYPE)].size(),
186 : topoAttr_.pairLinkInfo[static_cast<u32>(LinkTypeInServer::HCCS_SW_TYPE)].size(), opType);
187 57824 : return HCCL_SUCCESS;
188 57824 : }
189 :
190 56576 : HcclResult AlgConfigurator::SetAlgoLevel0(HcclAlgoType algoConfig, AlgTypeLevel0& algType)
191 : {
192 56576 : if (topoAttr_.isStandardCard) {
193 30160 : CHK_RET(SetAlgoLevel0StandardCard(algoConfig, algType));
194 : } else {
195 26416 : CHK_RET(SetAlgoLevel0Module(algoConfig, algType));
196 : }
197 56576 : return HCCL_SUCCESS;
198 : }
199 :
200 : HcclResult
201 56578 : AlgConfigurator::SetAlgoLevel1(HcclAlgoType algoConfig, u32 moduleNum, AlgTypeLevel1& algType, HcclCMDType opType)
202 : {
203 56578 : HcclAlgoType algoConfigShadow = algoConfig;
204 56578 : switch (algoConfig) {
205 15184 : case HcclAlgoType::HCCL_ALGO_TYPE_HDR:
206 15184 : algType = AlgTypeLevel1::ALG_LEVEL1_HD;
207 15184 : HCCL_INFO("server num[%u]: level1:hdr algo is set.", moduleNum);
208 15184 : break;
209 2496 : case HcclAlgoType::HCCL_ALGO_TYPE_RING:
210 2496 : algType = AlgTypeLevel1::ALG_LEVEL1_RING;
211 2496 : HCCL_INFO("server num[%u]: level1:ring algo is set.", moduleNum);
212 2496 : break;
213 0 : case HcclAlgoType::HCCL_ALGO_TYPE_NHR:
214 0 : algType = AlgTypeLevel1::ALG_LEVEL1_NHR;
215 0 : HCCL_INFO("server num[%u]: level1:nhr algo is set.", moduleNum);
216 0 : break;
217 0 : case HcclAlgoType::HCCL_ALGO_TYPE_NHR_V1:
218 0 : algType = AlgTypeLevel1::ALG_LEVEL1_NHR_V1;
219 0 : HCCL_INFO("server num[%u]: level1:nhr_v1 algo is set.", moduleNum);
220 0 : break;
221 1 : case HcclAlgoType::HCCL_ALGO_TYPE_AHC:
222 1 : if (opType == HcclCMDType::HCCL_CMD_ALLGATHER || opType == HcclCMDType::HCCL_CMD_ALLREDUCE
223 0 : || opType == HcclCMDType::HCCL_CMD_REDUCE_SCATTER) {
224 1 : algType = AlgTypeLevel1::ALG_LEVEL1_AHC;
225 1 : HCCL_INFO("server num[%u]: level1:ahc algo is set.", moduleNum);
226 1 : break;
227 0 : } else if (opType < HcclCMDType::HCCL_CMD_ALL) {
228 0 : algoConfigShadow = HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT;
229 0 : HCCL_INFO("server num[%u]: level1:ahc algo is not support, set default.", moduleNum);
230 0 : break;
231 : } else {
232 0 : algType = AlgTypeLevel1::ALG_LEVEL1_AHC;
233 0 : HCCL_INFO("server num[%u]: level1:ahc algo is set.", moduleNum);
234 0 : return HCCL_SUCCESS;
235 : }
236 1 : case HcclAlgoType::HCCL_ALGO_TYPE_AHC_BROKE:
237 1 : if (opType == HcclCMDType::HCCL_CMD_ALLGATHER || opType == HcclCMDType::HCCL_CMD_ALLREDUCE
238 0 : || opType == HcclCMDType::HCCL_CMD_REDUCE_SCATTER) {
239 1 : algType = AlgTypeLevel1::ALG_LEVEL1_AHC_BROKE;
240 1 : HCCL_INFO("server num[%u]: level1:ahc broke algo is set.", moduleNum);
241 1 : break;
242 0 : } else if (opType < HcclCMDType::HCCL_CMD_ALL) {
243 0 : algoConfigShadow = HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT;
244 0 : HCCL_INFO("server num[%u]: level1:ahc broke algo is not support, set default.", moduleNum);
245 0 : break;
246 : } else {
247 0 : algType = AlgTypeLevel1::ALG_LEVEL1_AHC_BROKE;
248 0 : HCCL_INFO("server num[%u]: level1:ahc broke algo is set.", moduleNum);
249 0 : return HCCL_SUCCESS;
250 : }
251 3328 : case HcclAlgoType::HCCL_ALGO_TYPE_NB:
252 3328 : algType = AlgTypeLevel1::ALG_LEVEL1_NB;
253 3328 : HCCL_INFO("server num[%u]: level1:nb algo is set.", moduleNum);
254 3328 : break;
255 0 : case HcclAlgoType::HCCL_ALGO_TYPE_PIPELINE:
256 0 : algType = AlgTypeLevel1::ALG_LEVEL1_PIPELINE;
257 0 : HCCL_INFO("server num[%u]: level1:pipeline algo is set.", moduleNum);
258 0 : break;
259 208 : case HcclAlgoType::HCCL_ALGO_TYPE_FULLMESH:
260 : case HcclAlgoType::HCCL_ALGO_TYPE_PAIRWISE:
261 208 : HCCL_WARNING("level1:fullmesh algo is not supported. the config is ignored.");
262 208 : algoConfigShadow = HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT;
263 208 : break;
264 35360 : default:
265 35360 : algoConfigShadow = HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT;
266 35360 : HCCL_INFO("server num[%u]: level1:default algo is set.", moduleNum);
267 35360 : break;
268 : }
269 :
270 56578 : HCCL_DEBUG(
271 : "[AlgConfigurator][SetAlgoLevel1] algType[%u], deviceType_[%u], workflowmode[%u]", algType,
272 : topoAttr_.deviceType, GetWorkflowMode());
273 113156 : if (algType == AlgTypeLevel1::ALG_LEVEL1_PIPELINE
274 56578 : && ((topoAttr_.deviceType != DevType::DEV_TYPE_910B && topoAttr_.deviceType != DevType::DEV_TYPE_910_93)
275 0 : || GetWorkflowMode() != HcclWorkflowMode::HCCL_WORKFLOW_MODE_OP_BASE)) {
276 0 : algoConfigShadow = HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT;
277 0 : HCCL_WARNING("hccl algorithm: there are %u server in level1, config pipeline algo failed.", moduleNum);
278 : }
279 :
280 56578 : if (algoConfigShadow == HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT) {
281 35568 : if (topoAttr_.deviceType == DevType::DEV_TYPE_910B) {
282 7592 : isAlgoLevel1Default_[opType] = true;
283 : }
284 35568 : CHK_RET(GetDefaultAlgoLevel1V1(moduleNum, algType));
285 : }
286 56578 : return HCCL_SUCCESS;
287 : }
288 :
289 35568 : HcclResult AlgConfigurator::GetDefaultAlgoLevel1V1(u32 moduleNum, AlgTypeLevel1& algType) const
290 : {
291 35568 : if (moduleNum >= HCCL_INTER_SERVER_RING_ALGO_MAX_SUPPORT_SERVER_NUM) {
292 : // server 数为 8 以上：使用 HD 算法
293 312 : algType = AlgTypeLevel1::ALG_LEVEL1_HD;
294 : } else {
295 : // server 数为 2 的非整数次幂：使用 RING 算法
296 : // server 数为 2 的整数次幂：使用 HD 算法
297 35256 : algType = (((moduleNum & (moduleNum - 1)) != 0) || (moduleNum == 1)) ? AlgTypeLevel1::ALG_LEVEL1_RING :
298 : AlgTypeLevel1::ALG_LEVEL1_HD;
299 : }
300 35568 : if (algType == AlgTypeLevel1::ALG_LEVEL1_HD && topoAttr_.deviceType == DevType::DEV_TYPE_910_93) {
301 1768 : algType = AlgTypeLevel1::ALG_LEVEL1_NHR;
302 : }
303 35568 : HCCL_INFO("[AlgConfigurator][GetDefaultAlgoLevel1V1] algType[%u], moduleNum[%u]", algType, moduleNum);
304 35568 : return HCCL_SUCCESS;
305 : }
306 :
307 56576 : HcclResult AlgConfigurator::SetAlgoLevel2(HcclAlgoType algoConfig, AlgTypeLevel2& algType)
308 : {
309 56576 : u32 superPodNum = topoAttr_.superPodNum;
310 56576 : switch (algoConfig) {
311 0 : case HcclAlgoType::HCCL_ALGO_TYPE_HDR:
312 0 : algType = AlgTypeLevel2::ALG_LEVEL2_HD;
313 0 : break;
314 1144 : case HcclAlgoType::HCCL_ALGO_TYPE_RING:
315 1144 : algType = AlgTypeLevel2::ALG_LEVEL2_RING;
316 1144 : break;
317 0 : case HcclAlgoType::HCCL_ALGO_TYPE_NHR:
318 0 : algType = AlgTypeLevel2::ALG_LEVEL2_NHR;
319 0 : break;
320 0 : case HcclAlgoType::HCCL_ALGO_TYPE_NB:
321 0 : algType = AlgTypeLevel2::ALG_LEVEL2_NB;
322 0 : break;
323 0 : case HcclAlgoType::HCCL_ALGO_TYPE_PIPELINE:
324 0 : algType = AlgTypeLevel2::ALG_LEVEL2_PIPELINE;
325 0 : break;
326 55432 : default: {
327 : // Level2默认选择NHR算法
328 55432 : algType = AlgTypeLevel2::ALG_LEVEL2_NHR;
329 55432 : break;
330 : }
331 : }
332 56576 : HCCL_DEBUG(
333 : "[AlgConfigurator][SetAlgoLevel2]algType[%u], deviceType_[%u], superPodNum_[%u]", algType, topoAttr_.deviceType,
334 : superPodNum);
335 56576 : return HCCL_SUCCESS;
336 : }
337 :
338 30160 : HcclResult AlgConfigurator::SetAlgoLevel0StandardCard(HcclAlgoType algoConfig, AlgTypeLevel0& algType)
339 : {
340 30160 : if (algoConfig == HcclAlgoType::HCCL_ALGO_TYPE_NULL) {
341 0 : algType = AlgTypeLevel0::ALG_LEVEL0_RESERVED;
342 0 : return HCCL_SUCCESS;
343 : }
344 :
345 30160 : if (algoConfig != HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT && algoConfig != HcclAlgoType::HCCL_ALGO_TYPE_NA) {
346 3016 : HCCL_WARNING("level0:%d algo is not supported. the config is ignored.", algoConfig);
347 : }
348 :
349 30160 : CHK_RET(GetDefaultAlgoLevel0StandardCard(algType));
350 30160 : return HCCL_SUCCESS;
351 : }
352 :
353 30160 : HcclResult AlgConfigurator::GetDefaultAlgoLevel0StandardCard(AlgTypeLevel0& algType) const
354 : {
355 30160 : if (topoAttr_.deviceNumPerAggregation == DEVICE_TWO) {
356 0 : if ((topoAttr_.deviceType == DevType::DEV_TYPE_910B)) {
357 0 : algType = AlgTypeLevel0::ALG_LEVEL0_NP_SINGLE_RING;
358 : } else {
359 0 : algType = AlgTypeLevel0::ALG_LEVEL0_2P_MESH;
360 : }
361 30160 : } else if (topoAttr_.deviceNumPerAggregation > DEVICE_TWO && topoAttr_.deviceNumPerAggregation <= DEVICE_EIGHT) {
362 : // 随标卡支持rank数变更
363 416 : algType = AlgTypeLevel0::ALG_LEVEL0_NP_SINGLE_RING;
364 29744 : } else if (topoAttr_.deviceNumPerAggregation == DEVICE_ONE) {
365 29744 : algType = AlgTypeLevel0::ALG_LEVEL0_NP_SINGLE_RING;
366 : } else {
367 0 : HCCL_ERROR("in standard card[num %u] there is no supported algo.", topoAttr_.deviceNumPerAggregation);
368 0 : return HCCL_E_PARA;
369 : }
370 30160 : HCCL_DEBUG("[GetDefaultAlgoLevel0StandardCard] AlgTypeLevel0 is set to [%u].", algType);
371 30160 : return HCCL_SUCCESS;
372 : }
373 :
374 26416 : HcclResult AlgConfigurator::SetAlgoLevel0Module(HcclAlgoType algoConfig, AlgTypeLevel0& algType)
375 : {
376 26416 : if (algoConfig == HcclAlgoType::HCCL_ALGO_TYPE_NULL) {
377 2496 : algType = AlgTypeLevel0::ALG_LEVEL0_RESERVED;
378 2496 : return HCCL_SUCCESS;
379 : }
380 :
381 23920 : if (algoConfig != HcclAlgoType::HCCL_ALGO_TYPE_DEFAULT && algoConfig != HcclAlgoType::HCCL_ALGO_TYPE_NA) {
382 3848 : HCCL_WARNING("level0:%d algo is not supported. the config is ignored.", algoConfig);
383 : }
384 :
385 23920 : CHK_RET(GetDefaultAlgoLevel0Module(algType));
386 23920 : return HCCL_SUCCESS;
387 : }
388 :
389 23920 : HcclResult AlgConfigurator::GetDefaultAlgoLevel0Module(AlgTypeLevel0& algType)
390 : {
391 23920 : u32 deviceNumPerAggregation = topoAttr_.deviceNumPerAggregation;
392 23920 : if (deviceNumPerAggregation == DEVICE_EIGHT) {
393 3224 : algType = AlgTypeLevel0::ALG_LEVEL0_8P_RING;
394 20696 : } else if (deviceNumPerAggregation == DEVICE_FOUR) {
395 14560 : algType = AlgTypeLevel0::ALG_LEVEL0_4P_MESH;
396 6136 : } else if (deviceNumPerAggregation == DEVICE_TWO) {
397 6032 : algType = AlgTypeLevel0::ALG_LEVEL0_NP_SINGLE_RING;
398 104 : } else if (deviceNumPerAggregation == DEVICE_ONE) {
399 0 : algType = AlgTypeLevel0::ALG_LEVEL0_NP_SINGLE_RING;
400 : } else {
401 104 : algType = AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING;
402 : }
403 :
404 23920 : if ((topoAttr_.pairLinkCounter[static_cast<u32>(LinkTypeInServer::HCCS_TYPE)]
405 23920 : == deviceNumPerAggregation * (deviceNumPerAggregation - 1)
406 832 : || topoAttr_.pairLinkCounter[static_cast<u32>(LinkTypeInServer::HCCS_TYPE)]
407 832 : == FACTOR_NUM_TWO * deviceNumPerAggregation * (deviceNumPerAggregation - 1))
408 24752 : && topoAttr_.deviceType == DevType::DEV_TYPE_910B) {
409 10712 : algType = AlgTypeLevel0::ALG_LEVEL0_NP_MESH;
410 10712 : HCCL_DEBUG("[GetDefaultAlgoLevel0Module] AlgTypeLevel0 is set to ALG_LEVEL0_NP_MESH (HCCS links is enabled).");
411 : }
412 :
413 23920 : if (topoAttr_.deviceType == DevType::DEV_TYPE_910_93) {
414 1976 : algType = IsHCCSSWNumEqualToTwiceSIONum() ? AlgTypeLevel0::ALG_LEVEL0_NP_DOUBLE_RING :
415 : AlgTypeLevel0::ALG_LEVEL0_NP_SINGLE_RING;
416 : }
417 23920 : if (topoAttr_.isDiffDeviceType) {
418 0 : HCCL_DEBUG(
419 : "[GetDefaultAlgoLevel0Module]gcdDeviceNumPerAggregation [%u] isDiffDeviceType [%u] algType [%u]",
420 : topoAttr_.gcdDeviceNumPerAggregation, topoAttr_.deviceType, algType);
421 : }
422 23920 : return HCCL_SUCCESS;
423 : }
424 :
425 1248 : bool AlgConfigurator::IsHCCSSWNumEqualToTwiceSIONum()
426 : {
427 1248 : u32 hccsSWNum = topoAttr_.pairLinkCounter[static_cast<u32>(LinkTypeInServer::HCCS_SW_TYPE)];
428 1248 : u32 sioNum = topoAttr_.pairLinkCounter[static_cast<u32>(LinkTypeInServer::SIO_TYPE)];
429 1248 : HCCL_DEBUG(
430 : "In pairLinkCounter_, the hccsSWNum is [%lu], the sioNum is [%lu], the deviceNumPerAggregation is [%lu]",
431 : hccsSWNum, sioNum, topoAttr_.deviceNumPerAggregation);
432 1248 : if (hccsSWNum == 0) {
433 416 : return false;
434 : }
435 832 : if (sioNum == 0) {
436 832 : return false;
437 : }
438 : // The following 2 means that the device has no HCCS_SW link with itself and its companion linked by same SIO link.
439 0 : return (hccsSWNum == ((topoAttr_.deviceNumPerAggregation - 2) * topoAttr_.deviceNumPerAggregation))
440 0 : && (sioNum == topoAttr_.deviceNumPerAggregation);
441 : }
442 :
443 764 : HcclResult AlgConfigurator::CheckAlgType(const AlgType algType)
444 : {
445 764 : if (algType.algoLevel0 == AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING
446 18 : && algType.algoLevel1 == AlgTypeLevel1::ALG_LEVEL1_HD) {
447 1 : HCCL_ERROR(
448 : "[Check][AlgType]errNo[0x%016llx] algType[%s] is not supported", HCCL_ERROR_CODE(HCCL_E_PARA),
449 : AlgTypeToStr(algType).c_str());
450 1 : return HCCL_E_PARA;
451 : }
452 763 : return HCCL_SUCCESS;
453 : }
454 :
455 0 : AlgTypeLevel0 AlgConfigurator::GetLevel0AlgType(const AlgType algType) const
456 : {
457 0 : if (algType.algoLevel0 != AlgTypeLevel0::ALG_LEVEL0_NP_STAR
458 0 : && algType.algoLevel1 != AlgTypeLevel1::ALG_LEVEL1_STAR) {
459 0 : return algType.algoLevel0;
460 : }
461 :
462 0 : return AlgTypeLevel0::ALG_LEVEL0_NP_STAR;
463 : }
464 :
465 524 : HcclResult AlgConfigurator::GetTopoTypeByAlgType(const AlgType& algType, const DevType deviceType, TopoType& topoType)
466 : {
467 524 : CHK_RET(CheckAlgType(algType));
468 523 : CHK_RET(CheckDeviceType(deviceType));
469 :
470 523 : switch (algType.algoLevel0) {
471 7 : case AlgTypeLevel0::ALG_LEVEL0_NP_DOUBLE_RING:
472 7 : topoType = TopoType::TOPO_TYPE_NP_DOUBLE_RING;
473 7 : break;
474 24 : case AlgTypeLevel0::ALG_LEVEL0_8P_RING:
475 24 : topoType = TopoType::TOPO_TYPE_8P_RING;
476 24 : break;
477 21 : case AlgTypeLevel0::ALG_LEVEL0_4P_MESH:
478 21 : topoType = TopoType::TOPO_TYPE_4P_MESH;
479 21 : break;
480 0 : case AlgTypeLevel0::ALG_LEVEL0_2P_MESH:
481 0 : topoType = TopoType::TOPO_TYPE_2P_MESH;
482 0 : break;
483 332 : case AlgTypeLevel0::ALG_LEVEL0_NP_SINGLE_RING:
484 332 : topoType = TopoType::TOPO_TYPE_NP_SINGLE_RING;
485 332 : break;
486 0 : case AlgTypeLevel0::ALG_LEVEL0_1P_MESH:
487 0 : topoType = TopoType::TOPO_TYPE_1P_MESH;
488 0 : break;
489 0 : case AlgTypeLevel0::ALG_LEVEL0_4P_RING:
490 0 : topoType = TopoType::TOPO_TYPE_4P_RING;
491 0 : break;
492 103 : case AlgTypeLevel0::ALG_LEVEL0_NP_MESH:
493 103 : topoType = TopoType::TOPO_TYPE_NP_MESH;
494 103 : break;
495 36 : case AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING:
496 : case AlgTypeLevel0::ALG_LEVEL0_RESERVED:
497 36 : topoType = TopoType::TOPO_TYPE_COMMON;
498 36 : break;
499 0 : case AlgTypeLevel0::ALG_LEVEL0_NP_STAR:
500 0 : topoType = TopoType::TOPO_TYPE_ES_MESH;
501 0 : break;
502 0 : default:
503 0 : HCCL_ERROR(
504 : "[AlgConfigurator][GetTopoTypeByAlgType]errNo[0x%016llx] case: device type[%d](0~1:V910),"
505 : " algorithm[%s] is not support",
506 : HCCL_ERROR_CODE(HCCL_E_PARA), deviceType, AlgTypeToStr(algType).c_str());
507 0 : return HCCL_E_PARA;
508 : }
509 :
510 523 : HCCL_INFO(
511 : "[AlgConfigurator][GetTopoTypeByAlgType]algtype[%s], devicetype[%d],topotype[%d] is selected",
512 : AlgTypeToStr(algType).c_str(), deviceType, topoType);
513 523 : return HCCL_SUCCESS;
514 : }
515 :
516 233 : HcclResult AlgConfigurator::GetAlgType(AlgType& algType, HcclCMDType opType)
517 : {
518 233 : opType = (algType_.find(opType) == algType_.end() ? HcclCMDType::HCCL_CMD_INVALID : opType);
519 233 : algType = algType_[opType];
520 233 : CHK_RET(CheckAlgType(algType));
521 233 : return HCCL_SUCCESS;
522 : }
523 :
524 0 : HcclResult AlgConfigurator::SetAlgType(AlgType algType, HcclCMDType opType)
525 : {
526 0 : CHK_RET(CheckAlgType(algType));
527 0 : algType_[opType] = algType;
528 0 : return HCCL_SUCCESS;
529 : }
530 :
531 0 : bool AlgConfigurator::SupportDeterministicOptim() const
532 : {
533 0 : bool support = topoAttr_.isSingleMeshAggregation && topoAttr_.deviceNumPerAggregation > DEVICE_TWO
534 0 : && topoAttr_.deviceType == DevType::DEV_TYPE_910B && deterministic_ != DETERMINISTIC_DISABLE;
535 0 : return support;
536 : }
537 :
538 1655 : void AlgConfigurator::GetTopoType(TopoType& topoType)
539 : {
540 1655 : topoType = topoType_;
541 1655 : return;
542 : }
543 :
544 94 : void AlgConfigurator::GetAlgTypeDirect(AlgType& algType, HcclCMDType opType)
545 : {
546 94 : opType = (algType_.find(opType) == algType_.end() ? HcclCMDType::HCCL_CMD_INVALID : opType);
547 88 : algType = algType_[opType];
548 87 : return;
549 : }
550 :
551 87 : HcclResult AlgConfigurator::GetAlgoLevel1DefaultSwitch(bool& isAlgoLevel1Default, HcclCMDType opType)
552 : {
553 87 : isAlgoLevel1Default = isAlgoLevel1Default_[opType];
554 86 : return HCCL_SUCCESS;
555 : }
556 :
557 97 : const HcclTopoAttr& AlgConfigurator::GetTopoAttr() { return topoAttr_; }
558 :
559 91 : const HcclAlgoAttr& AlgConfigurator::GetAlgoAttr() { return algoAttr_; }
560 : } // namespace hccl
|
