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 "env_config.h"
12 : #include <algorithm>
13 : #include <mutex>
14 : #include <sstream>
15 : #include <string>
16 : #include "adapter_error_manager_pub.h"
17 : #include "log.h"
18 : #include "sal_pub.h"
19 : #include "mmpa_api.h"
20 : #include "config_log.h"
21 : #include "adapter_rts_common.h"
22 :
23 : using namespace hccl;
24 :
25 : static std::mutex g_envConfigMutex;
26 :
27 : constexpr char ENV_EMPTY_STRING[] = "EmptyString";
28 :
29 : constexpr char HCCL_AUTO_PORT_CONFIG[] = "auto"; // 端口范围配置为auto时，由OS分配浮动监听端口
30 : constexpr u32 MAX_PORT_NUMBER = 65535; // 合法端口号的上限
31 : constexpr u32 HCCL_SOCKET_PORT_RANGE_AUTO = 0; // 需要保留的
32 : const std::string CLUSTER_HEART_CONFIG = "cluster_heartbeat:";
33 : const std::string STUCK_DETECTION_CONFIG = "stuck_detection:";
34 : const std::string INCONSISTENT_CHECK_CONFIG = "inconsistent_check:";
35 : const std::string CONNECTION_FAULT_DETECTION_TIME = "connection_fault_detection_time:";
36 : const std::string TASK_MONITOR_INTERVAL = "task_monitor_interval:";
37 : constexpr static const s32 HCCL_MAX_LINK_TIME_OUT_S = (120 * 60); // HCCL 最大探测超时时间设置为120*60s
38 257 : HcclResult InitEnvConfig()
39 : {
40 257 : std::lock_guard<std::mutex> lock(g_envConfigMutex);
41 257 : if (g_envConfig.initialized) {
42 252 : return HCCL_SUCCESS;
43 : }
44 : // 初始化环境变量
45 5 : CHK_RET(InitEnvParam());
46 :
47 5 : g_envConfig.initialized = true;
48 :
49 5 : return HCCL_SUCCESS;
50 257 : }
51 :
52 49 : bool GetExternalInputHostPortSwitch()
53 : {
54 49 : std::lock_guard<std::mutex> lock(g_envConfigMutex);
55 49 : return g_envConfig.hostSocketPortSwitch;
56 49 : }
57 :
58 498 : bool GetExternalInputNpuPortSwitch()
59 : {
60 498 : std::lock_guard<std::mutex> lock(g_envConfigMutex);
61 498 : return g_envConfig.npuSocketPortSwitch;
62 498 : }
63 :
64 234 : const u32& EnvConfig::GetExternalInputRdmaTrafficClass()
65 : {
66 234 : return g_envConfig.rdmaTrafficClass;
67 : }
68 :
69 234 : const u32& EnvConfig::GetExternalInputRdmaServerLevel()
70 : {
71 234 : return g_envConfig.rdmaServerLevel;
72 : }
73 :
74 0 : const u32& EnvConfig::GetExternalInputRdmaTimeOut()
75 : {
76 0 : return g_envConfig.rdmaTimeOut;
77 : }
78 :
79 0 : const u32& EnvConfig::GetExternalInputRdmaRetryCnt()
80 : {
81 0 : return g_envConfig.rdmaRetryCnt;
82 : }
83 :
84 1 : const std::vector<HcclSocketPortRange> &GetExternalInputHostSocketPortRange()
85 : {
86 1 : std::lock_guard<std::mutex> lock(g_envConfigMutex);
87 1 : return g_envConfig.hostSocketPortRange;
88 1 : }
89 :
90 0 : const std::vector<HcclSocketPortRange> &GetExternalInputNpuSocketPortRange()
91 : {
92 0 : std::lock_guard<std::mutex> lock(g_envConfigMutex);
93 0 : return g_envConfig.npuSocketPortRange;
94 0 : }
95 :
96 38 : s32& GetExternalInputDfsConnectionFaultDetectionTime()
97 : {
98 38 : return g_envConfig.dfsConnectionFaultDetectionTime;
99 : }
100 :
101 0 : u32& GetExternalInputDfsTaskMonitorInterval()
102 : {
103 0 : return g_envConfig.dfsTaskMonitorInterval;
104 : }
105 :
106 0 : HcclResult ResetEnvConfigInitState()
107 : {
108 0 : g_envConfig.SetDefaultParams();
109 0 : return HCCL_SUCCESS;
110 : }
111 :
112 52 : HcclResult InitEnvParam()
113 : {
114 52 : HcclResult ret = ParseHostSocketPortRange();
115 52 : char* mmSysGetHostEnvValue = nullptr;
116 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_HOST_SOCKET_PORT_RANGE, mmSysGetHostEnvValue);
117 52 : std::string hostSocketPortRangeEnv = (mmSysGetHostEnvValue != nullptr) ? mmSysGetHostEnvValue : "EmptyString";
118 52 : RPT_ENV_ERR(ret != HCCL_SUCCESS,
119 : "EI0001",
120 : std::vector<std::string>({"value", "env", "expect"}),
121 : std::vector<std::string>({hostSocketPortRangeEnv, "HCCL_HOST_SOCKET_PORT_RANGE",
122 : "a valid port range in the format of port1-port2, where port1 and port2 are valid port numbers (0-65535)"}));
123 52 : CHK_PRT_RET(ret != HCCL_SUCCESS,
124 : HCCL_ERROR("[%s][%s]errNo[0x%016llx] In init environment param, parse "
125 : "HCCL_HOST_SOCKET_PORT_RANGE failed. errorno[%d]",
126 : LOG_KEYWORDS_INIT_GROUP.c_str(),
127 : LOG_KEYWORDS_ENV_CONFIG.c_str(),
128 : HCCL_ERROR_CODE(ret),
129 : ret),
130 : ret);
131 :
132 52 : ret = ParseNpuSocketPortRange();
133 52 : char* mmSysGetNpuEnvValue = nullptr;
134 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_NPU_SOCKET_PORT_RANGE, mmSysGetNpuEnvValue);
135 52 : std::string npuSocketPortRangeEnv = (mmSysGetNpuEnvValue != nullptr) ? mmSysGetNpuEnvValue : "EmptyString";
136 52 : RPT_ENV_ERR(ret != HCCL_SUCCESS,
137 : "EI0001",
138 : std::vector<std::string>({"value", "env", "expect"}),
139 : std::vector<std::string>({npuSocketPortRangeEnv, "HCCL_NPU_SOCKET_PORT_RANGE",
140 : "a valid port range in the format of port1-port2, where port1 and port2 are valid port numbers (0-65535)"}));
141 52 : CHK_PRT_RET(ret != HCCL_SUCCESS,
142 : HCCL_ERROR("[%s][%s]errNo[0x%016llx] In init environment param, parse "
143 : "HCCL_NPU_SOCKET_PORT_RANGE failed. errorno[%d]",
144 : LOG_KEYWORDS_INIT_GROUP.c_str(),
145 : LOG_KEYWORDS_ENV_CONFIG.c_str(),
146 : HCCL_ERROR_CODE(ret),
147 : ret),
148 : ret);
149 :
150 52 : ret = ParseDFSConfig();
151 52 : char* dfsConfigValue = nullptr;
152 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_DFS_CONFIG, dfsConfigValue);
153 52 : std::string dfsConfigEnv = (dfsConfigValue != nullptr) ? dfsConfigValue : "EmptyString";
154 52 : RPT_ENV_ERR(ret != HCCL_SUCCESS,
155 : "EI0001",
156 : std::vector<std::string>({"value", "env", "expect"}),
157 : std::vector<std::string>({dfsConfigEnv, "HCCL_DFS_CONFIG", "comma-separated key-value pairs (e.g., cluter_heartbeat=on,stuck_detection=off)"}));
158 52 : CHK_PRT_RET(ret != HCCL_SUCCESS,
159 : HCCL_ERROR("[%s][%s]errNo[0x%016llx] In init environment param, parse "
160 : "HCCL_DFS_CONFIG failed. errorno[%d]",
161 : LOG_KEYWORDS_INIT_GROUP.c_str(),
162 : LOG_KEYWORDS_ENV_CONFIG.c_str(),
163 : HCCL_ERROR_CODE(ret),
164 : ret),
165 : ret);
166 :
167 52 : ret = g_envConfig.ParseRDMATrafficClass();
168 52 : char* mmSysGetTrafficClassEnvValue = nullptr;
169 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_RDMA_TC, mmSysGetTrafficClassEnvValue);
170 52 : std::string mmSysGetTrafficClassEnv = (mmSysGetTrafficClassEnvValue != nullptr) ? mmSysGetTrafficClassEnvValue : "EmptyString";
171 52 : RPT_ENV_ERR(ret != HCCL_SUCCESS,
172 : "EI0001",
173 : std::vector<std::string>({"value", "env", "expect"}),
174 : std::vector<std::string>({mmSysGetTrafficClassEnv, "HCCL_RDMA_TC", "range[0, 255], Must be a multiple of 4"}));
175 52 : CHK_PRT_RET(ret != HCCL_SUCCESS,
176 : HCCL_ERROR("[%s][%s]errNo[0x%016llx] In init environment param, parse "
177 : "HCCL_RDMA_TC failed. 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 52 : ret = g_envConfig.ParseRDMAServerLevel();
185 52 : char* mmSysGetServerLevelEnvValue = nullptr;
186 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_RDMA_SL, mmSysGetServerLevelEnvValue);
187 52 : std::string mmSysGetServerLevel = (mmSysGetServerLevelEnvValue != nullptr) ? mmSysGetServerLevelEnvValue : "EmptyString";
188 52 : RPT_ENV_ERR(ret != HCCL_SUCCESS,
189 : "EI0001",
190 : std::vector<std::string>({"value", "env", "expect"}),
191 : std::vector<std::string>({mmSysGetServerLevel, "HCCL_RDMA_SL", "Value range[0, 7]"}));
192 52 : CHK_PRT_RET(ret != HCCL_SUCCESS,
193 : HCCL_ERROR("[%s][%s]errNo[0x%016llx] In init environment param, parse "
194 : "HCCL_RDMA_SL failed. errorno[%d]",
195 : LOG_KEYWORDS_INIT_GROUP.c_str(),
196 : LOG_KEYWORDS_ENV_CONFIG.c_str(),
197 : HCCL_ERROR_CODE(ret),
198 : ret),
199 : ret);
200 :
201 : // 解析RDMATimeOut
202 52 : std::pair<u32, u32> rdmaTimeOutRange;
203 52 : ret = g_envConfig.ParseRDMATimeOut(rdmaTimeOutRange);
204 52 : char* mmSysGetTimeOutEnvValue = nullptr;
205 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_RDMA_TIMEOUT, mmSysGetTimeOutEnvValue);
206 52 : std::string timeOutEnv = (mmSysGetTimeOutEnvValue != nullptr) ? mmSysGetTimeOutEnvValue : "EmptyString";
207 : std::string vaildRange =
208 52 : "range[" + std::to_string(rdmaTimeOutRange.first) + " ," + std::to_string(rdmaTimeOutRange.second) + "]";
209 52 : RPT_ENV_ERR(ret != HCCL_SUCCESS,
210 : "EI0001",
211 : std::vector<std::string>({"value", "env", "expect"}),
212 : std::vector<std::string>({timeOutEnv, "HCCL_RDMA_TIMEOUT", vaildRange}));
213 52 : CHK_PRT_RET(ret != HCCL_SUCCESS,
214 : HCCL_ERROR("[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_RDMA_TIMEOUT failed. errorno[%d]",
215 : LOG_KEYWORDS_INIT_GROUP.c_str(),
216 : LOG_KEYWORDS_ENV_CONFIG.c_str(),
217 : HCCL_ERROR_CODE(ret),
218 : ret),
219 : ret);
220 :
221 : // 解析RDMARetryCnt
222 52 : ret = g_envConfig.ParseRDMARetryCnt();
223 52 : char* mmSysGetRetryCntEnvValue = nullptr;
224 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_RDMA_RETRY_CNT, mmSysGetRetryCntEnvValue);
225 52 : std::string retryCntEnv = (mmSysGetRetryCntEnvValue != nullptr) ? mmSysGetRetryCntEnvValue : "EmptyString";
226 52 : RPT_ENV_ERR(ret != HCCL_SUCCESS,
227 : "EI0001",
228 : std::vector<std::string>({"value", "env", "expect"}),
229 : std::vector<std::string>({retryCntEnv, "HCCL_RDMA_RETRY_CNT", "range[1, 7]"}));
230 52 : CHK_PRT_RET(ret != HCCL_SUCCESS,
231 : HCCL_ERROR("[%s][%s]errNo[0x%016llx] In init env variable param, parse HCCL_RDMA_RETRY_CNT failed. errorno[%d]",
232 : LOG_KEYWORDS_INIT_GROUP.c_str(),
233 : LOG_KEYWORDS_ENV_CONFIG.c_str(),
234 : HCCL_ERROR_CODE(ret),
235 : ret),
236 : ret);
237 :
238 52 : ret = InitDebugConfigByEnv();
239 52 : char* env = nullptr; // 环境变量值
240 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_DEBUG_CONFIG, env);
241 143 : std::string envValue = env ? std::string(env) : "null";
242 52 : RPT_ENV_ERR(ret != HCCL_SUCCESS,
243 : "EI0001",
244 : std::vector<std::string>({"value", "env", "expect"}),
245 : std::vector<std::string>({envValue, "HCCL_DEBUG_CONFIG", "ALG,TASK,RESOURCE(optionally prefixed with'^'"}));
246 52 : CHK_PRT_RET(ret != HCCL_SUCCESS,
247 : HCCL_ERROR("[%s][%s]errNo[0x%016llx] In init environment param, parse "
248 : "HCCL_DEBUG_CONFIG failed. errorno[%d]",
249 : LOG_KEYWORDS_INIT_GROUP.c_str(),
250 : LOG_KEYWORDS_ENV_CONFIG.c_str(),
251 : HCCL_ERROR_CODE(ret),
252 : ret),
253 : ret);
254 :
255 : // 解析算法配置
256 52 : ret = ParseHcclAlgo();
257 52 : char* mmSysGetEnvValue = nullptr;
258 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_ALGO, mmSysGetEnvValue);
259 52 : std::string hcclAlgo = (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString";
260 52 : RPT_ENV_ERR(ret != HCCL_SUCCESS,
261 : "EI0001",
262 : std::vector<std::string>({"value", "env", "expect"}),
263 : std::vector<std::string>({hcclAlgo, "HCCL_ALGO",
264 : "level0:NA;level1:<algo> or <op0>=level0:NA;level1:<algo0>/<op1>=level0:NA;level1:<algo1>"}));
265 52 : CHK_PRT_RET(ret != HCCL_SUCCESS,
266 : HCCL_ERROR("[%s][%s]errNo[0x%016llx] In init env variable param, parse "
267 : "hccl algorithm config failed. errorno[%d]",
268 : LOG_KEYWORDS_INIT_GROUP.c_str(),
269 : LOG_KEYWORDS_ENV_CONFIG.c_str(),
270 : HCCL_ERROR_CODE(ret),
271 : ret),
272 : ret);
273 52 : return HCCL_SUCCESS;
274 52 : }
275 :
276 0 : bool EnvConfig::CheckEnvLen(const char *envStr, u32 envMaxLen)
277 : {
278 : // 校验环境变量长度
279 0 : u32 envLen = strnlen(envStr, envMaxLen + 1);
280 0 : if (envLen == (envMaxLen + 1)) {
281 0 : HCCL_ERROR("[CheckEnvLen] errNo[0x%016llx] env len is invalid, len is %u", HCCL_ERROR_CODE(HCCL_E_PARA), envLen);
282 0 : return false;
283 : }
284 0 : return true;
285 : }
286 :
287 103 : HcclResult SetDefaultSocketPortRange(const SocketLocation &socketLoc, std::vector<HcclSocketPortRange> &portRangeVec)
288 : {
289 103 : if (socketLoc == SOCKET_HOST) {
290 51 : g_envConfig.hostSocketPortSwitch = false;
291 51 : portRangeVec.clear();
292 51 : HCCL_RUN_WARNING("[HCCL_ENV] HCCL_HOST_SOCKET_PORT_RANGE is not set. Multi-process will not be supported!");
293 52 : } else if (socketLoc == SOCKET_NPU) {
294 52 : g_envConfig.npuSocketPortSwitch = false;
295 52 : portRangeVec.clear();
296 52 : HCCL_RUN_WARNING("[HCCL_ENV] HCCL_NPU_SOCKET_PORT_RANGE is not set. Multi-process will not be supported!");
297 : } else {
298 0 : HCCL_ERROR("[SetDefaultSocketPortRange] undefined socket location, fail to init socket port range by default.");
299 0 : return HCCL_E_NOT_SUPPORT;
300 : }
301 103 : return HCCL_SUCCESS;
302 : }
303 :
304 1 : HcclResult CheckSocketPortRangeValid(const std::string &envName, const std::vector<HcclSocketPortRange> &portRanges)
305 : {
306 1 : std::vector<HcclSocketPortRange> rangeVec(portRanges.begin(), portRanges.end());
307 1 : std::sort(rangeVec.begin(), rangeVec.end(), [](auto &a, auto &b) {
308 0 : return a.min == b.min ? a.max < b.max : a.min < b.min;
309 : });
310 2 : for (size_t i = 0; i < rangeVec.size(); ++i) {
311 : // the socket range should not be inverted
312 1 : CHK_PRT_RET(rangeVec[i].min > rangeVec[i].max,
313 : HCCL_ERROR("[Check][PortRangeValid] In %s, in socket port range [%u, %u], "
314 : "the lower bound is greater than the upper bound.",
315 : envName.c_str(), rangeVec[i].min, rangeVec[i].max),
316 : HCCL_E_PARA);
317 :
318 : // the socket range should not include the reserved port for auto listening.
319 1 : CHK_PRT_RET(rangeVec[i].min <= HCCL_SOCKET_PORT_RANGE_AUTO,
320 : HCCL_ERROR("[Check][PortRangeValid] In %s, socket port range [%u, %u] includes "
321 : "the reserved port number [%u]. please do not use port [%u] in socket port range.",
322 : envName.c_str(), rangeVec[i].min, rangeVec[i].max, HCCL_SOCKET_PORT_RANGE_AUTO,
323 : HCCL_SOCKET_PORT_RANGE_AUTO),
324 : HCCL_E_PARA);
325 :
326 : // the socket range should not exceed the maximum port number
327 1 : CHK_PRT_RET(rangeVec[i].max > MAX_PORT_NUMBER,
328 : HCCL_ERROR("[Check][PortRangeValid] In %s, in socket port range [%u, %u], "
329 : "the upper bound exceed max port number[%u].",
330 : envName.c_str(), rangeVec[i].min, rangeVec[i].max, MAX_PORT_NUMBER),
331 : HCCL_E_PARA);
332 :
333 : // the socket range should not be overlapped
334 1 : CHK_PRT_RET(i != 0 && rangeVec[i - 1].max >= rangeVec[i].min,
335 : HCCL_ERROR("[Check][PortRangeValid] In %s, "
336 : "socket port range [%u, %u] is conflict with socket port range [%u, %u].",
337 : envName.c_str(), rangeVec[i - 1].min, rangeVec[i - 1].max, rangeVec[i].min, rangeVec[i].max),
338 : HCCL_E_PARA);
339 : }
340 :
341 1 : return HCCL_SUCCESS;
342 1 : }
343 :
344 2 : HcclResult GetUIntFromStr(const std::string &digitStr, u32 &val)
345 : {
346 2 : HcclResult ret = IsAllDigit(digitStr.c_str());
347 2 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[GetUIntFromStr] str[%s] is not all digit.",
348 : digitStr.c_str()), ret);
349 2 : ret = SalStrToULong(digitStr.c_str(), HCCL_BASE_DECIMAL, val);
350 2 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[GetUIntFromStr] str[%s] is a invalid number.",
351 : digitStr.c_str()), ret);
352 2 : return HCCL_SUCCESS;
353 : }
354 :
355 2 : bool SplitString(std::string &totalStr, std::string &prefixStr, const std::string &delim)
356 : {
357 2 : std::size_t found = totalStr.find(delim);
358 2 : if (found == std::string::npos) {
359 1 : return false;
360 : }
361 1 : prefixStr = totalStr.substr(0, found);
362 1 : totalStr = totalStr.substr(found + 1);
363 1 : return true;
364 : }
365 :
366 1 : HcclResult SplitSinglePortRange(const std::string &envName, std::string &rangeStr, HcclSocketPortRange &portRange)
367 : {
368 1 : std::string rangeMin{};
369 1 : const std::string delim = "-";
370 1 : if (SplitString(rangeStr, rangeMin, delim)) {
371 1 : CHK_RET(GetUIntFromStr(rangeMin, portRange.min));
372 1 : CHK_RET(GetUIntFromStr(rangeStr, portRange.max));
373 : } else {
374 0 : CHK_RET(GetUIntFromStr(rangeStr, portRange.min));
375 0 : portRange.max = portRange.min;
376 : }
377 1 : HCCL_INFO("[Split][SinglePortRange] Load hccl socket port range [%u, %u] from %s",
378 : portRange.min, portRange.max, envName.c_str());
379 1 : return HCCL_SUCCESS;
380 1 : }
381 :
382 1 : HcclResult SplitHcclSocketPortRange(const std::string &envName, std::string &portRangeConfig,
383 : std::vector<HcclSocketPortRange> &portRangeVec)
384 : {
385 1 : std::string rangeStr{};
386 1 : const std::string delim = ",";
387 1 : while (SplitString(portRangeConfig, rangeStr, delim)) {
388 0 : HcclSocketPortRange portRange = {};
389 0 : CHK_RET(SplitSinglePortRange(envName, rangeStr, portRange));
390 0 : portRangeVec.emplace_back(portRange);
391 : }
392 1 : HcclSocketPortRange portRange = {};
393 1 : CHK_RET(SplitSinglePortRange(envName, portRangeConfig, portRange));
394 1 : portRangeVec.emplace_back(portRange);
395 :
396 1 : CHK_RET(CheckSocketPortRangeValid(envName, portRangeVec));
397 1 : return HCCL_SUCCESS;
398 1 : }
399 :
400 1 : HcclResult PortRangeSwitchOn(const SocketLocation &socketLoc)
401 : {
402 1 : if (socketLoc == SOCKET_HOST) {
403 1 : g_envConfig.hostSocketPortSwitch = true;
404 1 : HCCL_INFO("HCCL_HOST_SOCKET_PORT_RANGE is set, switch on.");
405 0 : } else if (socketLoc == SOCKET_NPU) {
406 0 : g_envConfig.npuSocketPortSwitch = true;
407 0 : HCCL_INFO("HCCL_NPU_SOCKET_PORT_RANGE is set, switch on.");
408 : } else {
409 0 : HCCL_ERROR("[PortRangeSwitchOn] undefined socket location, fail to init socket port range by default.");
410 0 : return HCCL_E_NOT_SUPPORT;
411 : }
412 1 : return HCCL_SUCCESS;
413 : }
414 :
415 1 : void PrintSocketPortRange(const std::string &envName, const std::vector<HcclSocketPortRange> &portRangeVec)
416 : {
417 : // assemble port ranges into a string to print the result range
418 1 : std::ostringstream portRangeOss;
419 2 : for (auto range : portRangeVec) {
420 1 : portRangeOss << " [" << std::to_string(range.min) << ", " << std::to_string(range.max) << "]";
421 : }
422 1 : HCCL_RUN_INFO("%s is set to%s.", envName.c_str(), portRangeOss.str().c_str());
423 1 : }
424 :
425 104 : HcclResult SetSocketPortRange(const std::string &envName, const std::string &socketPortRange,
426 : const SocketLocation &socketLoc, std::vector<HcclSocketPortRange> &portRangeVec)
427 : {
428 104 : portRangeVec.clear();
429 :
430 : // the environment variable is not set
431 104 : if (socketPortRange.compare(ENV_EMPTY_STRING) == 0) {
432 103 : CHK_RET(SetDefaultSocketPortRange(socketLoc, portRangeVec));
433 103 : return HCCL_SUCCESS;
434 : }
435 :
436 : // the socket port range is set to auto, then the os will listen on the ports dynamically and automatically.
437 1 : if (socketPortRange.compare(HCCL_AUTO_PORT_CONFIG) == 0) {
438 0 : HcclSocketPortRange autoSocketPortRange = {
439 : HCCL_SOCKET_PORT_RANGE_AUTO,
440 : HCCL_SOCKET_PORT_RANGE_AUTO
441 : };
442 0 : portRangeVec.emplace_back(autoSocketPortRange);
443 0 : CHK_RET(PortRangeSwitchOn(socketLoc));
444 0 : HCCL_RUN_INFO("%s is set to %s as [%u, %u].", envName.c_str(), HCCL_AUTO_PORT_CONFIG,
445 : autoSocketPortRange.min, autoSocketPortRange.max);
446 0 : return HCCL_SUCCESS;
447 : }
448 :
449 1 : std::string portRangeConfig = socketPortRange;
450 : // the environment variable is set to an empty string
451 1 : portRangeConfig.erase(std::remove(portRangeConfig.begin(), portRangeConfig.end(), ' '), portRangeConfig.end());
452 1 : if (portRangeConfig.empty()) {
453 0 : CHK_RET(SetDefaultSocketPortRange(socketLoc, portRangeVec));
454 0 : return HCCL_SUCCESS;
455 : }
456 : // load ranges from string
457 1 : CHK_RET(SplitHcclSocketPortRange(envName, portRangeConfig, portRangeVec));
458 1 : if (portRangeVec.size() == 0) {
459 0 : HCCL_ERROR("Load empty port range from %s, please check.", envName.c_str());
460 0 : return HCCL_E_PARA;
461 : }
462 1 : CHK_RET(PortRangeSwitchOn(socketLoc));
463 1 : (void) PrintSocketPortRange(envName, portRangeVec);
464 1 : return HCCL_SUCCESS;
465 1 : }
466 :
467 52 : HcclResult ParseHostSocketPortRange()
468 : {
469 52 : DevType deviceType = DevType::DEV_TYPE_COUNT;
470 52 : CHK_RET(hrtGetDeviceType(deviceType));
471 52 : if (deviceType != DevType::DEV_TYPE_910
472 1 : && deviceType != DevType::DEV_TYPE_910B
473 1 : && deviceType != DevType::DEV_TYPE_910_93) {
474 0 : g_envConfig.hostSocketPortSwitch = false;
475 0 : g_envConfig.hostSocketPortRange.clear();
476 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_HOST_SOCKET_PORT_RANGE is not supported on devType[%u], nothing is loaded.", deviceType);
477 0 : return HCCL_SUCCESS;
478 : }
479 :
480 52 : char* mmSysGetEnvValue = nullptr;
481 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_HOST_SOCKET_PORT_RANGE, mmSysGetEnvValue);
482 52 : std::string hostSocketPortRangeEnv = (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString";
483 156 : CHK_RET(SetSocketPortRange("HCCL_HOST_SOCKET_PORT_RANGE", hostSocketPortRangeEnv, SOCKET_HOST,
484 : g_envConfig.hostSocketPortRange));
485 52 : return HCCL_SUCCESS;
486 52 : }
487 :
488 52 : HcclResult ParseNpuSocketPortRange()
489 : {
490 52 : DevType deviceType = DevType::DEV_TYPE_COUNT;
491 52 : CHK_RET(hrtGetDeviceType(deviceType));
492 52 : if (deviceType != DevType::DEV_TYPE_910
493 1 : && deviceType != DevType::DEV_TYPE_910B
494 1 : && deviceType != DevType::DEV_TYPE_910_93) {
495 0 : g_envConfig.npuSocketPortSwitch = false;
496 0 : g_envConfig.npuSocketPortRange.clear();
497 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_NPU_SOCKET_PORT_RANGE is not supported on devType[%u], nothing is loaded.", deviceType);
498 0 : return HCCL_SUCCESS;
499 : }
500 52 : char* mmSysGetEnvValue = nullptr;
501 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_NPU_SOCKET_PORT_RANGE, mmSysGetEnvValue);
502 52 : std::string npuSocketPortRangeEnv = (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString";
503 156 : CHK_RET(SetSocketPortRange("HCCL_NPU_SOCKET_PORT_RANGE", npuSocketPortRangeEnv, SOCKET_NPU,
504 : g_envConfig.npuSocketPortRange));
505 52 : return HCCL_SUCCESS;
506 52 : }
507 :
508 : // 通用的环境变量解析函数
509 104 : HcclResult ParseEnvConfig(const EnvConfigParam& param, std::string& envValue, u32& resultValue)
510 : {
511 104 : if (envValue.compare(ENV_EMPTY_STRING) == 0) {
512 104 : HCCL_RUN_INFO("%s set by default to [%u]", param.envName.c_str(), param.defaultValue);
513 104 : resultValue = param.defaultValue;
514 104 : return HCCL_SUCCESS;
515 : }
516 :
517 : // 校验环境变量长度
518 0 : bool isEnvLenValid = g_envConfig.CheckEnvLen(envValue.c_str(), g_envConfig.MAX_LEN_OF_DIGIT_ENV);
519 0 : CHK_PRT_RET(!isEnvLenValid,
520 : HCCL_ERROR("[Parse][%s] errNo[0x%016llx] Invalid %s env len, len is bigger than [%u], errorno[%d]",
521 : param.envName.c_str(), HCCL_ERROR_CODE(HCCL_E_PARA), param.envName.c_str(), g_envConfig.MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA),
522 : HCCL_E_PARA);
523 :
524 0 : CHK_RET(IsAllDigit(envValue.c_str()));
525 :
526 0 : HcclResult ret = SalStrToULong(envValue.c_str(), HCCL_BASE_DECIMAL, resultValue);
527 : // 若转换出错或者设置的值不在有效范围内，报错
528 0 : CHK_PRT_RET((ret != HCCL_SUCCESS || resultValue < param.minValue || resultValue > param.maxValue),
529 : HCCL_ERROR("[Parse][%s] is invalid. except: [%u, %u], actual: [%u]", param.envName.c_str(), param.minValue, param.maxValue, resultValue),
530 : HCCL_E_PARA);
531 :
532 : // 如果提供了baseValue，检查是否是baseValue的整数倍
533 0 : if (param.baseValue != 0 && resultValue % param.baseValue != 0) {
534 0 : HCCL_ERROR("[Parse] %s[%u] is not a multiple of [%u]", param.envName.c_str(), resultValue, param.baseValue);
535 0 : return HCCL_E_PARA;
536 : }
537 :
538 0 : HCCL_RUN_INFO("%s set by environment to [%u]", param.envName.c_str(), resultValue);
539 0 : return HCCL_SUCCESS;
540 : }
541 :
542 52 : HcclResult EnvConfig::ParseRDMATrafficClass()
543 : {
544 52 : EnvConfigParam param = {
545 0 : "HCCL_RDMA_TC",
546 : HCCL_RDMA_TC_DEFAULT,
547 : HCCL_RDMA_TC_MIN,
548 : HCCL_RDMA_TC_MAX,
549 : HCCL_RDMA_TC_BASE
550 52 : };
551 52 : char* mmSysGetEnvValue = nullptr;
552 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_RDMA_TC, mmSysGetEnvValue);
553 52 : std::string envValue = (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString";
554 104 : return ParseEnvConfig(param, envValue, g_envConfig.rdmaTrafficClass);
555 52 : }
556 :
557 52 : HcclResult EnvConfig::ParseRDMAServerLevel()
558 : {
559 52 : EnvConfigParam param = {
560 0 : "HCCL_RDMA_SL",
561 : HCCL_RDMA_SL_DEFAULT,
562 : HCCL_RDMA_SL_MIN,
563 : HCCL_RDMA_SL_MAX,
564 : 0
565 52 : };
566 52 : char* mmSysGetEnvValue = nullptr;
567 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_RDMA_SL, mmSysGetEnvValue);
568 52 : std::string envValue = (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString";
569 104 : return ParseEnvConfig(param, envValue, g_envConfig.rdmaServerLevel);
570 52 : }
571 :
572 52 : HcclResult EnvConfig::ParseRDMATimeOut(std::pair<u32, u32> &rdmaTimeOutRange)
573 : {
574 : u32 rdmaTimeOutMax;
575 : #ifndef HCCD
576 52 : if (!IsGeneralServer()) {
577 : DevType deviceType;
578 52 : CHK_RET(hrtGetDeviceType(deviceType));
579 103 : rdmaTimeOutMax = (deviceType == DevType::DEV_TYPE_910_93 || deviceType == DevType::DEV_TYPE_910B)
580 103 : ? HCCL_RDMA_TIMEOUT_MAX_910_93
581 : : HCCL_RDMA_TIMEOUT_MAX;
582 : } else {
583 0 : rdmaTimeOutMax = HCCL_RDMA_TIMEOUT_MAX;
584 : }
585 : #else
586 : rdmaTimeOutMax = HCCL_RDMA_TIMEOUT_MAX;
587 : #endif
588 52 : rdmaTimeOutRange.first = HCCL_RDMA_TIMEOUT_MIN;
589 52 : rdmaTimeOutRange.second = rdmaTimeOutMax;
590 52 : char* mmSysGetEnvValue = nullptr;
591 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_RDMA_TIMEOUT, mmSysGetEnvValue);
592 52 : std::string timeOutEnv = (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString";
593 52 : u32 rdmaTimeOut = HCCL_RDMA_TIMEOUT_DEFAULT;
594 52 : if (timeOutEnv == "EmptyString") {
595 52 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_TIMEOUT set by default to [%u]", rdmaTimeOut);
596 52 : return HCCL_SUCCESS;
597 : }
598 :
599 : // 校验环境变量长度
600 0 : bool isEnvLenValid = CheckEnvLen(timeOutEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
601 :
602 0 : CHK_PRT_RET(!isEnvLenValid,
603 : HCCL_ERROR("[Parse][RDMATimeOut]errNo[0x%016llx] Invalid HCCL_RDMA_TIMEOUT env len, len is bigger than "\
604 : "[%u]. errorno[%d]", HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA), HCCL_E_PARA);
605 :
606 0 : g_envConfig.rdmaTimeOut = HCCL_RDMA_TIMEOUT_DEFAULT;
607 0 : CHK_RET(IsAllDigit(timeOutEnv.c_str()));
608 :
609 0 : HcclResult ret = SalStrToULong(timeOutEnv.c_str(), HCCL_BASE_DECIMAL, rdmaTimeOut);
610 : // 若转换出错或者设置的RDMATimeOut不在有效范围内，报错
611 0 : CHK_PRT_RET(
612 : (ret != HCCL_SUCCESS || rdmaTimeOut < HCCL_RDMA_TIMEOUT_MIN || rdmaTimeOut > rdmaTimeOutMax),
613 : HCCL_ERROR("[Parse][RDMATimeOut]HCCL_RDMA_TIMEOUT[%s] is invalid. except: [%u, %u]",
614 : timeOutEnv.c_str(),
615 : HCCL_RDMA_TIMEOUT_MIN,
616 : rdmaTimeOutMax),
617 : HCCL_E_PARA);
618 :
619 0 : g_envConfig.rdmaTimeOut = rdmaTimeOut;
620 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_TIMEOUT set by environment to [%u]", rdmaTimeOut);
621 0 : return HCCL_SUCCESS;
622 52 : }
623 :
624 52 : HcclResult EnvConfig::ParseRDMARetryCnt()
625 : {
626 52 : char* mmSysGetEnvValue = nullptr;
627 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_RDMA_RETRY_CNT, mmSysGetEnvValue);
628 52 : std::string retryCntEnv = (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString";
629 52 : u32 rdmaRetryCnt = HCCL_RDMA_RETRY_CNT_DEFAULT;
630 52 : if (retryCntEnv == "EmptyString") {
631 52 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_RETRY_CNT set by default to [%u]", rdmaRetryCnt);
632 52 : return HCCL_SUCCESS;
633 : }
634 :
635 : // 校验环境变量长度
636 0 : bool isEnvLenValid = CheckEnvLen(retryCntEnv.c_str(), MAX_LEN_OF_DIGIT_ENV);
637 :
638 0 : CHK_PRT_RET(!isEnvLenValid,
639 : HCCL_ERROR("[Parse][rdmaRetryCnt]errNo[0x%016llx] Invalid HCCL_RDMA_RETRY_CNT env len, len is bigger than "\
640 : "[%u]. errorno[%d]", HCCL_ERROR_CODE(HCCL_E_PARA), MAX_LEN_OF_DIGIT_ENV, HCCL_E_PARA), HCCL_E_PARA);
641 :
642 0 : g_envConfig.rdmaRetryCnt = HCCL_RDMA_RETRY_CNT_DEFAULT;
643 0 : CHK_RET(IsAllDigit(retryCntEnv.c_str()));
644 :
645 0 : HcclResult ret = SalStrToULong(retryCntEnv.c_str(), HCCL_BASE_DECIMAL, rdmaRetryCnt);
646 : // 若转换出错或者设置的RDMARetryCnt不在有效范围内，报错
647 0 : CHK_PRT_RET(
648 : (ret != HCCL_SUCCESS || rdmaRetryCnt < HCCL_RDMA_RETRY_CNT_MIN || rdmaRetryCnt > HCCL_RDMA_RETRY_CNT_MAX),
649 : HCCL_ERROR("[Parse][rdmaRetryCnt]HCCL_RDMA_RETRY_CNT[%s] is invalid. except: [%u, %u]", retryCntEnv.c_str(),
650 : HCCL_RDMA_RETRY_CNT_MIN, HCCL_RDMA_RETRY_CNT_MAX),
651 : HCCL_E_PARA);
652 0 : g_envConfig.rdmaRetryCnt = rdmaRetryCnt;
653 0 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_RDMA_RETRY_CNT set by environment to [%u]", rdmaRetryCnt);
654 0 : return HCCL_SUCCESS;
655 52 : }
656 :
657 210 : HcclResult ParseSingleDFSConfigItem(const std::string& dfsConfigEnv, const std::string& configName,
658 : std::string& configResult)
659 : {
660 210 : size_t start = dfsConfigEnv.find(configName);
661 210 : if (start == std::string::npos) {
662 173 : HCCL_INFO("[Parse] DFS config item [%s] is not found.", configName.c_str());
663 173 : return HCCL_SUCCESS;
664 : }
665 37 : size_t end = dfsConfigEnv.find(",", start);
666 37 : if (end == std::string::npos) {
667 34 : configResult = dfsConfigEnv.substr(start + configName.size());
668 : } else {
669 3 : configResult = dfsConfigEnv.substr(start + configName.size(), end - start - configName.size());
670 : }
671 37 : HCCL_INFO("[Parse] DFS config item %s [%s]", configName.c_str(), configResult.c_str());
672 37 : return HCCL_SUCCESS;
673 : }
674 :
675 42 : HcclResult ParseMonitor(std::string &taskMonitorInterval, s32 &monitorTime)
676 : {
677 42 : if (taskMonitorInterval.empty()) {
678 42 : monitorTime = 0;
679 : } else {
680 0 : HcclResult ret = SalStrToInt(taskMonitorInterval, HCCL_BASE_DECIMAL, monitorTime);
681 0 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[ParseDFSConfig] HCCL_DFS_CONFIG-task_monitor_interval[%s]"
682 : "is invalid, errorno[%d]", taskMonitorInterval.c_str(), ret), ret);
683 : }
684 :
685 42 : s32 maxTimeInMs = HCCL_MAX_LINK_TIME_OUT_S * 1000;
686 42 : if (monitorTime == 0) {
687 42 : g_envConfig.dfsTaskMonitorInterval = 0;
688 0 : } else if (monitorTime >= 0 && monitorTime <= maxTimeInMs) {
689 0 : g_envConfig.dfsTaskMonitorInterval = monitorTime;
690 : } else { // 不在允许范围内报错
691 0 : HCCL_ERROR("[ParseDFSConfig] HCCL_DFS_CONFIG-task_monitor_interval[%d] is invalid, except: [0, %d]",
692 : monitorTime, maxTimeInMs);
693 0 : return HCCL_E_PARA;
694 : }
695 42 : return HCCL_SUCCESS;
696 : }
697 :
698 52 : HcclResult ParseDFSConfig()
699 : {
700 52 : char* dfsConfigValue = nullptr;
701 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_DFS_CONFIG, dfsConfigValue);
702 52 : std::string dfsConfigEnv = (dfsConfigValue != nullptr) ? dfsConfigValue : "EmptyString";
703 52 : if (dfsConfigEnv == "EmptyString") {
704 10 : HCCL_RUN_INFO("[HCCL_ENV][Parse][HCCL_DFS_CONFIG] Parse environmental variable HCCL_DFS_CONFIG is not set.");
705 10 : return HCCL_SUCCESS;
706 : }
707 :
708 : //去除空格
709 42 : dfsConfigEnv.erase(std::remove(dfsConfigEnv.begin(), dfsConfigEnv.end(), ' '), dfsConfigEnv.end());
710 :
711 42 : std::transform(dfsConfigEnv.begin(), dfsConfigEnv.end(), dfsConfigEnv.begin(), ::tolower);
712 :
713 42 : std::string heartbeatSwitch;
714 42 : CHK_RET(ParseSingleDFSConfigItem(dfsConfigEnv, CLUSTER_HEART_CONFIG, heartbeatSwitch));
715 42 : if (heartbeatSwitch == "off") {
716 5 : g_envConfig.enableClusterHeartBeat = false;
717 37 : } else if (heartbeatSwitch == "on") {
718 3 : g_envConfig.enableClusterHeartBeat = true;
719 : } else {
720 34 : HCCL_RUN_WARNING("[HCCL_ENV][ParseDFSConfig] HCCL_DFS_CONFIG-cluster_heartbeat was configured to [%s], please configured to"\
721 : "'on' or 'off'", heartbeatSwitch.c_str());
722 : }
723 :
724 42 : std::string stuckDetectSwitch;
725 42 : CHK_RET(ParseSingleDFSConfigItem(dfsConfigEnv, STUCK_DETECTION_CONFIG, stuckDetectSwitch));
726 42 : if (stuckDetectSwitch == "off") {
727 1 : g_envConfig.opCounterEnable = false;
728 41 : } else if (stuckDetectSwitch == "on") {
729 1 : g_envConfig.opCounterEnable = true;
730 : } else {
731 40 : HCCL_RUN_WARNING("[HCCL_ENV][ParseDFSConfig] HCCL_DFS_CONFIG-stuck_detection was configured to [%s], please configured to"\
732 : "'on' or 'off'", stuckDetectSwitch.c_str());
733 : }
734 :
735 : // 解析算子不一致故障检测能力开关
736 42 : std::string inconsistentCheckSwitch;
737 42 : CHK_RET(ParseSingleDFSConfigItem(dfsConfigEnv, INCONSISTENT_CHECK_CONFIG, inconsistentCheckSwitch));
738 42 : if (inconsistentCheckSwitch == "off") {
739 0 : g_envConfig.inconsistentCheckSwitch = InconsistentCheckMode::OFF;
740 42 : } else if (inconsistentCheckSwitch == "on") {
741 0 : g_envConfig.inconsistentCheckSwitch = InconsistentCheckMode::ON;
742 42 : } else if (inconsistentCheckSwitch == "first") {
743 0 : g_envConfig.inconsistentCheckSwitch = InconsistentCheckMode::FIRST;
744 : } else {
745 42 : HCCL_RUN_WARNING("[ParseDFSConfig] HCCL_DFS_CONFIG-inconsistent_check was configured to [%s], please configured to"\
746 : "'on' or 'off' or 'first'", inconsistentCheckSwitch.c_str());
747 : }
748 :
749 42 : std::string taskMonitorInterval = "";
750 42 : s32 monitorTime = 0;
751 42 : CHK_RET(ParseSingleDFSConfigItem(dfsConfigEnv, TASK_MONITOR_INTERVAL, taskMonitorInterval));
752 42 : CHK_RET(ParseMonitor(taskMonitorInterval, monitorTime));
753 :
754 : // 解析连接故障检测时间
755 42 : std::string connectionDefaultDetectionTime = "";
756 42 : CHK_RET(ParseSingleDFSConfigItem(dfsConfigEnv, CONNECTION_FAULT_DETECTION_TIME, connectionDefaultDetectionTime));
757 42 : if (connectionDefaultDetectionTime.empty()) {
758 15 : g_envConfig.dfsConnectionFaultDetectionTime = HCCL_MIN_CONNECT_FAULT_DETECTION_TIME;
759 15 : HCCL_RUN_INFO("[HCCL_ENV][Parse] HCCL_DFS_CONFIG cluster_heartbeat set by environment to [%d], "
760 : "stuck_detection set by environment to [%d], connection_fault_detection_time[%d]s inconsistentCheckSwitch[%d],"
761 : "task_monitor_interval[%u]ms", g_envConfig.enableClusterHeartBeat, g_envConfig.opCounterEnable,
762 : g_envConfig.dfsConnectionFaultDetectionTime, g_envConfig.inconsistentCheckSwitch, g_envConfig.dfsTaskMonitorInterval);
763 15 : return HCCL_SUCCESS;
764 : }
765 27 : s32 detctTime = 0;
766 27 : HcclResult ret = SalStrToInt(connectionDefaultDetectionTime, HCCL_BASE_DECIMAL, detctTime);
767 27 : CHK_PRT_RET(ret != HCCL_SUCCESS, HCCL_ERROR("[ParseDFSConfig] HCCL_DFS_CONFIG-connection_fault_detection_time[%s]"
768 : "is invalid, errorno[%d]", connectionDefaultDetectionTime.c_str(), ret), ret);
769 :
770 27 : if (detctTime == 0) {
771 21 : g_envConfig.dfsConnectionFaultDetectionTime = 0;
772 6 : } else if (detctTime >= HCCL_MIN_CONNECT_FAULT_DETECTION_TIME && detctTime <= HCCL_MAX_LINK_TIME_OUT_S) {
773 6 : g_envConfig.dfsConnectionFaultDetectionTime = detctTime;
774 : } else { // 不在允许范围内报错
775 0 : HCCL_ERROR("[ParseDFSConfig] HCCL_DFS_CONFIG-connection_fault_detection_time[%d] is invalid, except: [%d, %d]",
776 : detctTime, HCCL_MIN_CONNECT_FAULT_DETECTION_TIME, HCCL_MAX_LINK_TIME_OUT_S);
777 0 : return HCCL_E_PARA;
778 : }
779 :
780 27 : HCCL_RUN_INFO("[HCCL_ENV][Parse] HCCL_DFS_CONFIG cluster_heartbeat set by environment to [%d], "
781 : "stuck_detection set by environment to [%d], connection_fault_detection_time[%d]s inconsistentCheckSwitch[%d],"
782 : "task_monitor_interval[%u]ms", g_envConfig.enableClusterHeartBeat, g_envConfig.opCounterEnable,
783 : g_envConfig.dfsConnectionFaultDetectionTime, g_envConfig.inconsistentCheckSwitch, g_envConfig.dfsTaskMonitorInterval);
784 27 : return HCCL_SUCCESS;
785 52 : }
786 :
787 0 : HcclResult GetKeyWordPath(const std::string &cannEnvStr, const std::string &keyStr, std::string &cannPath)
788 : {
789 0 : std::string tempPath; // 存放临时路径
790 : // 查找cann安装路径
791 0 : for (u32 i = 0; i < cannEnvStr.length(); ++i) {
792 : // 环境变量中存放的每段路径之间以':'隔开
793 0 : if (cannEnvStr[i] != ':') {
794 0 : tempPath += cannEnvStr[i];
795 : }
796 :
797 0 : if (cannEnvStr[i] == ':' || i == cannEnvStr.length() - 1) {
798 0 : size_t found = tempPath.find(keyStr);
799 0 : if (found == std::string::npos) {
800 0 : tempPath.clear();
801 0 : continue;
802 : }
803 0 : if (tempPath.length() <= found + keyStr.length() || tempPath[found + keyStr.length()] == '/') {
804 0 : cannPath = tempPath.substr(0, found + keyStr.length());
805 0 : break;
806 : }
807 0 : tempPath.clear();
808 : }
809 : }
810 0 : if (cannPath.empty()) {
811 0 : return HCCL_E_NOT_FOUND;
812 : }
813 0 : return HCCL_SUCCESS;
814 0 : }
815 :
816 0 : HcclResult ParseLibraryPath(std::string &cannPath)
817 : {
818 0 : char* mmSysGetEnvValue = nullptr;
819 0 : MM_SYS_GET_ENV(MM_ENV_LD_LIBRARY_PATH, mmSysGetEnvValue);
820 0 : std::string getPath = (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString";
821 0 : if (getPath == "EmptyString") {
822 0 : HCCL_ERROR("[ParseLibraryPath]ENV:LD_LIBRARY_PATH is not set");
823 0 : return HCCL_E_PARA;
824 : } else {
825 0 : HCCL_INFO("ParseLibraryPath]getPath[%s]", getPath.c_str());
826 0 : cannPath = getPath;
827 : }
828 0 : return HCCL_SUCCESS;
829 0 : }
830 :
831 11 : const bool& GetExternalInputHcclHeartBeatEnable()
832 : {
833 11 : return g_envConfig.enableClusterHeartBeat;
834 : }
835 :
836 1076 : const bool& GetExternalInputStuckDetect()
837 : {
838 1076 : return g_envConfig.opCounterEnable;
839 : }
840 :
841 37 : const InconsistentCheckMode& GetExternalInconsistentCheckSwitch()
842 : {
843 37 : return g_envConfig.inconsistentCheckSwitch;
844 : }
845 :
846 52 : HcclResult ParseHcclAlgo()
847 : {
848 52 : char* mmSysGetEnvValue = nullptr;
849 52 : MM_SYS_GET_ENV(MM_ENV_HCCL_ALGO, mmSysGetEnvValue);
850 52 : std::string hcclAlgo = (mmSysGetEnvValue != nullptr) ? mmSysGetEnvValue : "EmptyString";
851 52 : if (hcclAlgo != "EmptyString") {
852 7 : CHK_RET(SetHcclAlgoConfig(hcclAlgo));
853 7 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_ALGO set by environment to [%s]", hcclAlgo.c_str());
854 : } else {
855 45 : HCCL_RUN_INFO("[HCCL_ENV] HCCL_ALGO is not set");
856 : }
857 52 : return HCCL_SUCCESS;
858 52 : }
|
