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