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