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