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 <iostream>
12 : #include <fstream>
13 : #include <algorithm>
14 : #include <adapter_rts.h>
15 : #include <thread>
16 : #include <mutex>
17 : #include <unistd.h>
18 : #include <regex>
19 : #include <cmath>
20 : #include "sal.h"
21 : #include "adapter_error_manager.h"
22 : #include "externalinput_pub.h"
23 : #include "mmpa_api.h"
24 : #include "config_plf_log.h"
25 : #include "device_capacity.h"
26 : #include "externalinput.h"
27 :
28 : using namespace std;
29 : using namespace hccl;
30 :
31 : #define GET_ENV(IdName) \
32 : ({ \
33 : char* mmSysGetEnvValue = nullptr; \
34 : MM_SYS_GET_ENV(IdName, mmSysGetEnvValue); \
35 : (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString"; \
36 : })
37 :
38 : static std::mutex g_externalInputMutex;
39 : static ExternalInput g_externalInput; // 外部输入参数 （环境变量，配置文件）
40 : static thread_local bool g_ifProf = true;
41 : constexpr u32 HCCL_QPS_PER_CONNECTION_MAX = 32; // HCCL 默认的rank 间QP个数（仅单算子下生效）
42 :
43 424 : HcclResult InitExternalInput()
44 : {
45 424 : std::lock_guard<std::mutex> lock(g_externalInputMutex);
46 424 : if (g_externalInput.initialized) {
47 66 : return HCCL_SUCCESS;
48 : }
49 : // 初始化环境变量参数
50 358 : CHK_RET(InitEnvVarParam());
51 :
52 358 : g_externalInput.initialized = true;
53 :
54 358 : return HCCL_SUCCESS;
55 424 : }
56 :
57 499 : HcclResult InitExternalInputHeterog()
58 : {
59 : // 解析server间通信协议
60 499 : g_externalInput.remoteIsHdc = true;
61 499 : g_externalInput.protocolType = ProtocolType::RDMA;
62 499 : HCCL_INFO(
63 : "Protocol[%d], remoteIsHdc[%d]", static_cast<s32>(g_externalInput.protocolType),
64 : g_externalInput.remoteIsHdc ? 1 : 0);
65 499 : return HCCL_SUCCESS;
66 : }
67 :
68 0 : void SetExternalInputProtocolType(ProtocolType prot) { g_externalInput.protocolType = prot; }
69 :
70 1130 : HcclResult ResetInitState()
71 : {
72 1130 : g_externalInput.SetDefaultParams();
73 1130 : return HCCL_SUCCESS;
74 : }
75 :
76 392 : HcclResult InitEnvVarParam()
77 : {
78 : // 解析hccl connect timeout 超时时间
79 392 : HcclResult ret = ParseLinkConnTimeOut();
80 392 : RPT_ENV_ERR(
81 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
82 : std::vector<std::string>(
83 : {GET_ENV(MM_ENV_HCCL_CONNECT_TIMEOUT), "HCCL_CONNECT_TIMEOUT",
84 : "a number greater than or equal to 120s and less than or equal to 7200s"}));
85 392 : CHK_PRT_RET(
86 : ret != HCCL_SUCCESS,
87 : HCCL_ERROR(
88 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse link "
89 : "time out failed. errorno[%d]",
90 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
91 : ret);
92 :
93 : // 解析hccl execute timeout 超时时间
94 : // 环境变量的解析在options解析之后, 如果options中配置了hccl execute timeout, 则不解析环境变量中的hccl execute
95 : // timeout
96 392 : if (g_externalInput.execTimeOutSet != HcclExecTimeoutSet::HCCL_EXEC_TIMEOUT_SET_BY_OPTIONS) {
97 392 : ret = ParseExecTimeOut();
98 392 : CHK_PRT_RET(
99 : ret != HCCL_SUCCESS,
100 : HCCL_ERROR(
101 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse execute time out failed. errorno[%d]",
102 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
103 : ret);
104 : }
105 :
106 : // 解析server内通信方式
107 392 : ret = ParseIntraLinkType();
108 784 : std::string userInput = "PCIE enable: " + std::string(GET_ENV(MM_ENV_HCCL_INTRA_PCIE_ENABLE))
109 1176 : + "or ROCE enable:" + std::string(GET_ENV(MM_ENV_HCCL_INTRA_ROCE_ENABLE));
110 392 : RPT_ENV_ERR(
111 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
112 : std::vector<std::string>(
113 : {userInput, "HCCL_INTRA_PCIE_ENABLE or HCCL_INTRA_ROCE_ENABLE", "0 or 1 (but not both 1)"}));
114 392 : CHK_PRT_RET(
115 : ret != HCCL_SUCCESS,
116 : HCCL_ERROR(
117 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse intra "
118 : "comm type failed. errorno[%d]",
119 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
120 : ret);
121 :
122 : // 解析profiling 配置
123 392 : ret = ParseProfilingConfig();
124 392 : RPT_ENV_ERR(
125 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
126 : std::vector<std::string>({GET_ENV(MM_ENV_PROFILING_MODE), "PROFILING_MODE", "true or false"}));
127 392 : CHK_PRT_RET(
128 : ret != HCCL_SUCCESS,
129 : HCCL_ERROR(
130 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse profiling "
131 : "config failed. errorno[%d]",
132 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
133 : ret);
134 :
135 : // 解析whitelist switch配置
136 392 : ret = ParseHcclWhitelistSwitch();
137 392 : RPT_ENV_ERR(
138 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
139 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_WHITELIST_DISABLE), "HCCL_WHITELIST_DISABLE", "0 or 1"}));
140 392 : CHK_PRT_RET(
141 : ret != HCCL_SUCCESS,
142 : HCCL_ERROR(
143 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse whitelist switch failed. errorno[%d]",
144 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
145 : ret);
146 :
147 : // 解析whitelist file配置
148 392 : ret = ParseHcclWhitelistFilePath();
149 392 : RPT_ENV_ERR(
150 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
151 : std::vector<std::string>(
152 : {GET_ENV(MM_ENV_HCCL_WHITELIST_FILE), "HCCL_WHITELIST_FILE",
153 : "absolute file path with length less than 4096"}));
154 392 : CHK_PRT_RET(
155 : ret != HCCL_SUCCESS,
156 : HCCL_ERROR(
157 : "[%s][%s]errNo[0x%016llx] In init env variable param, "
158 : "parse whitelist file failed. errorno[%d]",
159 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
160 : ret);
161 :
162 : // 解析rootinfo IF配置
163 392 : ret = ParseHcclIfIp();
164 392 : RPT_ENV_ERR(
165 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
166 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_IF_IP), "HCCL_IF_IP", "\"ip[%ifname]\""}));
167 392 : CHK_PRT_RET(
168 : ret != HCCL_SUCCESS,
169 : HCCL_ERROR(
170 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse rootInfo network interface failed. "
171 : "errorno[%d]",
172 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
173 : ret);
174 :
175 : // 解析Host Socket IfName配置
176 392 : ret = ParseHcclSocketIfName();
177 392 : RPT_ENV_ERR(
178 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
179 : std::vector<std::string>(
180 : {GET_ENV(MM_ENV_HCCL_SOCKET_IFNAME), "HCCL_SOCKET_IFNAME", "Format: [=|^=|<interface>[,<interface>...]]"}));
181 392 : CHK_PRT_RET(
182 : ret != HCCL_SUCCESS,
183 : HCCL_ERROR(
184 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse host interface name failed. errorno[%d]",
185 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
186 : ret);
187 :
188 392 : ret = ParseHcclSocketFamily();
189 392 : RPT_ENV_ERR(
190 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
191 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_SOCKET_FAMILY), "HCCL_SOCKET_FAMILY", "AF_INET or AF_INET6"}));
192 392 : CHK_PRT_RET(
193 : ret != HCCL_SUCCESS,
194 : HCCL_ERROR(
195 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse hccl socket family config failed. "
196 : "errorno[%d]",
197 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
198 : ret);
199 :
200 : // 解析BASE端口
201 392 : ret = ParseHcclIfBasePort();
202 392 : RPT_ENV_ERR(
203 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
204 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_IF_BASE_PORT), "HCCL_IF_BASE_PORT", "range[1024,65520]"}));
205 392 : CHK_PRT_RET(
206 : ret != HCCL_SUCCESS,
207 : HCCL_ERROR(
208 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse IF base port config failed. errorno[%d]",
209 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
210 : ret);
211 :
212 : // 解析Cann版本
213 : // CANN版本的校验不影响HCCL业务，所以解析过程中不返回错误
214 392 : (void)ParseCannVersion();
215 :
216 : // 解析RDMATrafficClass
217 392 : ret = ParseRDMATrafficClass();
218 392 : RPT_ENV_ERR(
219 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
220 : std::vector<std::string>(
221 : {GET_ENV(MM_ENV_HCCL_RDMA_TC), "HCCL_RDMA_TC", "range[0, 255], Must be a multiple of 4"}));
222 392 : CHK_PRT_RET(
223 : ret != HCCL_SUCCESS,
224 : HCCL_ERROR(
225 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_RDMA_TC failed. errorno[%d]",
226 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
227 : ret);
228 :
229 : // 解析RDMAServerLevel
230 392 : ret = ParseRDMAServerLevel();
231 392 : RPT_ENV_ERR(
232 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
233 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_RDMA_SL), "HCCL_RDMA_SL", "range[0, 7]"}));
234 392 : CHK_PRT_RET(
235 : ret != HCCL_SUCCESS,
236 : HCCL_ERROR(
237 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_RDMA_SL failed. errorno[%d]",
238 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
239 : ret);
240 :
241 : // 解析RDMATimeOut
242 392 : std::pair<u32, u32> rdmaTimeOutRange;
243 392 : ret = ParseRDMATimeOut(rdmaTimeOutRange);
244 : std::string vaildRange
245 392 : = "range[" + std::to_string(rdmaTimeOutRange.first) + " ," + std::to_string(rdmaTimeOutRange.second) + "]";
246 392 : RPT_ENV_ERR(
247 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
248 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_RDMA_TIMEOUT), "HCCL_RDMA_TIMEOUT", vaildRange}));
249 392 : CHK_PRT_RET(
250 : ret != HCCL_SUCCESS,
251 : HCCL_ERROR(
252 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_RDMA_TIMEOUT failed. errorno[%d]",
253 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
254 : ret);
255 :
256 : // 解析RDMARetryCnt
257 392 : ret = ParseRDMARetryCnt();
258 392 : RPT_ENV_ERR(
259 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
260 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_RDMA_RETRY_CNT), "HCCL_RDMA_RETRY_CNT", "range[1, 7]"}));
261 392 : CHK_PRT_RET(
262 : ret != HCCL_SUCCESS,
263 : HCCL_ERROR(
264 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_RDMA_RETRY_CNT failed. errorno[%d]",
265 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
266 : ret);
267 :
268 : // 解析cclbufersize
269 392 : ret = ParseCclBufferSize();
270 392 : RPT_ENV_ERR(
271 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
272 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_BUFFSIZE), "HCCL_BUFFSIZE", "equal to or greater than 1(MB)"}));
273 392 : CHK_PRT_RET(
274 : ret != HCCL_SUCCESS,
275 : HCCL_ERROR(
276 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_BUFFSIZE failed. errorno[%d]",
277 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
278 : ret);
279 :
280 : // 解析hcclDeterministic,是否为确定性计算
281 392 : ret = ParseDeterministic();
282 392 : RPT_ENV_ERR(
283 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
284 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_DETERMINISTIC), "HCCL_DETERMINISTIC", "true, false or strict"}));
285 392 : CHK_PRT_RET(
286 : ret != HCCL_SUCCESS,
287 : HCCL_ERROR(
288 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_DETERMINISTIC failed. errorno[%d]",
289 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
290 : ret);
291 :
292 : // 解析ffts+模式（子任务粒度）下task_exception_handler开关
293 392 : ret = ParseTaskExceptionSwitch();
294 392 : RPT_ENV_ERR(
295 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
296 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_DIAGNOSE_ENABLE), "HCCL_DIAGNOSE_ENABLE", "0 or 1"}));
297 392 : CHK_PRT_RET(
298 : ret != HCCL_SUCCESS,
299 : HCCL_ERROR(
300 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_DIAGNOSE_ENABLE failed. "
301 : "errorno[%d]",
302 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
303 : ret);
304 :
305 : // 解析Entry日志开关
306 392 : ret = ParseEntryLogEnable();
307 392 : RPT_ENV_ERR(
308 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
309 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_ENTRY_LOG_ENABLE), "HCCL_ENTRY_LOG_ENABLE", "0 or 1"}));
310 392 : CHK_PRT_RET(
311 : ret != HCCL_SUCCESS,
312 : HCCL_ERROR(
313 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_ENTRY_LOG_ENABLE failed. "
314 : "errorno[%d]",
315 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
316 : ret);
317 :
318 : // 解析超节点内节点间链路选择开关
319 392 : ret = ParseInterLinkType();
320 392 : RPT_ENV_ERR(
321 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
322 : std::vector<std::string>(
323 : {GET_ENV(MM_ENV_HCCL_INTER_HCCS_DISABLE), "HCCL_INTER_HCCS_DISABLE", "true or false"}));
324 392 : CHK_PRT_RET(
325 : ret != HCCL_SUCCESS,
326 : HCCL_ERROR(
327 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_INTER_HCCS_DISABLE failed. "
328 : "errorno[%d]",
329 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
330 : ret);
331 :
332 392 : ret = ParseOpExpansion();
333 392 : RPT_ENV_ERR(
334 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
335 : std::vector<std::string>(
336 : {GET_ENV(MM_ENV_HCCL_OP_EXPANSION_MODE), "HCCL_OP_EXPANSION_MODE",
337 : "Atlas A3: AI_CPU | AIV; Atlas A2 AIV | HOST | HOST_TS; Atlas 300I AI_CPU | HOST"}));
338 392 : CHK_PRT_RET(
339 : ret != HCCL_SUCCESS,
340 : HCCL_ERROR(
341 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_OP_EXPANSION_MODE failed. "
342 : "errorno[%d]",
343 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
344 : ret);
345 :
346 : // 解析rank 间的QP个数
347 392 : ret = ParseRdmaQpsPerConnection();
348 392 : RPT_ENV_ERR(
349 : ret != HCCL_SUCCESS, "", std::vector<std::string>({"value", "env", "expect"}),
350 : std::vector<std::string>(
351 : {GET_ENV(MM_ENV_HCCL_RDMA_QPS_PER_CONNECTION), "HCCL_RDMA_QPS_PER_CONNECTION",
352 : "The allowed value range is [1, 32], "
353 : "but the recommended value range is [1, 8]."}));
354 392 : CHK_PRT_RET(
355 : ret != HCCL_SUCCESS,
356 : HCCL_ERROR(
357 : "[%s][%s]errNo[0x%016llx] In init env variable param, "
358 : "parse HCCL_RDMA_QPS_PER_CONNECTION(range[1,32]) failed. errorno[%d]",
359 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
360 : ret);
361 :
362 : // 解析rank 间多QP切分门限
363 392 : ret = ParseMultiQpThreshold();
364 392 : RPT_ENV_ERR(
365 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
366 : std::vector<std::string>(
367 : {GET_ENV(MM_ENV_HCCL_MULTI_QP_THRESHOLD), "HCCL_MULTI_QP_THRESHOLD", "larger than 0, less than 8193(KB)"}));
368 392 : CHK_PRT_RET(
369 : ret != HCCL_SUCCESS,
370 : HCCL_ERROR(
371 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse "
372 : "HCCL_MULTI_QP_THRESHOLD(range[1,8192]) failed. errorno[%d]",
373 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
374 : ret);
375 :
376 : #ifndef CCL_KERNEL_AICPU
377 : // 解析重执行设置
378 392 : ret = ParseRetryEnable();
379 392 : RPT_ENV_ERR(
380 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
381 : std::vector<std::string>({GET_ENV(MM_ENV_HCCL_OP_RETRY_ENABLE), "HCCL_OP_RETRY_ENABLE", "0 or 1"}));
382 392 : CHK_PRT_RET(
383 : ret != HCCL_SUCCESS,
384 : HCCL_ERROR(
385 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_OP_RETRY_ENABLE failed. "
386 : "errorno[%d]",
387 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
388 : ret);
389 : #endif
390 :
391 : #ifndef CCL_KERNEL_AICPU
392 : // 解析重执行最大尝试次数 重执行间隔时间 首次重执行等待时间 */
393 392 : ret = ParseRetryParams();
394 392 : RPT_ENV_ERR(
395 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
396 : std::vector<std::string>(
397 : {GET_ENV(MM_ENV_HCCL_OP_RETRY_PARAMS), "HCCL_OP_RETRY_PARAMS",
398 : "format must be: \"MaxCnt:cnt,HoldTime:time,IntervalTime:time\"."
399 : "cnt range is [1, 10], time range is [0, 60000]"}));
400 392 : CHK_PRT_RET(
401 : ret != HCCL_SUCCESS,
402 : HCCL_ERROR(
403 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_OP_RETRY_PARAMS failed. "
404 : "errorno[%d]",
405 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
406 : ret);
407 : #endif
408 :
409 392 : ret = ParseLogicSuperPodId();
410 392 : RPT_ENV_ERR(
411 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
412 : std::vector<std::string>(
413 : {GET_ENV(MM_ENV_HCCL_LOGIC_SUPERPOD_ID), "HCCL_LOGIC_SUPERPOD_ID", "length must be less than 128"}));
414 392 : CHK_PRT_RET(
415 : ret != HCCL_SUCCESS,
416 : HCCL_ERROR(
417 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_LOGIC_SUPERPOD_ID failed. "
418 : "errorno[%d]",
419 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
420 : ret);
421 :
422 392 : ret = ParseRdmaFastPost();
423 392 : RPT_ENV_ERR(
424 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
425 : std::vector<std::string>(
426 : {GET_ENV(MM_ENV_HCCL_RDMA_PCIE_DIRECT_POST_NOSTRICT), "HCCL_RDMA_PCIE_DIRECT_POST_NOSTRICT",
427 : "true or false"}));
428 392 : CHK_PRT_RET(
429 : ret != HCCL_SUCCESS,
430 : HCCL_ERROR(
431 : "[%s][%s]errNo[0x%016llx] In init env variable param, parse "
432 : "HCCL_RDMA_PCIE_DIRECT_POST_NOSTRICT failed. errorno[%d]",
433 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
434 : ret);
435 :
436 : // 解析多QP源端口号配置文件路径
437 392 : ret = ParseMultiQpSrcPortConfigPath();
438 392 : RPT_ENV_ERR(
439 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
440 : std::vector<std::string>(
441 : {GET_ENV(MM_ENV_HCCL_RDMA_QP_PORT_CONFIG_PATH), "HCCL_RDMA_QP_PORT_CONFIG_PATH",
442 : "a valid existing file path"}));
443 392 : CHK_PRT_RET(
444 : ret != HCCL_SUCCESS,
445 : HCCL_ERROR(
446 : "[%s][%s]errNo[0x%016llx] In init env variable param, "
447 : "parse MultiQpSrcPortConfigPath failed. errorno[%d]",
448 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
449 : ret);
450 :
451 : // 解析ParseDebugConfig
452 392 : ret = ParseDebugConfig();
453 392 : char* env = nullptr; // 环境变量值
454 392 : MM_SYS_GET_ENV(MM_ENV_HCCL_DEBUG_CONFIG, env);
455 917 : std::string envValue = env ? std::string(env) : "null";
456 392 : RPT_ENV_ERR(
457 : ret != HCCL_SUCCESS, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
458 : std::vector<std::string>({envValue, "HCCL_DEBUG_CONFIG", "ALG,TASK,RESOURCE(optionally prefixed with'^')"}));
459 392 : CHK_PRT_RET(
460 : ret != HCCL_SUCCESS,
461 : HCCL_ERROR(
462 : "[%s][%s]errNo[0x%016llx] In init env variable param, "
463 : "parse HCCL_DEBUG_CONFIG failed. errorno[%d]",
464 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCCL_ERROR_CODE(ret), ret),
465 : ret);
466 :
467 392 : return HCCL_SUCCESS;
468 392 : }
469 :
470 392 : HcclResult ParseRdmaFastPost()
471 : {
472 392 : std::string rdmaFastPostEnv = GET_ENV(MM_ENV_HCCL_RDMA_PCIE_DIRECT_POST_NOSTRICT);
473 392 : if (rdmaFastPostEnv == "EmptyString") {
474 392 : HCCL_RUN_INFO(
475 : "[HCCL_ENV] HCCL_RDMA_PCIE_DIRECT_POST_NOSTRICT set by default to [%s], rdmaFastPost is [%d]",
476 : rdmaFastPostEnv.c_str(), g_externalInput.rdmaFastPost);
477 392 : return HCCL_SUCCESS;
478 : }
479 0 : std::transform(rdmaFastPostEnv.begin(), rdmaFastPostEnv.end(), rdmaFastPostEnv.begin(), ::toupper);
480 0 : if (rdmaFastPostEnv == "TRUE") {
481 0 : g_externalInput.rdmaFastPost = true;
482 0 : } else if (rdmaFastPostEnv == "FALSE") {
483 0 : g_externalInput.rdmaFastPost = false;
484 : } else {
485 0 : HCCL_ERROR(
486 : "HCCL_RDMA_PCIE_DIRECT_POST_NOSTRICT is set to [%s], which is incorrect. Please check",
487 : rdmaFastPostEnv.c_str());
488 0 : return HCCL_E_PARA;
489 : }
490 0 : HCCL_RUN_INFO(
491 : "[HCCL_ENV] HCCL_RDMA_PCIE_DIRECT_POST_NOSTRICT set by environment to [%s], rdmaFastPost is [%d].",
492 : rdmaFastPostEnv.c_str(), g_externalInput.rdmaFastPost);
493 0 : return HCCL_SUCCESS;
494 392 : }
495 :
496 3 : bool IsValidExecTimeOutMs(const std::string& execTimeOutStr)
497 : {
498 : // 校验配置值为数字格式，小数点最多2位
499 3 : std::regex validFormat(R"(^\d+(\.\d{1,2})?$)");
500 3 : if (!std::regex_match(execTimeOutStr, validFormat)) {
501 0 : return false;
502 : }
503 :
504 3 : return true;
505 3 : }
506 :
507 392 : HcclResult ParseExecTimeOut()
508 : {
509 392 : std::string execTimeOutEnv = GET_ENV(MM_ENV_HCCL_EXEC_TIMEOUT);
510 392 : if (execTimeOutEnv == "EmptyString") {
511 391 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_EXEC_TIMEOUT set by default to [%d]s", NOTIFY_DEFAULT_WAIT_TIME);
512 391 : return HCCL_SUCCESS;
513 : }
514 :
515 : // 校验环境变量长度
516 1 : bool isEnvLenValid = CheckEnvLen(execTimeOutEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
517 1 : CHK_PRT_RET(
518 : !isEnvLenValid,
519 : HCCL_ERROR(
520 : "[Parse][ExecuteTimeOut]errNo[0x%016llx] Invalid ExecuteTimeOut env len, len is bigger than "
521 : "[%u]. errorno[%d]",
522 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
523 : HCCL_E_PARA);
524 :
525 1 : CHK_RET(SetHccLExecTimeOut(execTimeOutEnv.c_str(), HcclExecTimeoutSet::HCCL_EXEC_TIMEOUT_SET_BY_ENV));
526 :
527 1 : return HCCL_SUCCESS;
528 392 : }
529 :
530 392 : HcclResult ParseLinkConnTimeOut()
531 : {
532 392 : std::string timeOutEnv = GET_ENV(MM_ENV_HCCL_CONNECT_TIMEOUT);
533 392 : s32 timeOut = HCCL_LINK_TIME_OUT_S;
534 :
535 392 : if (timeOutEnv != "EmptyString") {
536 : // 校验环境变量长度
537 0 : bool isEnvLenValid = CheckEnvLen(timeOutEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
538 0 : CHK_PRT_RET(
539 : !isEnvLenValid,
540 : HCCL_ERROR(
541 : "[Parse][LinkConnTimeOut]errNo[0x%016llx] Invalid LinkConnTimeOut env len, len is bigger than "
542 : "[%u]. errorno[%d]",
543 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
544 : HCCL_E_PARA);
545 :
546 0 : CHK_RET(IsAllDigit(timeOutEnv.c_str()));
547 0 : HcclResult ret = SalStrToInt(timeOutEnv, HCCL_BASE_DECIMAL, timeOut);
548 : // 若转换出错或者设置的超时时间小于2分钟或大于2小时，报错并设为默认值
549 0 : if (ret != HCCL_SUCCESS || (timeOut < HCCL_MIN_LINK_TIME_OUT_S) || (timeOut > HCCL_MAX_LINK_TIME_OUT_S)) {
550 0 : HCCL_ERROR(
551 : "[Parse][LinkConnTimeOut]environmental variable HCCL_CONNECT_TIMEOUT error, errNo[0x%016llx]"
552 : "timeOutEnv[%ss] timeRange[%ds,%ds]",
553 : HCOM_ERROR_CODE(ret), timeOutEnv.c_str(), HCCL_MIN_LINK_TIME_OUT_S, HCCL_MAX_LINK_TIME_OUT_S);
554 0 : g_externalInput.linkTimeOut = HCCL_LINK_TIME_OUT_S;
555 0 : return HCCL_E_PARA;
556 : }
557 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_CONNECT_TIMEOUT set by environment to [%d]s", timeOut);
558 : } else {
559 392 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_CONNECT_TIMEOUT set by default to [%d]s", timeOut);
560 : }
561 :
562 392 : g_externalInput.linkTimeOut = timeOut;
563 392 : return HCCL_SUCCESS;
564 392 : }
565 :
566 1 : HcclResult GetIntraLinkTypeDigit(std::string& intraCommStr, u32& intraCommDig)
567 : {
568 1 : CHK_RET(IsAllDigit(intraCommStr.c_str()));
569 2 : CHK_RET(SalStrToULong(intraCommStr.c_str(), HCCL_BASE_DECIMAL, intraCommDig));
570 :
571 1 : if ((intraCommDig != 0) && (intraCommDig != 1)) { // 判断转换后的数字是否为0或1
572 0 : HCCL_ERROR("[Get][IntraLinkTypeDigit]environmental digit variable error, intraCommDig[%u]", intraCommDig);
573 0 : return HCCL_E_PARA;
574 : }
575 1 : return HCCL_SUCCESS;
576 : }
577 :
578 392 : HcclResult ParseDeterministic()
579 : {
580 392 : std::string hcclDeterministicEnv = GET_ENV(MM_ENV_HCCL_DETERMINISTIC);
581 392 : if (hcclDeterministicEnv == "EmptyString") {
582 380 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_DETERMINISTIC set by default to [false]");
583 380 : return HCCL_SUCCESS;
584 : }
585 :
586 12 : std::transform(hcclDeterministicEnv.begin(), hcclDeterministicEnv.end(), hcclDeterministicEnv.begin(), ::toupper);
587 12 : if (hcclDeterministicEnv != "STRICT" && hcclDeterministicEnv != "TRUE" && hcclDeterministicEnv != "FALSE") {
588 0 : HCCL_ERROR("HCCL_DETERMINISTIC is set to [%s], which is incorrect. Please check", hcclDeterministicEnv.c_str());
589 0 : return HCCL_E_PARA;
590 : }
591 12 : if (hcclDeterministicEnv == "STRICT") {
592 : // 规约保序场景（严格的确定性计算，在确定性的基础上强保证规约顺序一致）
593 : DevType deviceType;
594 0 : CHK_RET(hrtGetDeviceType(deviceType));
595 0 : if (deviceType != DevType::DEV_TYPE_910B && deviceType != DevType::DEV_TYPE_910_93) {
596 : // 规约保序仅支持A2 A3场景
597 0 : HCCL_ERROR(
598 : "HCCL_DETERMINISTIC is set to [%s], Reduce order preservation is not supported for "
599 : "deviceType[%d], please check",
600 : hcclDeterministicEnv.c_str(), deviceType);
601 0 : return HCCL_E_NOT_SUPPORT;
602 : }
603 0 : g_externalInput.hcclDeterministic = DETERMINISTIC_STRICT;
604 12 : } else if (hcclDeterministicEnv == "TRUE") {
605 : // 确定性计算场景（不保证规约保序）
606 12 : g_externalInput.hcclDeterministic = DETERMINISTIC_ENABLE;
607 : } else {
608 0 : g_externalInput.hcclDeterministic = DETERMINISTIC_DISABLE;
609 : }
610 12 : HCCL_RUN_INFO(
611 : "[HCCL_ENV] HCCL_DETERMINISTIC set by environment to [%s], hcclDeterministic[%u]", hcclDeterministicEnv.c_str(),
612 : g_externalInput.hcclDeterministic);
613 12 : return HCCL_SUCCESS;
614 392 : }
615 :
616 392 : HcclResult ParseIntraLinkType()
617 : {
618 784 : std::string intraPcieEnv = GET_ENV(MM_ENV_HCCL_INTRA_PCIE_ENABLE);
619 392 : std::string intraRoceEnv = GET_ENV(MM_ENV_HCCL_INTRA_ROCE_ENABLE);
620 :
621 392 : u32 intraPcie = 1; // 保存pcie环境变量的解析数字
622 392 : u32 intraRoce = 0; // 保存roce环境变量的解析数字
623 :
624 : // 两个通信域环境变量均未设置，默认走pcie
625 392 : if (intraPcieEnv == "EmptyString" && intraRoceEnv == "EmptyString") {
626 391 : HCCL_RUN_INFO(
627 : "[HCCL_ENV] HCCL_INTRA_PCIE_ENABLE set by default to [%u], HCCL_INTRA_ROCE_ENABLE set by default to [%u]",
628 : intraPcie, intraRoce);
629 391 : return HCCL_SUCCESS;
630 : }
631 :
632 1 : if (intraPcieEnv != "EmptyString") { // 解析HCCL_INTRA_PCIE_ENABLE为数字
633 : // 校验环境变量长度
634 0 : bool isEnvLenValid = CheckEnvLen(intraPcieEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
635 0 : CHK_PRT_RET(
636 : !isEnvLenValid,
637 : HCCL_ERROR(
638 : "[Parse][IntraLinkType]errNo[0x%016llx] Invalid INTRA_PCIE_ENABLE env len, len is bigger than "
639 : "[%u]. errorno[%d]",
640 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
641 : HCCL_E_PARA);
642 0 : std::string intraPcieStr(intraPcieEnv);
643 0 : CHK_RET(GetIntraLinkTypeDigit(intraPcieStr, intraPcie));
644 0 : }
645 :
646 1 : if (intraRoceEnv != "EmptyString") { // 解析HCCL_INTRA_ROCE_ENABLE为数字
647 : // 校验环境变量长度
648 1 : bool isEnvLenValid = CheckEnvLen(intraRoceEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
649 1 : CHK_PRT_RET(
650 : !isEnvLenValid,
651 : HCCL_ERROR(
652 : "[Parse][IntraLinkType]errNo[0x%016llx] Invalid INTRA_ROCE_ENABLE env len, len is bigger than "
653 : "[%u]. errorno[%d]",
654 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
655 : HCCL_E_PARA);
656 1 : std::string intraRoceStr(intraRoceEnv);
657 1 : CHK_RET(GetIntraLinkTypeDigit(intraRoceStr, intraRoce));
658 1 : }
659 :
660 : // 只配置了roce的环境变量
661 1 : if (intraPcieEnv == "EmptyString" && intraRoceEnv != "EmptyString") {
662 1 : if (intraRoce == 0) { // roce环境变量值为0，报错
663 0 : HCCL_ERROR("[Parse][IntraLinkType]only set HCCL_INTRA_ROCE_ENABLE, and the val is zero, pls set "
664 : "HCCL_INTRA_PCIE_ENABLE");
665 0 : return HCCL_E_PARA;
666 : } else { // roce环境变量值为1，走roce
667 1 : intraPcie = 0;
668 : }
669 1 : HCCL_RUN_INFO(
670 : "[HCCL_ENV] HCCL_INTRA_PCIE_ENABLE set by environment to [%u], "
671 : "HCCL_INTRA_ROCE_ENABLE set by environment to [%u]",
672 : intraPcie, intraRoce);
673 : }
674 :
675 : // 只配置了pcie的环境变量
676 1 : if (intraPcieEnv != "EmptyString" && intraRoceEnv == "EmptyString") {
677 0 : if (intraPcie == 0) { // pcie环境变量值为0，报错
678 0 : HCCL_ERROR("[Parse][IntraLinkType]only set HCCL_INTRA_PCIE_ENABLE, and the val is zero, pls set "
679 : "HCCL_INTRA_ROCE_ENABLE");
680 0 : return HCCL_E_PARA;
681 : }
682 0 : HCCL_RUN_INFO(
683 : "[HCCL_ENV] HCCL_INTRA_PCIE_ENABLE set by environment to [%u], "
684 : "HCCL_INTRA_ROCE_ENABLE set by default to [%u]",
685 : intraPcie, intraRoce);
686 : }
687 :
688 : // pcie和roce环境变量同时配置且不相等
689 1 : if (intraPcieEnv != "EmptyString" && intraRoceEnv != "EmptyString") {
690 0 : if ((intraPcie == 0 && intraRoce == 1) || (intraPcie == 1 && intraRoce == 0)) {
691 0 : HCCL_RUN_INFO(
692 : "[HCCL_ENV] HCCL_INTRA_PCIE_ENABLE set by environment to [%u], "
693 : "HCCL_INTRA_ROCE_ENABLE set by environment to [%u]",
694 : intraPcie, intraRoce);
695 : }
696 : }
697 :
698 : // pcie和roce环境变量同时配置且相等
699 1 : if (!(intraPcie ^ intraRoce)) {
700 0 : if (intraPcie == 1) { // 同时为1，暂不支持，报错
701 0 : HCCL_ERROR(
702 : "[Parse][IntraLinkType] Enabling intra Pcie and intra Roce at the same time is not supported now.");
703 0 : return HCCL_E_PARA;
704 : } else { // 同时为0，走pcie
705 0 : HCCL_WARNING("Pcie and Roce Env both set to zero at the same time, intra comm is default Pcie");
706 0 : intraPcie = 1;
707 : }
708 0 : HCCL_RUN_INFO(
709 : "[HCCL_ENV] HCCL_INTRA_PCIE_ENABLE set by environment to [%u], "
710 : "HCCL_INTRA_ROCE_ENABLE set by environment to [%u]",
711 : intraPcie, intraRoce);
712 : }
713 :
714 1 : g_externalInput.intraRoceSwitch = intraRoce;
715 1 : return HCCL_SUCCESS;
716 392 : }
717 392 : HcclResult ParseProfilingConfig()
718 : {
719 392 : g_externalInput.profilingMode = false;
720 392 : g_externalInput.profilingOption = "";
721 392 : std::string profilingEnv = GET_ENV(MM_ENV_PROFILING_MODE);
722 392 : CHK_PRT_RET(
723 : profilingEnv == "EmptyString",
724 : HCCL_RUN_INFO(
725 : "[HCCL_ENV] environmental variable PROFILING_MODE and GE profiling option is not set, default: false"),
726 : HCCL_SUCCESS);
727 5 : HCCL_DEBUG("PROFILING_MODE[%s] is set", profilingEnv.c_str());
728 5 : CHK_PRT_RET(
729 : profilingEnv.compare("true") != 0, HCCL_INFO("environmental variable PROFILING_MODE = false"), HCCL_SUCCESS);
730 0 : g_externalInput.profilingMode = true;
731 0 : profilingEnv = GET_ENV(MM_ENV_PROFILING_OPTIONS);
732 0 : CHK_PRT_RET(
733 : profilingEnv == "EmptyString", HCCL_RUN_INFO("[HCCL_ENV] environmental variable PROFILING_OPTIONS is not set."),
734 : HCCL_SUCCESS);
735 :
736 0 : g_externalInput.profilingOption = profilingEnv;
737 0 : HCCL_RUN_INFO("[HCCL_ENV] Set Env [PROFILING_MODE]: Value[%s]", g_externalInput.profilingOption.c_str());
738 0 : return HCCL_SUCCESS;
739 392 : }
740 :
741 394 : HcclResult ParseHcclWhitelistFilePath()
742 : {
743 394 : CHK_PRT_RET((g_externalInput.enableWhitelist != HCCL_WHITELIST_ON), , HCCL_SUCCESS); // 白名单功能无效时无需解析
744 :
745 4 : std::string filePath = GET_ENV(MM_ENV_HCCL_WHITELIST_FILE);
746 4 : if (filePath == "EmptyString") {
747 1 : g_externalInput.hcclWhiteListFile.clear();
748 1 : HCCL_RUN_INFO("[HCCL_ENV][Parse][HcclWhitelistFilePath]environmental variable HCCL_WHITELIST_DISABLE is [0],"
749 : "but HCCL_WHITELIST_FILE is not set");
750 : } else {
751 3 : u32 len = strnlen(filePath.c_str(), PATH_MAX);
752 3 : if (len == (PATH_MAX) || len == 0) {
753 0 : HCCL_ERROR(
754 : "[Parse][HcclWhitelistFilePath]errNo[0x%016llx] env[HCCL_WHITELIST_FILE] is invalid, "
755 : "len is %u",
756 : HCCL_ERROR_CODE(HCCL_E_PARA), len);
757 0 : return HCCL_E_PARA;
758 : }
759 : // 校验文件是否存在
760 3 : char realFile[PATH_MAX] = {0};
761 3 : if (realpath(filePath.c_str(), realFile) == nullptr) {
762 0 : HCCL_RUN_WARNING(
763 : "[HCCL_ENV][Parse][HcclWhitelistFilePath]path %s is not a valid real path", filePath.c_str());
764 0 : g_externalInput.hcclWhiteListFile.clear();
765 : } else {
766 3 : g_externalInput.hcclWhiteListFile = realFile;
767 : }
768 3 : HCCL_RUN_INFO(
769 : "[HCCL_ENV] HCCL_WHITELIST_FILE set by environment to [%s], realpath[%s].", filePath.c_str(),
770 : g_externalInput.hcclWhiteListFile.c_str());
771 : }
772 4 : return HCCL_SUCCESS;
773 4 : }
774 :
775 392 : HcclResult ParseMultiQpSrcPortConfigPath()
776 : {
777 392 : std::string filePath = GET_ENV(MM_ENV_HCCL_RDMA_QP_PORT_CONFIG_PATH);
778 392 : if (filePath == "EmptyString") {
779 391 : g_externalInput.multiQpSrcPortConfigPath.clear();
780 391 : HCCL_RUN_INFO(
781 : "[HCCL_ENV][Parse][MultiQpSrcPortConfigPath]environmental variable HCCL_RDMA_QP_PORT_CONFIG_PATH is empty");
782 : } else {
783 1 : u32 len = filePath.size() > PATH_MAX ? PATH_MAX : filePath.size();
784 1 : if (len == (PATH_MAX) || len == 0) {
785 0 : HCCL_ERROR(
786 : "[Parse][MultiQpSrcPortConfigPath]errNo[0x%016llx] env[HCCL_RDMA_QP_PORT_CONFIG_PATH] is invalid,"
787 : "len is %u",
788 : HCCL_ERROR_CODE(HCCL_E_PARA), len);
789 0 : return HCCL_E_PARA;
790 : }
791 : // 校验文件是否存在
792 1 : char realFile[PATH_MAX] = {0};
793 1 : if (realpath(filePath.c_str(), realFile) == nullptr) {
794 0 : HCCL_ERROR(
795 : "[Parse][MultiQpSrcPortConfigPath]errNo[0x%016llx] path %s is not a valid real path",
796 : HCOM_ERROR_CODE(HCCL_E_PARA), filePath.c_str());
797 0 : return HCCL_E_PARA;
798 : }
799 1 : g_externalInput.multiQpSrcPortConfigPath = realFile;
800 1 : HCCL_RUN_INFO(
801 : "[HCCL_ENV] HCCL_RDMA_QP_PORT_CONFIG_PATH set by environment to [%s], realpath[%s]", filePath.c_str(),
802 : g_externalInput.multiQpSrcPortConfigPath.c_str());
803 : }
804 392 : return HCCL_SUCCESS;
805 392 : }
806 :
807 394 : HcclResult ParseHcclWhitelistSwitch()
808 : {
809 394 : std::string disableWhitelistEnv = GET_ENV(MM_ENV_HCCL_WHITELIST_DISABLE);
810 394 : u32 disableWhitelist = 0;
811 :
812 394 : if (disableWhitelistEnv != "EmptyString") {
813 : // 校验环境变量长度
814 8 : bool isEnvLenValid = CheckEnvLen(disableWhitelistEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
815 8 : CHK_PRT_RET(
816 : !isEnvLenValid,
817 : HCCL_ERROR(
818 : "[Parse][WhitelistSwitch]errNo[0x%016llx] Invalid HCCL_WHITELIST_DISABLE env len, len is "
819 : "bigger than [%u]. errorno[%d]",
820 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
821 : HCCL_E_PARA);
822 8 : HcclResult ret = SalStrToULong(disableWhitelistEnv, HCCL_BASE_DECIMAL, disableWhitelist);
823 : // 若转换出错或使能开关的值不为0和1，报错并设置为默认值
824 8 : if (ret != HCCL_SUCCESS || disableWhitelist > 1) {
825 0 : HCCL_ERROR(
826 : "[Parse][WhitelistSwitch]environmental variable HCCL_WHITELIST_DISABLE[%s] is invalid, "
827 : "expect[%u ~ %u].",
828 : disableWhitelistEnv.c_str(), 0, 1);
829 0 : g_externalInput.enableWhitelist = HCCL_WHITELIST_OFF;
830 0 : return HCCL_E_PARA;
831 : }
832 8 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_WHITELIST_DISABLE set by environment to [%u]", disableWhitelist);
833 : } else {
834 386 : disableWhitelist = 1; // 缺省时关闭白名单
835 386 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_WHITELIST_DISABLE set by default to [%u]", disableWhitelist);
836 : }
837 394 : g_externalInput.enableWhitelist = !disableWhitelist;
838 394 : return HCCL_SUCCESS;
839 394 : }
840 :
841 392 : HcclResult ParseHcclIfBasePort()
842 : {
843 392 : std::string ifBasePort = GET_ENV(MM_ENV_HCCL_IF_BASE_PORT);
844 392 : u32 basePort = HCCL_INVALID_PORT;
845 :
846 392 : if (ifBasePort != "EmptyString") {
847 : // 校验环境变量长度
848 1 : bool isEnvLenValid = CheckEnvLen(ifBasePort.c_str(), MAX_LEN_OF_DIGIT_ENV);
849 1 : CHK_PRT_RET(
850 : !isEnvLenValid,
851 : HCCL_ERROR(
852 : "[Parse][HcclIfBasePort]errNo[0x%016llx] Invalid HcclIfBasePort env len, len is bigger than "
853 : "[%u]. errorno[%d]",
854 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
855 : HCCL_E_PARA);
856 :
857 1 : CHK_RET(IsAllDigit(ifBasePort.c_str()));
858 1 : HcclResult ret = SalStrToULong(ifBasePort, HCCL_BASE_DECIMAL, basePort);
859 : // 若数字小于1024或者数字大于65520，报错并设置为默认值HOST_CONTROL_BASE_PORT
860 1 : if (ret != HCCL_SUCCESS || basePort > HOST_PORT_MAX || basePort < HCCL_BASE_PORT_MIN) {
861 0 : HCCL_ERROR(
862 : "[Parse][HcclIfBasePort]environmental variable HCCL_IF_BASE_PORT error, errNo[0x%016llx]"
863 : "ifBasePort[%s] portRange[%u,%u]",
864 : HCOM_ERROR_CODE(ret), ifBasePort.c_str(), HCCL_BASE_PORT_MIN, HOST_PORT_MAX);
865 0 : return HCCL_E_PARA;
866 : }
867 1 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_IF_BASE_PORT set by environment to [%u]", basePort);
868 : } else {
869 391 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_IF_BASE_PORT set by default to [%u]", HOST_CONTROL_BASE_PORT);
870 : }
871 392 : g_externalInput.hcclIfBasePort = basePort;
872 392 : return HCCL_SUCCESS;
873 392 : }
874 :
875 392 : HcclResult ParseHcclIfIp()
876 : {
877 392 : std::string hcclControlIfIp = GET_ENV(MM_ENV_HCCL_IF_IP);
878 392 : if (hcclControlIfIp != "EmptyString") {
879 5 : CHK_PRT_RET(
880 : g_externalInput.hcclControlIfIp.SetReadableAddress(hcclControlIfIp),
881 : HCCL_ERROR("[Parse][HcclIfIp]IP address[%s] is invalid.", hcclControlIfIp.c_str()), HCCL_E_PARA);
882 5 : HCCL_RUN_INFO(
883 : "[HCCL_ENV] HCCL_IF_IP is set to [%s], ip[%s].", hcclControlIfIp.c_str(),
884 : g_externalInput.hcclControlIfIp.GetReadableAddress());
885 : } else {
886 387 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_IF_IP is not set");
887 : }
888 392 : return HCCL_SUCCESS;
889 392 : }
890 :
891 392 : HcclResult ParseHcclSocketFamily()
892 : {
893 392 : std::string hcclSocketFamily = GET_ENV(MM_ENV_HCCL_SOCKET_FAMILY);
894 392 : if (hcclSocketFamily != "EmptyString") {
895 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_SOCKET_FAMILY set by environment to [%s]", hcclSocketFamily.c_str());
896 0 : if (hcclSocketFamily == "AF_INET") {
897 0 : g_externalInput.hcclSocketFamily = AF_INET;
898 0 : } else if (hcclSocketFamily == "AF_INET6") {
899 0 : g_externalInput.hcclSocketFamily = AF_INET6;
900 : } else {
901 0 : g_externalInput.hcclSocketFamily = -1;
902 0 : HCCL_ERROR(
903 : "[Parse][HcclSocketFamily]environmental variable HCCL_SOCKET_FAMILY[%s] is invalid. it should "
904 : "be \"AF_INET\" or \"AF_INET6\".",
905 : hcclSocketFamily.c_str());
906 0 : return HCCL_E_PARA;
907 : }
908 : } else {
909 392 : g_externalInput.hcclSocketFamily = -1;
910 392 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_SOCKET_FAMILY is not set and is used by default [AF_INET]");
911 : }
912 392 : return HCCL_SUCCESS;
913 392 : }
914 :
915 392 : HcclResult ParseHcclSocketIfName()
916 : {
917 392 : bool searchNot = false;
918 392 : bool searchExact = false;
919 392 : std::string hcclSocketIfName = GET_ENV(MM_ENV_HCCL_SOCKET_IFNAME);
920 392 : std::string remainSocketIfName = hcclSocketIfName;
921 392 : g_externalInput.hcclSocketIfName.configIfNames.clear();
922 :
923 392 : if (hcclSocketIfName != "EmptyString") {
924 : // 获取HCCL_SOCKET_IFNAME环境变量匹配规则
925 3 : if (!hcclSocketIfName.empty() && hcclSocketIfName.at(0) == '^') {
926 0 : searchNot = true;
927 : // 获取从1位置开始剩余部分环境变量内容
928 0 : remainSocketIfName = hcclSocketIfName.substr(1);
929 : }
930 :
931 3 : if (!remainSocketIfName.empty() && remainSocketIfName.at(0) == '=') {
932 2 : searchExact = true;
933 2 : remainSocketIfName = remainSocketIfName.substr(1);
934 : }
935 :
936 : // 获取用户输入的网卡名列表(使用逗号隔开),将网卡名列表存放到全局vector变量中
937 3 : HcclResult ret = SplitHcclSocketIfName(remainSocketIfName, g_externalInput.hcclSocketIfName.configIfNames);
938 3 : CHK_PRT_RET(
939 : ret != HCCL_SUCCESS,
940 : HCCL_ERROR("[Parse][HcclSocketIfName]hccl IfName config[%s] is invalid.", hcclSocketIfName.c_str()),
941 : HCCL_E_PARA);
942 3 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_SOCKET_IFNAME set by environment to [%s]", hcclSocketIfName.c_str());
943 : } else {
944 389 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_SOCKET_IFNAME set by default to [%s]", hcclSocketIfName.c_str());
945 : }
946 392 : g_externalInput.hcclSocketIfName.searchNot = searchNot;
947 392 : g_externalInput.hcclSocketIfName.searchExact = searchExact;
948 392 : return HCCL_SUCCESS;
949 392 : }
950 :
951 3 : HcclResult SplitHcclSocketIfName(const std::string& socketIfName, std::vector<std::string>& configIfNames)
952 : {
953 3 : std::string remainSocketIfName;
954 3 : std::size_t found = socketIfName.find(",");
955 3 : if ((found == 0) || (found == (socketIfName.length() - 1))) {
956 0 : HCCL_ERROR("[Split][HcclSocketIfName] configIfNames config is invalid.");
957 0 : return HCCL_E_PARA;
958 3 : } else if (found != std::string::npos) {
959 0 : remainSocketIfName = socketIfName.substr(found + 1);
960 : } else {
961 : // 最后一组配置,剩余的字符串为空
962 : }
963 3 : configIfNames.push_back(socketIfName.substr(0, found));
964 :
965 3 : if (!remainSocketIfName.empty()) {
966 0 : CHK_RET(SplitHcclSocketIfName(remainSocketIfName, configIfNames));
967 : }
968 :
969 3 : return HCCL_SUCCESS;
970 3 : }
971 :
972 3 : HcclResult SetHccLExecTimeOut(const char* execTimeOutStr, const HcclExecTimeoutSet execTimeOutSet)
973 : {
974 3 : CHK_PTR_NULL(execTimeOutStr);
975 6 : if (!IsValidExecTimeOutMs(execTimeOutStr)) {
976 0 : HCCL_ERROR("[SetHccLExecTimeOut]Invalid config value, execTimeOutStr[%s]", execTimeOutStr);
977 0 : RPT_ENV_ERR(
978 : true, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
979 : std::vector<std::string>(
980 : {std::string(execTimeOutStr), "HCCL_EXEC_TIMEOUT", "a valid number in the specified range"}));
981 0 : return HCCL_E_PARA;
982 : }
983 : DevType deviceType;
984 3 : CHK_RET(hrtGetDeviceType(deviceType)); // 910A和910B要分开
985 3 : double hcclExecTimeout = (deviceType == DevType::DEV_TYPE_910_93 || deviceType == DevType::DEV_TYPE_910B) ?
986 : HCCL_EXEC_TIME_OUT_S_910_93 :
987 : HCCL_EXEC_TIME_OUT_S;
988 3 : double execTimeOut = hcclExecTimeout;
989 3 : g_externalInput.execTimeOut = hcclExecTimeout;
990 3 : HcclResult ret = SalStrToDouble(execTimeOutStr, execTimeOut);
991 3 : bool flag = false;
992 3 : std::string inputValue = (execTimeOutStr ? execTimeOutStr : "NULL");
993 3 : if (deviceType == DevType::DEV_TYPE_910_93 || deviceType == DevType::DEV_TYPE_910B) {
994 : // 910B和910_93算子超时时间范围0s-2147483647s,其中0代表永不超时
995 0 : flag = (ret != HCCL_SUCCESS || (execTimeOut < 0) || (execTimeOut > HCCL_EXEC_TIME_OUT_S_910_93));
996 0 : RPT_ENV_ERR(
997 : flag, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
998 : std::vector<std::string>(
999 : {inputValue, "HCCL_EXEC_TIMEOUT",
1000 : "a number greater than or equal to 0s and less "
1001 : "than or equal to 2147483647s"}));
1002 0 : CHK_PRT_RET(
1003 : flag,
1004 : HCCL_ERROR(
1005 : "[%s][%s]ExecTimeOut[%s]s is invalid. except: [0, %d]", LOG_KEYWORDS_INIT_GROUP.c_str(),
1006 : LOG_KEYWORDS_ENV_CONFIG.c_str(), execTimeOutStr, HCCL_EXEC_TIME_OUT_S_910_93),
1007 : HCCL_E_PARA);
1008 : } else {
1009 : // 非910B和910_93算子超时时间范围1s-17340s
1010 3 : flag = (ret != HCCL_SUCCESS || (execTimeOut <= 0) || (execTimeOut > HCCL_EXEC_TIME_OUT_S));
1011 3 : RPT_ENV_ERR(
1012 : flag, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
1013 : std::vector<std::string>(
1014 : {inputValue, "HCCL_EXEC_TIMEOUT",
1015 : "a number greater than or equal to 1s and less than or equal to 17340s"}));
1016 3 : CHK_PRT_RET(
1017 : flag,
1018 : HCCL_ERROR(
1019 : "[%s][%s]ExecTimeOut[%s]s is invalid. except: [1, %d]", LOG_KEYWORDS_INIT_GROUP.c_str(),
1020 : LOG_KEYWORDS_ENV_CONFIG.c_str(), execTimeOutStr, HCCL_EXEC_TIME_OUT_S),
1021 : HCCL_E_PARA);
1022 3 : s32 intPart = static_cast<s32>(execTimeOut / HCCL_INTEVAL_EXEC_TIME_OUT_S);
1023 3 : intPart = (intPart == 0) ? 1 : intPart;
1024 3 : execTimeOut = intPart * HCCL_INTEVAL_EXEC_TIME_OUT_S;
1025 : }
1026 3 : g_externalInput.execTimeOut = execTimeOut;
1027 3 : g_externalInput.execTimeOutSet = execTimeOutSet;
1028 3 : if (execTimeOutSet == HcclExecTimeoutSet::HCCL_EXEC_TIMEOUT_SET_BY_ENV) {
1029 3 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_EXEC_TIMEOUT set by environment to [%.2f]s", execTimeOut);
1030 : } else {
1031 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_EXEC_TIMEOUT set by GE option to [%.2f]s", execTimeOut);
1032 : }
1033 3 : return HCCL_SUCCESS;
1034 3 : }
1035 :
1036 19 : bool CheckEnvLen(const char* envStr, u32 envMaxLen)
1037 : {
1038 : // 校验环境变量长度
1039 19 : u32 envLen = strnlen(envStr, envMaxLen + 1);
1040 19 : if (envLen == (envMaxLen + 1)) {
1041 0 : HCCL_ERROR(
1042 : "[Check][EnvLen]errNo[0x%016llx] env len is invalid, len is %u", HCCL_ERROR_CODE(HCCL_E_PARA), envLen);
1043 0 : return false;
1044 : }
1045 19 : return true;
1046 : }
1047 0 : HcclResult SetMasterInfo(
1048 : const string& masterIp, const string& masterPort, const string& masterDeviceId, const string& rankSize,
1049 : const string& rankIp)
1050 : {
1051 0 : HcclResult ret = HCCL_SUCCESS;
1052 0 : ret = g_externalInput.masterInfo.serverIp.SetReadableAddress(masterIp);
1053 0 : if (ret != HCCL_SUCCESS) {
1054 0 : RPT_ENV_ERR(
1055 : ret, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
1056 : std::vector<std::string>({masterIp, "CM_CHIEF_IP", "a valid IPv4/IPv6 address string"}));
1057 0 : HCCL_ERROR(
1058 : "[%s][%s]errNo[0x%016llx] %s errorno[%d]", LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(),
1059 : HCOM_ERROR_CODE(ret), "Invalid masterIp address", ret);
1060 0 : return HCCL_E_PARA;
1061 : }
1062 :
1063 0 : ret = IsAllDigit(masterPort.c_str());
1064 0 : ret = (ret == HCCL_SUCCESS) ? SalStrToULong(masterPort, HCCL_BASE_DECIMAL, g_externalInput.masterInfo.port) : ret;
1065 0 : if (ret != HCCL_SUCCESS || g_externalInput.masterInfo.port > HOST_PORT_MAX) {
1066 0 : RPT_ENV_ERR(
1067 : HCCL_E_PARA, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
1068 : std::vector<std::string>({masterPort, "CM_CHIEF_PORT", "a unsigned number less than the max port num"}));
1069 0 : HCCL_ERROR(
1070 : "[%s][%s]errNo[0x%016llx] option masterPort[CM_CHIEF_PORT] error, %s errorno[%d]",
1071 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCOM_ERROR_CODE(ret), "out of range",
1072 : ret);
1073 0 : return HCCL_E_PARA;
1074 : }
1075 :
1076 0 : ret = IsAllDigit(masterDeviceId.c_str());
1077 0 : ret = (ret == HCCL_SUCCESS) ?
1078 0 : SalStrToULong(masterDeviceId, HCCL_BASE_DECIMAL, g_externalInput.masterInfo.serverDeviceId) :
1079 : ret;
1080 : u32 maxDeviceNum;
1081 0 : CHK_RET(GetMaxDevNum(maxDeviceNum));
1082 0 : if (ret != HCCL_SUCCESS || g_externalInput.masterInfo.serverDeviceId >= maxDeviceNum) {
1083 0 : RPT_ENV_ERR(
1084 : HCCL_E_PARA, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
1085 : std::vector<std::string>(
1086 : {masterDeviceId, "CM_CHIEF_DEVICE", "a unsigned number less than the max device num"}));
1087 0 : HCCL_ERROR(
1088 : "[%s][%s]errNo[0x%016llx] option master device id[CM_CHIEF_DEVICE] error, masterDeviceId[%s]"
1089 : "errorno[%d]",
1090 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCOM_ERROR_CODE(ret),
1091 : masterDeviceId.c_str(), ret);
1092 0 : return HCCL_E_PARA;
1093 : }
1094 :
1095 0 : if (rankIp.size() == 0) {
1096 0 : g_externalInput.masterInfo.agentIp.clear();
1097 : } else {
1098 0 : ret = g_externalInput.masterInfo.agentIp.SetReadableAddress(rankIp);
1099 0 : if (ret != HCCL_SUCCESS) {
1100 0 : RPT_ENV_ERR(
1101 : HCCL_E_PARA, "EI0001", std::vector<std::string>({"value", "env", "expect"}),
1102 : std::vector<std::string>({rankIp, "CM_WORKER_IP", "an available ip"}));
1103 0 : HCCL_ERROR(
1104 : "[%s][%s]errNo[0x%016llx] masterIp agent address[CM_WORKER_IP][%s] is invalid. errorno[%d]",
1105 : LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_ENV_CONFIG.c_str(), HCOM_ERROR_CODE(ret), rankIp.c_str(),
1106 : ret);
1107 0 : return HCCL_E_PARA;
1108 : }
1109 : }
1110 :
1111 0 : ret = IsAllDigit(rankSize.c_str());
1112 0 : ret = (ret == HCCL_SUCCESS) ? SalStrToULong(rankSize, HCCL_BASE_DECIMAL, g_externalInput.masterInfo.rankSize) : ret;
1113 0 : if (ret != HCCL_SUCCESS) {
1114 0 : HCCL_ERROR(
1115 : "[Parse][HcclMasterInfo] option rankSize[CM_WORKER_SIZE] error, errNo[0x%016llx] rankSize[%s]",
1116 : HCOM_ERROR_CODE(ret), rankSize.c_str());
1117 0 : return HCCL_E_PARA;
1118 : }
1119 0 : return HCCL_SUCCESS;
1120 0 : }
1121 515 : HcclResult SetTcpMode(const bool isTcpMode)
1122 : {
1123 515 : g_externalInput.isTcpMode = isTcpMode;
1124 515 : return HCCL_SUCCESS;
1125 : }
1126 :
1127 0 : u32 GetEsMaxPsTable() { return g_externalInput.esMaxPsTable; }
1128 :
1129 0 : HcclResult SetEsStreamNum(const u32 streamNum)
1130 : {
1131 0 : g_externalInput.streamNum = streamNum;
1132 0 : return HCCL_SUCCESS;
1133 : }
1134 :
1135 0 : u32 GetEsStreamNum() { return g_externalInput.streamNum; }
1136 :
1137 2 : HcclResult SetDeterministic(u8 deterministic)
1138 : {
1139 2 : g_externalInput.hcclDeterministic = deterministic;
1140 2 : return HCCL_SUCCESS;
1141 : }
1142 :
1143 0 : void SetDumpDebugMode(const bool dumpDebug)
1144 : {
1145 0 : g_externalInput.dumpDebug = dumpDebug;
1146 0 : return;
1147 : }
1148 :
1149 462 : HcclResult SetFftsSwitch(const bool switchStatus)
1150 : {
1151 462 : g_externalInput.enableFfts = switchStatus;
1152 462 : return HCCL_SUCCESS;
1153 : }
1154 :
1155 392 : HcclResult ParseRDMATrafficClass()
1156 : {
1157 392 : std::string trafficClassEnv = GET_ENV(MM_ENV_HCCL_RDMA_TC);
1158 392 : u32 rdmaTrafficClass = HCCL_RDMA_TC_DEFAULT;
1159 :
1160 392 : if (trafficClassEnv == "EmptyString") {
1161 392 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_TC set by default to [%u]", rdmaTrafficClass);
1162 392 : return HCCL_SUCCESS;
1163 : }
1164 :
1165 : // 校验环境变量长度
1166 0 : bool isEnvLenValid = CheckEnvLen(trafficClassEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
1167 :
1168 0 : CHK_PRT_RET(
1169 : !isEnvLenValid,
1170 : HCCL_ERROR(
1171 : "[Parse][TrafficClass]errNo[0x%016llx] Invalid HCCL_RDMA_TC env len, len is bigger than "
1172 : "[%u]. errorno[%d]",
1173 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
1174 : HCCL_E_PARA);
1175 :
1176 0 : g_externalInput.rdmaTrafficClass = HCCL_RDMA_TC_DEFAULT;
1177 0 : CHK_RET(IsAllDigit(trafficClassEnv.c_str()));
1178 :
1179 0 : HcclResult ret = SalStrToULong(trafficClassEnv.c_str(), HCCL_BASE_DECIMAL, rdmaTrafficClass);
1180 : // 若转换出错或者设置的RDMATrafficClass不在有效范围内，报错
1181 0 : CHK_PRT_RET(
1182 : (ret != HCCL_SUCCESS || rdmaTrafficClass > HCCL_RDMA_TC_MAX),
1183 : HCCL_ERROR(
1184 : "[Parse][TrafficClass]HCCL_RDMA_TC[%s] is invalid. except: [%u, %u]", trafficClassEnv.c_str(),
1185 : HCCL_RDMA_TC_MIN, HCCL_RDMA_TC_MAX),
1186 : HCCL_E_PARA);
1187 : // 设置的RDMATrafficClass需要是4的整数倍, 否则报错
1188 0 : if (rdmaTrafficClass % HCCL_RDMA_TC_BASE != 0) {
1189 0 : HCCL_ERROR("rdmaTrafficClass[%u] is not a multiple of [%u]", rdmaTrafficClass, HCCL_RDMA_TC_BASE);
1190 0 : return HCCL_E_PARA;
1191 : }
1192 0 : g_externalInput.rdmaTrafficClass = rdmaTrafficClass;
1193 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_TC set by environment to [%u]", rdmaTrafficClass);
1194 0 : return HCCL_SUCCESS;
1195 392 : }
1196 :
1197 392 : HcclResult ParseRDMAServerLevel()
1198 : {
1199 392 : std::string serverLevelEnv = GET_ENV(MM_ENV_HCCL_RDMA_SL);
1200 392 : u32 rdmaServerLevel = HCCL_RDMA_SL_DEFAULT;
1201 :
1202 392 : if (serverLevelEnv == "EmptyString") {
1203 392 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_SL set by default to [%u]", rdmaServerLevel);
1204 392 : return HCCL_SUCCESS;
1205 : }
1206 :
1207 : // 校验环境变量长度
1208 0 : bool isEnvLenValid = CheckEnvLen(serverLevelEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
1209 :
1210 0 : CHK_PRT_RET(
1211 : !isEnvLenValid,
1212 : HCCL_ERROR(
1213 : "[Parse][rdmaServerLevel]errNo[0x%016llx] Invalid HCCL_RDMA_SL env len, len is bigger than "
1214 : "[%u]. errorno[%d]",
1215 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
1216 : HCCL_E_PARA);
1217 :
1218 0 : g_externalInput.rdmaServerLevel = HCCL_RDMA_SL_DEFAULT;
1219 0 : CHK_RET(IsAllDigit(serverLevelEnv.c_str()));
1220 :
1221 0 : HcclResult ret = SalStrToULong(serverLevelEnv.c_str(), HCCL_BASE_DECIMAL, rdmaServerLevel);
1222 : // 若转换出错或者设置的RDMAServerLevel不在有效范围内，报错
1223 0 : CHK_PRT_RET(
1224 : (ret != HCCL_SUCCESS || rdmaServerLevel > HCCL_RDMA_SL_MAX),
1225 : HCCL_ERROR(
1226 : "[Parse][rdmaServerLevel]HCCL_RDMA_SL[%s] is invalid. except: [%u, %u]", serverLevelEnv.c_str(),
1227 : HCCL_RDMA_SL_MIN, HCCL_RDMA_SL_MAX),
1228 : HCCL_E_PARA);
1229 0 : g_externalInput.rdmaServerLevel = rdmaServerLevel;
1230 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_SL set by environment to [%u]", rdmaServerLevel);
1231 0 : return HCCL_SUCCESS;
1232 392 : }
1233 :
1234 392 : HcclResult ParseRDMATimeOut(std::pair<u32, u32>& rdmaTimeOutRange)
1235 : {
1236 : u32 rdmaTimeOutMax;
1237 : #ifndef HCCD
1238 392 : if (!IsGeneralServer()) {
1239 : DevType deviceType;
1240 392 : CHK_RET(hrtGetDeviceType(deviceType));
1241 392 : rdmaTimeOutMax = (deviceType == DevType::DEV_TYPE_910_93 || deviceType == DevType::DEV_TYPE_910B) ?
1242 : HCCL_RDMA_TIMEOUT_MAX_910_93 :
1243 : HCCL_RDMA_TIMEOUT_MAX;
1244 : } else {
1245 0 : rdmaTimeOutMax = HCCL_RDMA_TIMEOUT_MAX;
1246 : }
1247 : #else
1248 : rdmaTimeOutMax = HCCL_RDMA_TIMEOUT_MAX;
1249 : #endif
1250 392 : rdmaTimeOutRange.first = HCCL_RDMA_TIMEOUT_MIN;
1251 392 : rdmaTimeOutRange.second = rdmaTimeOutMax;
1252 392 : std::string timeOutEnv = GET_ENV(MM_ENV_HCCL_RDMA_TIMEOUT);
1253 392 : u32 rdmaTimeOut = HCCL_RDMA_TIMEOUT_DEFAULT;
1254 392 : if (timeOutEnv == "EmptyString") {
1255 392 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_TIMEOUT set by default to [%u]", rdmaTimeOut);
1256 392 : return HCCL_SUCCESS;
1257 : }
1258 :
1259 : // 校验环境变量长度
1260 0 : bool isEnvLenValid = CheckEnvLen(timeOutEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
1261 :
1262 0 : CHK_PRT_RET(
1263 : !isEnvLenValid,
1264 : HCCL_ERROR(
1265 : "[Parse][TrafficClass]errNo[0x%016llx] Invalid HCCL_RDMA_TIMEOUT env len, len is bigger than "
1266 : "[%u]. errorno[%d]",
1267 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
1268 : HCCL_E_PARA);
1269 :
1270 0 : g_externalInput.rdmaTimeOut = HCCL_RDMA_TIMEOUT_DEFAULT;
1271 0 : CHK_RET(IsAllDigit(timeOutEnv.c_str()));
1272 :
1273 0 : HcclResult ret = SalStrToULong(timeOutEnv.c_str(), HCCL_BASE_DECIMAL, rdmaTimeOut);
1274 : // 若转换出错或者设置的RDMATrafficClass不在有效范围内，报错
1275 0 : CHK_PRT_RET(
1276 : (ret != HCCL_SUCCESS || rdmaTimeOut < HCCL_RDMA_TIMEOUT_MIN || rdmaTimeOut > rdmaTimeOutMax),
1277 : HCCL_ERROR(
1278 : "[Parse][TrafficClass]HCCL_RDMA_TIMEOUT[%s] is invalid. except: [%u, %u]", timeOutEnv.c_str(),
1279 : HCCL_RDMA_TIMEOUT_MIN, rdmaTimeOutMax),
1280 : HCCL_E_PARA);
1281 :
1282 0 : g_externalInput.rdmaTimeOut = rdmaTimeOut;
1283 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_TIMEOUT set by environment to [%u]", rdmaTimeOut);
1284 0 : return HCCL_SUCCESS;
1285 392 : }
1286 :
1287 392 : HcclResult ParseRDMARetryCnt()
1288 : {
1289 392 : std::string retryCntEnv = GET_ENV(MM_ENV_HCCL_RDMA_RETRY_CNT);
1290 392 : u32 rdmaRetryCnt = HCCL_RDMA_RETRY_CNT_DEFAULT;
1291 392 : if (retryCntEnv == "EmptyString") {
1292 392 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_RETRY_CNT set by default to [%u]", rdmaRetryCnt);
1293 392 : return HCCL_SUCCESS;
1294 : }
1295 :
1296 : // 校验环境变量长度
1297 0 : bool isEnvLenValid = CheckEnvLen(retryCntEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
1298 :
1299 0 : CHK_PRT_RET(
1300 : !isEnvLenValid,
1301 : HCCL_ERROR(
1302 : "[Parse][rdmaRetryCnt]errNo[0x%016llx] Invalid HCCL_RDMA_RETRY_CNT env len, len is bigger than "
1303 : "[%u]. errorno[%d]",
1304 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
1305 : HCCL_E_PARA);
1306 :
1307 0 : g_externalInput.rdmaRetryCnt = HCCL_RDMA_RETRY_CNT_DEFAULT;
1308 0 : CHK_RET(IsAllDigit(retryCntEnv.c_str()));
1309 :
1310 0 : HcclResult ret = SalStrToULong(retryCntEnv.c_str(), HCCL_BASE_DECIMAL, rdmaRetryCnt);
1311 : // 若转换出错或者设置的RDMAServerLevel不在有效范围内，报错
1312 0 : CHK_PRT_RET(
1313 : (ret != HCCL_SUCCESS || rdmaRetryCnt < HCCL_RDMA_RETRY_CNT_MIN || rdmaRetryCnt > HCCL_RDMA_RETRY_CNT_MAX),
1314 : HCCL_ERROR(
1315 : "[Parse][rdmaRetryCnt]HCCL_RDMA_RETRY_CNT[%s] is invalid. except: [%u, %u]", retryCntEnv.c_str(),
1316 : HCCL_RDMA_RETRY_CNT_MIN, HCCL_RDMA_RETRY_CNT_MAX),
1317 : HCCL_E_PARA);
1318 0 : g_externalInput.rdmaRetryCnt = rdmaRetryCnt;
1319 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_RETRY_CNT set by environment to [%u]", rdmaRetryCnt);
1320 0 : return HCCL_SUCCESS;
1321 392 : }
1322 : #if !defined(CCL_KERNEL_AICPU) && !defined(HCCD)
1323 : namespace {
1324 : #define PKG_VERSION_MAX_SIZE 128
1325 : constexpr auto kVersionInfoKey = "Version=";
1326 : constexpr auto kRelPathInfo = "/share/info/";
1327 : constexpr auto kInfoFileName = "/version.info";
1328 784 : std::string Trim(const std::string& str)
1329 : {
1330 784 : const size_t first = str.find_first_not_of(" \t\r\n");
1331 784 : if (std::string::npos == first) {
1332 0 : return "";
1333 : }
1334 784 : const size_t last = str.find_last_not_of(" \t\r\n");
1335 784 : return str.substr(first, (last - first + 1));
1336 : }
1337 :
1338 784 : HcclResult GetVersionStringInternal(
1339 : const std::string& fullPath, const char_t* pkgName, std::string& versionOut, bool isSilent = false)
1340 : {
1341 784 : std::ifstream ifs(fullPath);
1342 784 : if (!ifs.is_open()) {
1343 0 : if (isSilent) {
1344 0 : HCCL_WARNING("Version file not found at [%s] (Silent check, will retry alternative).", fullPath.c_str());
1345 : } else {
1346 0 : HCCL_WARNING(
1347 : "Version file not found at [%s]. Please check if package name [%s] is correct and package is "
1348 : "installed.",
1349 : fullPath.c_str(), pkgName);
1350 : }
1351 0 : return HCCL_E_OPEN_FILE_FAILURE;
1352 : }
1353 784 : std::string line;
1354 784 : bool found = false;
1355 784 : const size_t keyLen = std::strlen(kVersionInfoKey);
1356 784 : while (std::getline(ifs, line)) {
1357 784 : const size_t pos = line.find(kVersionInfoKey);
1358 784 : if (pos != std::string::npos) {
1359 784 : versionOut = Trim(line.substr(pos + keyLen));
1360 784 : found = true;
1361 784 : break;
1362 : }
1363 : }
1364 784 : ifs.close();
1365 784 : if (!found || versionOut.empty()) {
1366 0 : HCCL_WARNING("Keyword [%s] not found in file [%s].", kVersionInfoKey, fullPath.c_str());
1367 0 : return HCCL_E_NOT_FOUND;
1368 : }
1369 784 : return HCCL_SUCCESS;
1370 784 : }
1371 :
1372 784 : std::string GetLocalRealPath(const std::string& path)
1373 : {
1374 784 : if (path.empty()) {
1375 0 : return "";
1376 : }
1377 784 : char resolvedPath[PATH_MAX] = {0};
1378 784 : if (realpath(path.c_str(), resolvedPath) == nullptr) {
1379 0 : HCCL_WARNING("Failed to get real path for [%s], errno:%d", path.c_str(), errno);
1380 0 : return "";
1381 : }
1382 1568 : return std::string(resolvedPath);
1383 : }
1384 :
1385 784 : HcclResult GetVersionByPkgName(const std::string& targetPkgName, std::string& versionContent, bool isSilent)
1386 : {
1387 784 : const char* pathEnv = nullptr;
1388 784 : MM_SYS_GET_ENV(MM_ENV_ASCEND_HOME_PATH, pathEnv);
1389 784 : if (pathEnv == nullptr) {
1390 0 : HCCL_WARNING("Can not get env [%s]. Please check if ASCEND_HOME_PATH is set.", "ASCEND_HOME_PATH");
1391 0 : return HCCL_E_OPEN_FILE_FAILURE;
1392 : }
1393 784 : std::string homePath(pathEnv);
1394 784 : homePath = GetLocalRealPath(homePath);
1395 784 : if (homePath.empty()) {
1396 0 : HCCL_WARNING("ASCEND_HOME_PATH [%s] does not exist.", homePath.c_str());
1397 0 : return HCCL_E_OPEN_FILE_FAILURE;
1398 : }
1399 784 : const std::string fullPath = homePath + kRelPathInfo + targetPkgName + kInfoFileName;
1400 784 : return GetVersionStringInternal(fullPath, targetPkgName.c_str(), versionContent, isSilent);
1401 784 : }
1402 784 : HcclResult GetPkgVersionContent(const char* pkgName, std::string& versionContent)
1403 : {
1404 784 : const std::string originPkgName(pkgName);
1405 784 : std::string altPkgName = originPkgName;
1406 784 : bool hasAlternative = false;
1407 :
1408 784 : if (originPkgName.find('-') != std::string::npos) {
1409 0 : std::replace(altPkgName.begin(), altPkgName.end(), '-', '_');
1410 0 : hasAlternative = true;
1411 784 : } else if (originPkgName.find('_') != std::string::npos) {
1412 0 : std::replace(altPkgName.begin(), altPkgName.end(), '_', '-');
1413 0 : hasAlternative = true;
1414 : }
1415 784 : const bool isSilent = hasAlternative;
1416 784 : HcclResult ret = GetVersionByPkgName(originPkgName, versionContent, isSilent);
1417 784 : if (ret == HCCL_SUCCESS) {
1418 784 : return ret;
1419 : }
1420 0 : if (hasAlternative) {
1421 0 : HCCL_INFO("Pkg [%s] not found, trying alternative name [%s]...", originPkgName.c_str(), altPkgName.c_str());
1422 :
1423 0 : ret = GetVersionByPkgName(altPkgName, versionContent, false);
1424 0 : if (ret == HCCL_SUCCESS) {
1425 0 : HCCL_INFO("Found version info using alternative name [%s].", altPkgName.c_str());
1426 0 : return HCCL_SUCCESS;
1427 : }
1428 : }
1429 0 : return ret;
1430 784 : }
1431 :
1432 784 : HcclResult GetPkgVersionStr(char* pkgName, char* versionStr)
1433 : {
1434 784 : HCCL_INFO("start to execute GetPkgVersionStr.");
1435 784 : CHK_PTR_NULL(versionStr);
1436 784 : CHK_PTR_NULL(pkgName);
1437 784 : std::string verInfo;
1438 784 : const HcclResult ret = GetPkgVersionContent(pkgName, verInfo);
1439 784 : if (ret != HCCL_SUCCESS) {
1440 0 : return ret;
1441 : }
1442 784 : if (strcpy_s(versionStr, PKG_VERSION_MAX_SIZE, verInfo.c_str()) != EOK) {
1443 0 : HCCL_WARNING(
1444 : "Copy string failed. Dest buffer size is [%d], source len is [%lu].", PKG_VERSION_MAX_SIZE,
1445 : verInfo.length());
1446 0 : return HCCL_E_INTERNAL;
1447 : }
1448 784 : HCCL_INFO("GetPkgVersionStr success. Pkg:[%s], Ver:[%s]", pkgName, versionStr);
1449 784 : return ret;
1450 784 : }
1451 :
1452 : } // namespace
1453 : #endif
1454 :
1455 392 : HcclResult ParseCannVersion()
1456 : {
1457 : #if !defined(CCL_KERNEL_AICPU) && !defined(HCCD)
1458 392 : char hcommPkgName[] = "hcomm";
1459 392 : char hcclPkgName[] = "hccl";
1460 392 : constexpr u32 HCCL_VERSION_STR_MAX_LEN = 128;
1461 392 : std::vector<char> hcommVersion(HCCL_VERSION_STR_MAX_LEN, 0);
1462 392 : std::vector<char> hcclVersion(HCCL_VERSION_STR_MAX_LEN, 0);
1463 392 : HcclResult versionRet = GetPkgVersionStr(hcommPkgName, hcommVersion.data());
1464 392 : CHK_PRT_RET(
1465 : versionRet != HCCL_SUCCESS,
1466 : HCCL_WARNING("[Parse][CannVersion]failed to get hcomm version, ret[%d]", versionRet), HCCL_E_NOT_FOUND);
1467 392 : versionRet = GetPkgVersionStr(hcclPkgName, hcclVersion.data());
1468 392 : if (versionRet != HCCL_SUCCESS) {
1469 0 : HCCL_WARNING("[Parse][CannVersion]failed to get hccl version, ret[%d]", versionRet);
1470 0 : hcclVersion.assign(HCCL_VERSION_STR_MAX_LEN, 0);
1471 : }
1472 392 : const size_t hlen = strnlen(hcommVersion.data(), HCCL_VERSION_STR_MAX_LEN);
1473 392 : const size_t clen = strnlen(hcclVersion.data(), HCCL_VERSION_STR_MAX_LEN);
1474 392 : if (hlen == 0 || hlen == HCCL_VERSION_STR_MAX_LEN) {
1475 0 : HCCL_WARNING("[Parse][CannVersion]hcomm version is empty", std::string(hcommVersion.data(), hlen).c_str());
1476 0 : return HCCL_E_NOT_FOUND;
1477 : }
1478 392 : g_externalInput.cannVersion = std::string(hcommVersion.data());
1479 392 : if (clen != 0 && clen != HCCL_VERSION_STR_MAX_LEN) {
1480 392 : g_externalInput.cannVersion += "_" + std::string(hcclVersion.data());
1481 1960 : HCCL_RUN_INFO(
1482 : "[Parse][CannVersion]success, hcomm version is %s, hccl version is %s ",
1483 : std::string(hcommVersion.data()).c_str(), std::string(hcclVersion.data()).c_str());
1484 : } else {
1485 0 : HCCL_RUN_INFO(
1486 : "[Parse][CannVersion]success, hcomm version is %s, but hccl package not found.",
1487 : std::string(hcommVersion.data()).c_str());
1488 : }
1489 392 : return HcclResult::HCCL_SUCCESS;
1490 : #else
1491 : HCCL_WARNING("[ParseCannVersion]Does not support this interface.");
1492 : return HCCL_E_NOT_SUPPORT;
1493 : #endif
1494 392 : }
1495 :
1496 392 : HcclResult ParseCclBufferSize()
1497 : {
1498 392 : std::string hcclBufferSize = GET_ENV(MM_ENV_HCCL_BUFFSIZE);
1499 392 : u32 cclBufferSize = HCCL_CCL_COMM_DEFAULT_BUFFER_SIZE;
1500 392 : if (hcclBufferSize == "EmptyString") {
1501 386 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_BUFFSIZE set by default to [%u]M", cclBufferSize);
1502 386 : return HCCL_SUCCESS;
1503 : }
1504 :
1505 : // 校验环境变量长度
1506 6 : bool isEnvLenValid = CheckEnvLen(hcclBufferSize.c_str(), MAX_LEN_OF_DIGIT_ENV);
1507 :
1508 6 : CHK_PRT_RET(
1509 : !isEnvLenValid,
1510 : HCCL_ERROR(
1511 : "[Parse][CclBufferSize]errNo[0x%016llx] Invalid HCCL_BUFFSIZE env len, len is bigger than "
1512 : "[%u]. errorno[%d]",
1513 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
1514 : HCCL_E_PARA);
1515 :
1516 6 : u64 cclBufFixedCalcSize = HCCL_CCL_COMM_FIXED_CALC_BUFFER_SIZE;
1517 6 : CHK_RET(IsAllDigit(hcclBufferSize.c_str()));
1518 :
1519 6 : HcclResult ret = SalStrToULong(hcclBufferSize.c_str(), HCCL_BASE_DECIMAL, cclBufferSize);
1520 : // 若转换出错或者设置的CclBufferSize不在有效范围内，报错
1521 6 : CHK_PRT_RET(
1522 : (ret != HCCL_SUCCESS || cclBufferSize < HCCL_CCL_COMM_BUFFER_MIN),
1523 : HCCL_ERROR(
1524 : "[Parse][CclBufferSize]external input CclBufferSize[%uM] should be greater than %uM", cclBufferSize,
1525 : HCCL_CCL_COMM_BUFFER_MIN),
1526 : HCCL_E_PARA);
1527 6 : g_externalInput.cclBufferSize = static_cast<u64>(cclBufferSize * cclBufFixedCalcSize);
1528 6 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_BUFFSIZE set by environment to [%u]M", cclBufferSize);
1529 6 : return HCCL_SUCCESS;
1530 392 : }
1531 :
1532 606 : void SetIfProfile(bool ifProfile) { g_ifProf = ifProfile; }
1533 :
1534 850 : const bool& GetIfProfile() { return g_ifProf; }
1535 :
1536 9 : void SetProfConfig(u64 profConfig)
1537 : {
1538 9 : g_externalInput.profConfig = profConfig;
1539 9 : HCCL_INFO("[%s]Set profConfig[%x]", __func__, profConfig);
1540 9 : }
1541 :
1542 392 : HcclResult ParseTaskExceptionSwitch()
1543 : {
1544 : // task_exception_handler调测开关，默认关闭 (0)
1545 392 : std::string taskExceptionSwitchEnv = GET_ENV(MM_ENV_HCCL_DIAGNOSE_ENABLE);
1546 392 : if (taskExceptionSwitchEnv == "EmptyString") {
1547 392 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_DIAGNOSE_ENABLE set by default to [0]");
1548 392 : return HCCL_SUCCESS;
1549 : }
1550 0 : u32 taskExceptionSwitchConfig = 0;
1551 0 : bool isEnvLenValid = CheckEnvLen(taskExceptionSwitchEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
1552 0 : CHK_PRT_RET(
1553 : !isEnvLenValid,
1554 : HCCL_ERROR(
1555 : "[Parse][TaskExceptionSwitch]errNo[0x%016llx] Invalid"
1556 : " HCCL_DIAGNOSE_ENABLE env len, len is bigger than [%u]. errorno[%d]",
1557 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
1558 : HCCL_E_PARA);
1559 0 : CHK_RET(IsAllDigit(taskExceptionSwitchEnv.c_str()));
1560 0 : CHK_RET(SalStrToULong(taskExceptionSwitchEnv.c_str(), HCCL_BASE_DECIMAL, taskExceptionSwitchConfig));
1561 0 : if ((taskExceptionSwitchConfig != 0) && (taskExceptionSwitchConfig != 1)) {
1562 0 : HCCL_ERROR(
1563 : "[Get][TaskExceptionSwitch]environmental digit variable error, taskExceptionSwitchConfig[%u]",
1564 : taskExceptionSwitchConfig);
1565 0 : return HCCL_E_PARA;
1566 : }
1567 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_DIAGNOSE_ENABLE set by environment to [%u]", taskExceptionSwitchConfig);
1568 0 : g_externalInput.taskExceptionSwitch = taskExceptionSwitchConfig;
1569 0 : return HCCL_SUCCESS;
1570 392 : }
1571 :
1572 392 : HcclResult ParseRdmaQpsPerConnection()
1573 : {
1574 392 : g_externalInput.qpsPerConnection = HCCL_QPS_PER_CONNECTION_DEFAULT;
1575 392 : std::string rdmaQpsPerConnectionEnv = GET_ENV(MM_ENV_HCCL_RDMA_QPS_PER_CONNECTION);
1576 392 : if (rdmaQpsPerConnectionEnv == "EmptyString") {
1577 390 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_QPS_PER_CONNECTION is set to default value [1]");
1578 390 : return HCCL_SUCCESS;
1579 : }
1580 : // 校验环境变量长度
1581 2 : bool isEnvLenValid = CheckEnvLen(rdmaQpsPerConnectionEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
1582 2 : CHK_PRT_RET(
1583 : !isEnvLenValid,
1584 : HCCL_ERROR(
1585 : "[Parse][RdmaQpsPerConnectionEnv]errNo[0x%016llx] Invalid RdmaQpsPerConnectionEnv env len,"
1586 : "len is bigger than [%u]. errorno[%d]",
1587 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
1588 : HCCL_E_PARA);
1589 :
1590 2 : u32 qpsPerConnection = HCCL_QPS_PER_CONNECTION_DEFAULT;
1591 2 : CHK_RET(IsAllDigit(rdmaQpsPerConnectionEnv.c_str()));
1592 2 : HcclResult ret = SalStrToULong(rdmaQpsPerConnectionEnv, HCCL_BASE_DECIMAL, qpsPerConnection);
1593 2 : if (ret != HCCL_SUCCESS || (qpsPerConnection < HCCL_QPS_PER_CONNECTION_DEFAULT)
1594 2 : || (qpsPerConnection > HCCL_QPS_PER_CONNECTION_MAX)) {
1595 0 : HCCL_ERROR(
1596 : "[Parse][RdmaQpsPerConnectionEnv]environmental variable HCCL_RDMA_QPS_PER_CONNECTION error,"
1597 : "errNo[0x%016llx] qpsPerConnection[%s] Range[%u, %u] Recommended Range[1, 8]",
1598 : HCOM_ERROR_CODE(ret), rdmaQpsPerConnectionEnv.c_str(), HCCL_QPS_PER_CONNECTION_DEFAULT,
1599 : HCCL_QPS_PER_CONNECTION_MAX);
1600 0 : g_externalInput.qpsPerConnection = HCCL_QPS_PER_CONNECTION_DEFAULT;
1601 0 : return HCCL_E_PARA;
1602 : }
1603 2 : g_externalInput.qpsPerConnection = qpsPerConnection;
1604 2 : HCCL_RUN_INFO("[HCCL_ENV] environmental variable HCCL_RDMA_QPS_PER_CONNECTION is set to [%d]", qpsPerConnection);
1605 2 : return HCCL_SUCCESS;
1606 392 : }
1607 :
1608 392 : HcclResult ParseMultiQpThreshold()
1609 : {
1610 392 : g_externalInput.multiQpThreshold = HCCL_MULTI_QP_THRESHOLD_DEFAULT;
1611 392 : std::string strMultiQpThresholdEnv = GET_ENV(MM_ENV_HCCL_MULTI_QP_THRESHOLD);
1612 392 : if (strMultiQpThresholdEnv == "EmptyString") {
1613 392 : HCCL_RUN_INFO(
1614 : "[HCCL_ENV] HCCL_MULTI_QP_THRESHOLD is set to default value [%u]KB", HCCL_MULTI_QP_THRESHOLD_DEFAULT);
1615 392 : return HCCL_SUCCESS;
1616 : }
1617 : // 校验环境变量长度
1618 0 : bool isEnvLenValid = CheckEnvLen(strMultiQpThresholdEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
1619 0 : CHK_PRT_RET(
1620 : !isEnvLenValid,
1621 : HCCL_ERROR(
1622 : "[Parse][MultiQpThresholdEnv]errNo[0x%016llx] Invalid MultiQpThresholdEnv env len,"
1623 : "len is bigger than [%u]. errorno[%d]",
1624 : HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
1625 : HCCL_E_PARA);
1626 :
1627 0 : u32 multiQpThreshold = HCCL_MULTI_QP_THRESHOLD_DEFAULT;
1628 0 : CHK_RET(IsAllDigit(strMultiQpThresholdEnv.c_str()));
1629 0 : HcclResult ret = SalStrToULong(strMultiQpThresholdEnv, HCCL_BASE_DECIMAL, multiQpThreshold);
1630 0 : if (ret != HCCL_SUCCESS || multiQpThreshold == 0 || multiQpThreshold > HCCL_MULTI_QP_THRESHOLD_MAX) {
1631 0 : HCCL_ERROR(
1632 : "[Parse][MultiQpThresholdEnv]environmental variable HCCL_MULTI_QP_THRESHOLD error,"
1633 : "errNo[0x%016llx] multiQpThreshold[%s] Range[1, %u]",
1634 : HCOM_ERROR_CODE(ret), strMultiQpThresholdEnv.c_str(), HCCL_MULTI_QP_THRESHOLD_MAX);
1635 0 : g_externalInput.multiQpThreshold = HCCL_MULTI_QP_THRESHOLD_DEFAULT;
1636 0 : return HCCL_E_PARA;
1637 : }
1638 0 : g_externalInput.multiQpThreshold = multiQpThreshold;
1639 0 : HCCL_RUN_INFO("[HCCL_ENV] environmental variable HCCL_MULTI_QP_THRESHOLD is set to [%d]KB", multiQpThreshold);
1640 0 : return HCCL_SUCCESS;
1641 392 : }
1642 :
1643 392 : HcclResult ParseEntryLogEnable()
1644 : {
1645 392 : std::string enableEntryLogEnv = GET_ENV(MM_ENV_HCCL_ENTRY_LOG_ENABLE);
1646 392 : if (enableEntryLogEnv == "EmptyString") {
1647 392 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_ENTRY_LOG_ENABLE set by default to [0]");
1648 392 : return HCCL_SUCCESS;
1649 : }
1650 0 : if (enableEntryLogEnv != "0" && enableEntryLogEnv != "1") {
1651 0 : HCCL_ERROR(
1652 : "[Parser][EntryLogEnable]environmental variable HCCL_ENTRY_LOG_ENABLE [%s] is invalid, set by "
1653 : "default to [0]",
1654 : enableEntryLogEnv.c_str());
1655 0 : return HCCL_E_PARA;
1656 : }
1657 0 : g_externalInput.enableEntryLog = false;
1658 0 : if (enableEntryLogEnv == "1") {
1659 0 : g_externalInput.enableEntryLog = true;
1660 : }
1661 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_ENTRY_LOG_ENABLE set by environment to [%u]", g_externalInput.enableEntryLog);
1662 0 : return HCCL_SUCCESS;
1663 392 : }
1664 :
1665 392 : HcclResult ParseInterLinkType()
1666 : {
1667 392 : std::string interHccsDisableEnv = GET_ENV(MM_ENV_HCCL_INTER_HCCS_DISABLE);
1668 392 : if (interHccsDisableEnv == "EmptyString") {
1669 379 : HCCL_RUN_INFO(
1670 : "[HCCL_ENV] HCCL_INTER_HCCS_DISABLE is not set, default value is %s.",
1671 : g_externalInput.interHccsDisable ? "TRUE" : "FALSE");
1672 379 : return HCCL_SUCCESS;
1673 : }
1674 13 : std::transform(interHccsDisableEnv.begin(), interHccsDisableEnv.end(), interHccsDisableEnv.begin(), ::toupper);
1675 13 : if ("TRUE" == interHccsDisableEnv) {
1676 0 : g_externalInput.interHccsDisable = true;
1677 13 : } else if ("FALSE" == interHccsDisableEnv) {
1678 13 : g_externalInput.interHccsDisable = false;
1679 : } else {
1680 0 : HCCL_ERROR("HCCL_INTER_HCCS_DISABLE %s is invalid, expect true or false.", interHccsDisableEnv.c_str());
1681 0 : return HCCL_E_PARA;
1682 : }
1683 13 : HCCL_RUN_INFO(
1684 : "[HCCL_ENV] environmental variable HCCL_INTER_HCCS_DISABLE is set to [%s], interHccsDisable[%d]",
1685 : interHccsDisableEnv.c_str(), g_externalInput.interHccsDisable);
1686 13 : return HCCL_SUCCESS;
1687 392 : }
1688 :
1689 392 : HcclResult ParseOpExpansion()
1690 : {
1691 392 : std::string opExpansionModeEnv = GET_ENV(MM_ENV_HCCL_OP_EXPANSION_MODE);
1692 392 : g_externalInput.aicpuUnfold = false;
1693 392 : g_externalInput.aivMode = false;
1694 392 : g_externalInput.aicpuCacheEnable = 0; // aicpu模式不使能时, aicpu cache也不使能 (即使使能也不生效)
1695 392 : if (IsGeneralServer()) {
1696 0 : HCCL_RUN_INFO(
1697 : "[HCCL_ENV] HCCL_OP_EXPANSION_MODE is not set, aicpuUnfold is [%u], aivMode is [%u], aicpuCacheEnable is "
1698 : "[%u]",
1699 : g_externalInput.aicpuUnfold, g_externalInput.aivMode, g_externalInput.aicpuCacheEnable);
1700 0 : return HCCL_SUCCESS;
1701 : }
1702 :
1703 : #ifndef HCCD
1704 : DevType deviceType;
1705 392 : CHK_RET(hrtGetDeviceType(deviceType));
1706 : // 910_93默认打开AICPU展开
1707 392 : if (deviceType == DevType::DEV_TYPE_910_93) {
1708 3 : g_externalInput.aicpuUnfold = true;
1709 3 : g_externalInput.aicpuCacheEnable = 1; // aicpu cache默认使能
1710 : }
1711 392 : if (opExpansionModeEnv == "EmptyString") {
1712 387 : HCCL_RUN_INFO(
1713 : "[HCCL_ENV] HCCL_OP_EXPANSION_MODE is not set, aicpuUnfold is [%u], aivMode is [%u], aicpuCacheEnable is "
1714 : "[%u]",
1715 : g_externalInput.aicpuUnfold, g_externalInput.aivMode, g_externalInput.aicpuCacheEnable);
1716 387 : return HCCL_SUCCESS;
1717 : }
1718 5 : if (opExpansionModeEnv == "AI_CPU") {
1719 5 : if (deviceType == DevType::DEV_TYPE_910) {
1720 0 : HCCL_WARNING("910 do not support AICPU unfold.");
1721 : } else {
1722 5 : g_externalInput.aicpuUnfold = true;
1723 5 : g_externalInput.aicpuCacheEnable = 1; // aicpu cache默认使能
1724 : }
1725 0 : } else if (opExpansionModeEnv == "AICPU_CacheDisable") {
1726 0 : if (deviceType == DevType::DEV_TYPE_910) {
1727 0 : HCCL_WARNING("910 do not support AICPU unfold.");
1728 : } else {
1729 0 : g_externalInput.aicpuUnfold = true;
1730 0 : g_externalInput.aicpuCacheEnable = 0; // Disable aicpu cache
1731 : }
1732 0 : } else if (opExpansionModeEnv == "AIV") {
1733 0 : g_externalInput.aivMode = true;
1734 0 : } else if (opExpansionModeEnv == "HOST") {
1735 0 : g_externalInput.aivMode = false;
1736 0 : g_externalInput.aicpuUnfold = false;
1737 0 : g_externalInput.aicpuCacheEnable = 0;
1738 0 : } else if (opExpansionModeEnv == "HOST_TS") {
1739 0 : if (deviceType == DevType::DEV_TYPE_910B) {
1740 0 : g_externalInput.enableFfts = false;
1741 : } else {
1742 0 : HCCL_WARNING("deviceType[%u] do not support HOST_TS", deviceType);
1743 : }
1744 : } else {
1745 0 : HCCL_ERROR(
1746 : "HCCL_OP_EXPANSION_MODE is set to [%s], which is incorrect. Please check", opExpansionModeEnv.c_str());
1747 0 : return HCCL_E_PARA;
1748 : }
1749 : #endif
1750 5 : HCCL_RUN_INFO(
1751 : "[HCCL_ENV] environmental variable HCCL_OP_EXPANSION_MODE is [%s], aicpuUnfold[%u], aivMode[%u], "
1752 : "enableFfts[%u], aicpuCacheEnable[%u]",
1753 : opExpansionModeEnv.c_str(), g_externalInput.aicpuUnfold, g_externalInput.aivMode, g_externalInput.enableFfts,
1754 : g_externalInput.aicpuCacheEnable);
1755 5 : return HCCL_SUCCESS;
1756 392 : }
1757 :
1758 60 : HcclResult SplitHcclRetryEnable(
1759 : [[maybe_unused]] const std::string& retryConfig, [[maybe_unused]] std::vector<std::string>& retryEnables)
1760 : {
1761 : #ifndef CCL_KERNEL_AICPU
1762 60 : std::string remainRetryConfig;
1763 60 : std::size_t found = retryConfig.find(",");
1764 60 : if ((found == 0) || (found == (retryConfig.length() - 1))) {
1765 0 : HCCL_ERROR("[SplitHcclRetryEnable] algo config is invalid.");
1766 0 : return HCCL_E_PARA;
1767 60 : } else if (found != std::string::npos) {
1768 40 : remainRetryConfig = retryConfig.substr(found + 1);
1769 : } else {
1770 : // 最后一组配置,剩余的字符串为空
1771 : }
1772 60 : retryEnables.push_back(retryConfig.substr(0, found));
1773 :
1774 60 : if (retryEnables.size() > HCCL_RETRY_ENABLE_LEVEL_NUM) {
1775 0 : HCCL_ERROR(
1776 : "[SplitHcclRetryEnable] retryEnable config is invalid. retryEnable level is more than %u.",
1777 : HCCL_RETRY_ENABLE_LEVEL_NUM);
1778 0 : return HCCL_E_PARA;
1779 : }
1780 60 : if (!remainRetryConfig.empty()) {
1781 40 : CHK_RET(SplitHcclRetryEnable(remainRetryConfig, retryEnables));
1782 : }
1783 : #endif
1784 60 : return HCCL_SUCCESS;
1785 60 : }
1786 :
1787 20 : HcclResult CollectRetryEnableFromConfig([[maybe_unused]] const std::vector<std::string>& retryEnables)
1788 : {
1789 : #ifndef CCL_KERNEL_AICPU
1790 : const std::map<std::string, u32> hcclRetryLevelMap
1791 100 : = {{"L0", HCCL_RETRY_ENABLE_LEVEL_0}, {"L1", HCCL_RETRY_ENABLE_LEVEL_1}, {"L2", HCCL_RETRY_ENABLE_LEVEL_2}};
1792 :
1793 100 : std::map<std::string, u32> countHcclRetryLevelMap = {{"L0", 0}, {"L1", 0}, {"L2", 0}};
1794 :
1795 80 : const std::map<std::string, bool> hcclRetryEnableMap = {{"0", false}, {"1", true}};
1796 80 : for (auto retryEnableLevel : retryEnables) {
1797 60 : u32 level = 0;
1798 60 : bool retryEnable = false;
1799 60 : std::size_t found = retryEnableLevel.find(":");
1800 60 : if ((found == 0) || (found == (retryEnableLevel.length() - 1))) {
1801 0 : HCCL_ERROR("[CollectRetryEnableFromConfig] Hccl retryEnableLevel is invalid.");
1802 0 : return HCCL_E_PARA;
1803 : }
1804 60 : std::string orginalLevel = retryEnableLevel.substr(0, found);
1805 60 : std::string orginalRetryEnable = retryEnableLevel.substr(found + 1);
1806 60 : if (orginalLevel == "L0") {
1807 20 : HCCL_RUN_WARNING("[CollectRetryEnableFromConfig] L0 config does not take effect");
1808 : }
1809 : // 检查是否存在重复配置level
1810 60 : auto iterCountRetryLevel = countHcclRetryLevelMap.find(orginalLevel);
1811 60 : if (iterCountRetryLevel == countHcclRetryLevelMap.end()) {
1812 0 : HCCL_ERROR(
1813 : "[CollectRetryEnableFromConfig] Retry config is invalid, level %s is not supported.",
1814 : orginalLevel.c_str());
1815 0 : return HCCL_E_PARA;
1816 : }
1817 60 : if (countHcclRetryLevelMap[orginalLevel] == 1) {
1818 0 : HCCL_ERROR(
1819 : "[CollectRetryEnableFromConfig] Retry config level[%s] is repeated, expect: L1:0, L2:0",
1820 : orginalLevel.c_str());
1821 0 : return HCCL_E_PARA;
1822 : }
1823 60 : countHcclRetryLevelMap[orginalLevel] += 1;
1824 : // 获取level和对应的retryEnable，并赋值给g_externalInput.hcclRetryConfig
1825 60 : auto iterRetryLevel = hcclRetryLevelMap.find(orginalLevel);
1826 60 : if (iterRetryLevel == hcclRetryLevelMap.end()) {
1827 0 : HCCL_ERROR(
1828 : "[CollectRetryEnableFromConfig] Retry config is invalid, level %s is not supported.",
1829 : orginalLevel.c_str());
1830 0 : return HCCL_E_PARA;
1831 : }
1832 60 : auto iterRetryEnable = hcclRetryEnableMap.find(orginalRetryEnable);
1833 60 : if (iterRetryEnable == hcclRetryEnableMap.end()) {
1834 0 : HCCL_ERROR(
1835 : "[CollectRetryEnableFromConfig] Retry config is invalid, retryEnable %s is not supported.",
1836 : orginalRetryEnable.c_str());
1837 0 : return HCCL_E_PARA;
1838 : }
1839 60 : level = iterRetryLevel->second;
1840 60 : retryEnable = iterRetryEnable->second;
1841 60 : g_externalInput.hcclRetryConfig[level] = retryEnable;
1842 60 : }
1843 : #endif
1844 20 : return HCCL_SUCCESS;
1845 100 : }
1846 :
1847 392 : HcclResult ParseRetryEnable()
1848 : {
1849 : #ifndef CCL_KERNEL_AICPU
1850 : // 默认都设置成false
1851 1568 : for (u32 level = 0; level < HCCL_RETRY_ENABLE_LEVEL_NUM; ++level) {
1852 1176 : g_externalInput.hcclRetryConfig[level] = false;
1853 : }
1854 392 : std::string hcclRetryEnable = GET_ENV(MM_ENV_HCCL_OP_RETRY_ENABLE);
1855 392 : if (hcclRetryEnable == "EmptyString") {
1856 372 : HCCL_RUN_INFO("[HCCL_ENV][ParseRetryEnable] HCCL_OP_RETRY_ENABLE is not set. The retryEnable of all levels is "
1857 : "set to false.");
1858 372 : return HCCL_SUCCESS;
1859 : }
1860 : // 去除空格
1861 20 : std::string retryConfig = hcclRetryEnable;
1862 20 : retryConfig.erase(std::remove(retryConfig.begin(), retryConfig.end(), ' '), retryConfig.end());
1863 :
1864 20 : if (retryConfig.empty()) {
1865 0 : HCCL_RUN_INFO(
1866 : "[HCCL_ENV][ParseRetryEnable] Hccl retry config is empty. The retryEnable of all levels is set to false.");
1867 0 : return HCCL_SUCCESS;
1868 : }
1869 :
1870 20 : std::vector<std::string> retryEnables;
1871 20 : HcclResult ret = SplitHcclRetryEnable(retryConfig, retryEnables);
1872 20 : CHK_PRT_RET(
1873 : ret != HCCL_SUCCESS,
1874 : HCCL_ERROR(
1875 : "[CollectRetryEnableFromConfig] Hccl retry config[%s] is invalid. "
1876 : "expect: L1:0, L2:0",
1877 : retryConfig.c_str()),
1878 : ret);
1879 :
1880 20 : CHK_RET(CollectRetryEnableFromConfig(retryEnables));
1881 20 : HCCL_RUN_INFO(
1882 : "[HCCL_ENV][ParseRetryEnable] HCCL_OP_RETRY_ENABLE set by environment variable to [%s].", retryConfig.c_str());
1883 : #endif
1884 20 : return HCCL_SUCCESS;
1885 392 : }
1886 :
1887 392 : HcclResult ParseRetryParams()
1888 : {
1889 : #ifndef CCL_KERNEL_AICPU
1890 392 : std::string retryParams = GET_ENV(MM_ENV_HCCL_OP_RETRY_PARAMS);
1891 392 : if (retryParams == "EmptyString") {
1892 392 : HCCL_RUN_INFO(
1893 : "[HCCL_ENV] HCCL_OP_RETRY_PARAMS is not set, default value MaxCnt is [%u], HoldTime is [%u]ms, "
1894 : "IntervalTime is [%u]ms",
1895 : HCCL_RETRY_MAXCNT_DEFAULT, HCCL_RETRY_HOLD_TIME_DEFAULT, HCCL_RETRY_INTERVAL_DEFAULT);
1896 392 : return HCCL_SUCCESS;
1897 : }
1898 0 : u32 maxcnt = 0;
1899 0 : u32 holdtime = 0;
1900 0 : u32 intervaltime = 0;
1901 0 : int ret = 0;
1902 0 : ret = sscanf_s(retryParams.c_str(), "MaxCnt:%u, HoldTime:%u, IntervalTime:%u", &maxcnt, &holdtime, &intervaltime);
1903 : /* 三个参数全部解析成功，返回值为3，否则不等于3 */
1904 0 : if ((ret != 3) || (maxcnt > HCCL_RETRY_MAXCNT_MAX) || (maxcnt < HCCL_RETRY_MAXCNT_MIN)
1905 0 : || (holdtime > HCCL_RETRY_HLOD_TIME_MAX) || (intervaltime > HCCL_RETRY_INTERVAL_MAX)) {
1906 0 : HCCL_ERROR(
1907 : "[Parse][RetryParams]fail, HCCL_OP_RETRY_PARAMS: %s is invalid, format must be: "
1908 : "MaxCnt:cnt,HoldTime:time,IntervalTime:time, cnt range is [1, 10], time range is [0, 60000]ms.",
1909 : retryParams.c_str());
1910 0 : return HCCL_E_PARA;
1911 : }
1912 0 : g_externalInput.retryMaxCnt = maxcnt;
1913 0 : g_externalInput.retryHoldTime = holdtime;
1914 0 : g_externalInput.retryIntervalTime = intervaltime;
1915 :
1916 0 : HCCL_RUN_INFO(
1917 : "[HCCL_ENV] HCCL_OP_RETRY_PARAMS is set, MaxCnt is [%u], HoldTime is [%u]ms, IntervalTime is [%u]ms.", maxcnt,
1918 : holdtime, intervaltime);
1919 : #endif
1920 0 : return HCCL_SUCCESS;
1921 392 : }
1922 :
1923 392 : HcclResult ParseLogicSuperPodId()
1924 : {
1925 392 : std::string logicSuperPodId = GET_ENV(MM_ENV_HCCL_LOGIC_SUPERPOD_ID);
1926 392 : if (logicSuperPodId == "EmptyString") {
1927 392 : HCCL_RUN_INFO(
1928 : "[HCCL_ENV] HCCL_LOGIC_SUPERPOD_ID is not set, default value[%s]", g_externalInput.logicSuperPodId.c_str());
1929 392 : return HCCL_SUCCESS;
1930 : }
1931 :
1932 : // 校验环境变量长度
1933 0 : bool isEnvLenValid = CheckEnvLen(logicSuperPodId.c_str(), MAX_LEN_OF_LOGIC_SUPER_ID);
1934 0 : CHK_PRT_RET(
1935 : !isEnvLenValid,
1936 : HCCL_ERROR(
1937 : "[Parse][LogicSuperPodId]Invalid HCCL_LOGIC_SUPERPOD_ID env len, len is bigger than [%u].",
1938 : MAX_LEN_OF_LOGIC_SUPER_ID),
1939 : HCCL_E_PARA);
1940 :
1941 0 : g_externalInput.logicSuperPodId = logicSuperPodId;
1942 0 : HCCL_RUN_INFO(
1943 : "[HCCL_ENV] HCCL_LOGIC_SUPERPOD_ID set by environment to [%s]", g_externalInput.logicSuperPodId.c_str());
1944 0 : return HCCL_SUCCESS;
1945 392 : }
1946 :
1947 0 : HcclResult SetIncreSaveExecTimeOut(const s32 execTimeout)
1948 : {
1949 0 : if (execTimeout == -1) {
1950 0 : g_externalInput.increSaveExecTimeOut = execTimeout;
1951 : } else {
1952 0 : g_externalInput.increSaveExecTimeOut = g_externalInput.execTimeOut;
1953 : }
1954 :
1955 0 : HCCL_RUN_INFO(
1956 : "setIncreSaveExecTimeOut execTimeout[%d s] increSaveExecTimeOut[%d s]", execTimeout,
1957 : g_externalInput.increSaveExecTimeOut);
1958 0 : return HCCL_SUCCESS;
1959 : }
1960 :
1961 392 : HcclResult ParseDebugConfig()
1962 : {
1963 392 : char* env = nullptr; // 环境变量值
1964 392 : MM_SYS_GET_ENV(MM_ENV_HCCL_DEBUG_CONFIG, env);
1965 392 : if (env == nullptr) {
1966 133 : HCCL_RUN_INFO(
1967 : "[HCCL_ENV] HCCL_DEBUG_CONFIG is not set, debugConfig set by default to 0x%llx",
1968 : g_externalInput.debugConfig);
1969 133 : return HCCL_SUCCESS;
1970 : }
1971 :
1972 259 : bool invert = (env[0] == '^');
1973 : g_externalInput.debugConfig
1974 259 : = invert ? ~0ULL : 0ULL; // 第一个字符是'^', 使用取反模式，用户配置的项关闭，未配置的项打开
1975 259 : char* configValue = (env[0] == '^') ? env + 1 : env; // 去掉'^'符号
1976 259 : char* configDup = strdup(configValue); // 需要使用strdup避免修改字符串常量
1977 259 : CHK_PTR_NULL(configDup);
1978 :
1979 259 : char* left = nullptr;
1980 259 : char* subConfig = strtok_r(configDup, ",", &left); // 按逗号分割
1981 518 : while (subConfig != nullptr) {
1982 259 : u64 mask = 0;
1983 259 : if (strcasecmp(subConfig, "ALG") == 0) {
1984 239 : mask = PLF_ALG;
1985 20 : } else if (strcasecmp(subConfig, "TASK") == 0) {
1986 0 : mask = PLF_TASK;
1987 20 : } else if (strcasecmp(subConfig, "RESOURCE") == 0) {
1988 0 : mask = PLF_RES;
1989 20 : } else if (strcasecmp(subConfig, "AIV_OPS_EXC") == 0) {
1990 20 : HCCL_WARNING("HCCL_DEBUG_CONFIG:%s subConfig:%s is deprecated and ignored", env, subConfig);
1991 : } else {
1992 0 : HCCL_ERROR("HCCL_DEBUG_CONFIG:%s is invalid, subConfig:%s is not supported", env, subConfig);
1993 0 : free(configDup);
1994 0 : return HCCL_E_PARA;
1995 : }
1996 : g_externalInput.debugConfig
1997 259 : = invert ? (g_externalInput.debugConfig & (~mask)) : (g_externalInput.debugConfig | mask);
1998 259 : subConfig = strtok_r(nullptr, ",", &left);
1999 : }
2000 259 : free(configDup);
2001 259 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_DEBUG_CONFIG[%s], set debugConfig[0x%llx]", env, g_externalInput.debugConfig);
2002 259 : return HCCL_SUCCESS;
2003 : }
2004 :
2005 19 : const u32& GetExternalInputHcclIfBasePort() { return g_externalInput.hcclIfBasePort; }
2006 :
2007 0 : const u32& GetExternalInputRdmaTrafficClass() { return g_externalInput.rdmaTrafficClass; }
2008 :
2009 0 : const u32& GetExternalInputRdmaServerLevel() { return g_externalInput.rdmaServerLevel; }
2010 :
2011 7 : const u32& GetExternalInputRdmaTimeOut() { return g_externalInput.rdmaTimeOut; }
2012 :
2013 4 : const u32& GetExternalInputRdmaRetryCnt() { return g_externalInput.rdmaRetryCnt; }
2014 :
2015 96 : const u32& GetExternalInputTaskExceptionSwitch() { return g_externalInput.taskExceptionSwitch; }
2016 :
2017 891 : const u32& GetExternalInputIntraRoceSwitch() { return g_externalInput.intraRoceSwitch; }
2018 :
2019 296 : const u32& GetExternalInputHcclEnableWhitelist() { return g_externalInput.enableWhitelist; }
2020 :
2021 9 : const std::string& GetExternalInputHcclWhiteListFile() { return g_externalInput.hcclWhiteListFile; }
2022 :
2023 0 : const std::string& GetExternalInputProfilingOption() { return g_externalInput.profilingOption; }
2024 :
2025 236 : const std::string& GetExternalInputCannVersion() { return g_externalInput.cannVersion; }
2026 :
2027 3892 : const double& GetExternalInputHcclExecTimeOut() { return g_externalInput.execTimeOut; }
2028 :
2029 341 : const s32& GetExternalInputHcclLinkTimeOut() { return g_externalInput.linkTimeOut; }
2030 :
2031 13 : const s32& GetExternalInputHcclSocketFamily() { return g_externalInput.hcclSocketFamily; }
2032 :
2033 491 : const bool& GetExternalInputProfilingMode() { return g_externalInput.profilingMode; }
2034 :
2035 1288 : const bool& GetExternalInputHcclIsTcpMode() { return g_externalInput.isTcpMode; }
2036 :
2037 706 : const bool& GetExternalInputHcclDumpDebug() { return g_externalInput.dumpDebug; }
2038 :
2039 2226 : const bool& GetExternalInputHcclEnableFfts() { return g_externalInput.enableFfts; }
2040 :
2041 3788 : const u8& GetExternalInputHcclDeterministicV2() { return g_externalInput.hcclDeterministic; }
2042 :
2043 0 : const bool& GetExternalInputHcclDeterministic()
2044 : {
2045 0 : g_externalInput.isDeterministic = g_externalInput.hcclDeterministic == DETERMINISTIC_ENABLE;
2046 0 : return g_externalInput.isDeterministic;
2047 : }
2048 :
2049 150 : const bool& GetExternalInputHcclEnablePipline() { return g_externalInput.enablePipline; }
2050 :
2051 29 : const bool& GetExternalInputHcclEnableEntryLog() { return g_externalInput.enableEntryLog; }
2052 :
2053 462 : const bool& GetExternalInputInterHccsDisable() { return g_externalInput.interHccsDisable; }
2054 :
2055 2761 : const u64& GetExternalInputCCLBuffSize() { return g_externalInput.cclBufferSize; }
2056 :
2057 611 : const HcclExecTimeoutSet& GetExternalInputHcclExecTimeoutSet() { return g_externalInput.execTimeOutSet; }
2058 :
2059 16 : const hccl::HcclIpAddress& GetExternalInputHcclControlIfIp() { return g_externalInput.hcclControlIfIp; }
2060 :
2061 21 : const HcclSocketIfName& GetExternalInputHcclSocketIfName() { return g_externalInput.hcclSocketIfName; }
2062 :
2063 0 : u32 GetExternalInputQpsPerConnection() { return g_externalInput.qpsPerConnection; }
2064 :
2065 0 : u32 GetExternalInputMultiQpThreshold() { return g_externalInput.multiQpThreshold; }
2066 :
2067 1494 : const ProtocolType& GetExternalInputProtocolType() { return g_externalInput.protocolType; }
2068 :
2069 13 : const MasterInfo& GetExternalInputMasterInfo() { return g_externalInput.masterInfo; }
2070 :
2071 3266 : const bool& GetExternalInputHcclAicpuUnfold() { return g_externalInput.aicpuUnfold; }
2072 :
2073 176 : const uint8_t& GetExternalInputAicpuCacheEnable() { return g_externalInput.aicpuCacheEnable; }
2074 :
2075 3324 : const bool& GetExternalInputHcclAivMode() { return g_externalInput.aivMode; }
2076 :
2077 228 : const bool& GetRemoteIsHdc() { return g_externalInput.remoteIsHdc; }
2078 :
2079 2739 : const bool& GetExternalInputIntraServerRetryEnable()
2080 : {
2081 2739 : return g_externalInput.hcclRetryConfig[HCCL_RETRY_ENABLE_LEVEL_0];
2082 : }
2083 :
2084 2739 : const bool& GetExternalInputInterServerRetryEnable()
2085 : {
2086 2739 : return g_externalInput.hcclRetryConfig[HCCL_RETRY_ENABLE_LEVEL_1];
2087 : }
2088 :
2089 2930 : const bool& GetExternalInputInterSuperPodRetryEnable()
2090 : {
2091 2930 : return g_externalInput.hcclRetryConfig[HCCL_RETRY_ENABLE_LEVEL_2];
2092 : }
2093 :
2094 0 : const bool& GetExternalInputOpCounter() { return g_externalInput.opCounterEnable; }
2095 :
2096 2739 : const u32& GetExternalInputRetryMaxCnt() { return g_externalInput.retryMaxCnt; }
2097 :
2098 2745 : const u32& GetExternalInputRetryHoldTime() { return g_externalInput.retryHoldTime; }
2099 :
2100 2744 : const u32& GetExternalInputRetryIntervalTime() { return g_externalInput.retryIntervalTime; }
2101 :
2102 2 : const std::string& GetExternalInputLogicSuperPodId() { return g_externalInput.logicSuperPodId; }
2103 :
2104 34 : const bool& GetExternalInputRdmaFastPost() { return g_externalInput.rdmaFastPost; }
2105 :
2106 0 : const std::string& GetExternalInputQpSrcPortConfigPath() { return g_externalInput.multiQpSrcPortConfigPath; }
2107 :
2108 0 : const s32& GetIncreSaveExecTimeOut() { return g_externalInput.increSaveExecTimeOut; }
2109 :
2110 0 : const u64& GetProfConfig() { return g_externalInput.profConfig; }
2111 :
2112 17217 : const u64& GetExternalInputDebugConfig() { return g_externalInput.debugConfig; }
2113 :
2114 11 : void SetExternalInputDebugConfig(u64 value) { g_externalInput.debugConfig = value; }
|
