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 "topoinfo_ranktableHeterog.h"
12 :
13 : #include <map>
14 : #include <vector>
15 : #include <string>
16 : #include <fstream>
17 : #include <algorithm>
18 : #include <unistd.h>
19 : #include <chrono>
20 : #include <iostream>
21 : #include <arpa/inet.h>
22 :
23 : #include "externalinput_pub.h"
24 : // ltm指定config路径
25 : #include "common/src/config.h"
26 : #include "workflow_pub.h"
27 :
28 : using namespace std;
29 : using namespace hccl;
30 :
31 : constexpr u32 MAX_PORT_ID = 65535;
32 0 : TopoinfoRanktableHeterog::TopoinfoRanktableHeterog(
33 0 : const std::string& rankTableM, const std::string& identify, DevType deviceType)
34 : : TopoInfoRanktableParser(rankTableM, identify),
35 0 : deviceType_(deviceType)
36 0 : {}
37 :
38 0 : TopoinfoRanktableHeterog::~TopoinfoRanktableHeterog() {}
39 :
40 0 : HcclResult TopoinfoRanktableHeterog::Init()
41 : {
42 : // 根据rankTable类型标记执行读文件或读字符串,将内容保存在json对象fileContent_中
43 0 : CHK_RET(LoadRankTableString(rankTableFile_));
44 : // 解析rankTable
45 0 : CHK_RET(ParserClusterInfo(params_, rankTable_));
46 0 : return HCCL_SUCCESS;
47 : }
48 :
49 0 : HcclResult TopoinfoRanktableHeterog::GetSelfClusterInfo(HcclCommParams& params)
50 : {
51 : // 获取params
52 0 : params.rank = params_.rank;
53 0 : params.userRank = params_.rank;
54 0 : params.totalRanks = params_.totalRanks;
55 0 : params.logicDevId = params_.logicDevId;
56 0 : params.serverId = params_.serverId;
57 0 : params.deviceType = params_.deviceType;
58 0 : return HCCL_SUCCESS;
59 : }
60 :
61 0 : HcclResult TopoinfoRanktableHeterog::GetClusterInfo(hccl::HcclCommParams& params, hccl::RankTable_t& rankTable)
62 : {
63 0 : CHK_RET(GetClusterInfo(rankTable));
64 0 : CHK_RET(GetSelfClusterInfo(params));
65 0 : return HCCL_SUCCESS;
66 : }
67 :
68 0 : HcclResult TopoinfoRanktableHeterog::GetClusterInfo(RankTable_t& clusterInfo)
69 : {
70 : // 获取rankInfo
71 0 : clusterInfo.deviceNum = rankTable_.deviceNum;
72 0 : clusterInfo.serverNum = rankTable_.serverNum;
73 0 : clusterInfo.nicDeploy = rankTable_.nicDeploy;
74 0 : clusterInfo.rankNum = rankTable_.rankNum;
75 0 : clusterInfo.rankList = rankTable_.rankList;
76 0 : clusterInfo.serverList = rankTable_.serverList;
77 0 : clusterInfo.collectiveId = rankTable_.collectiveId;
78 0 : clusterInfo.version = rankTable_.version;
79 0 : clusterInfo.mode = rankTable_.mode;
80 0 : return HCCL_SUCCESS;
81 : }
82 :
83 0 : HcclResult TopoinfoRanktableHeterog::ParserClusterInfo(hccl::HcclCommParams& params, hccl::RankTable_t& rankTable)
84 : {
85 : // 获取ranktable info信息
86 0 : CHK_RET(GetRanktableInfo(rankTable));
87 0 : if (!IsTaskNumCalMode()) {
88 0 : CHK_RET(CheckNicDeployConsistence(rankTable));
89 0 : rankTable.nicDeploy = NICDeployment::NIC_DEPLOYMENT_DEVICE;
90 0 : std::sort(
91 : rankTable.rankList.begin(), rankTable.rankList.end(),
92 0 : [&](const RankInfo_t& a, const RankInfo_t& b) -> bool {
93 0 : return a.rankId < b.rankId;
94 : });
95 :
96 0 : unordered_map<std::string, u32> minRankPerServerMap;
97 0 : for (auto& iter : rankTable.rankList) {
98 0 : if (minRankPerServerMap.find(iter.serverId) == minRankPerServerMap.end()) {
99 0 : minRankPerServerMap[iter.serverId] = iter.rankId;
100 0 : } else if (minRankPerServerMap[iter.serverId] > iter.rankId) {
101 0 : minRankPerServerMap[iter.serverId] = iter.rankId;
102 : }
103 : }
104 0 : map<u32, std::string> minRankInServerMap;
105 0 : for (auto& iter : minRankPerServerMap) {
106 0 : minRankInServerMap.insert(std::make_pair(iter.second, iter.first));
107 : }
108 :
109 0 : u32 serverIndex = 0;
110 0 : for (auto& iter : minRankInServerMap) {
111 0 : for (u32 rankIndex = 0; rankIndex < rankTable.rankList.size(); rankIndex++) {
112 0 : if (rankTable.rankList[rankIndex].serverId == iter.second) {
113 0 : rankTable.rankList[rankIndex].serverIdx = serverIndex;
114 0 : ServerInfo_t serverinfo;
115 0 : NetworkInfo_t networkInfo;
116 0 : serverinfo.serverId = iter.second;
117 0 : networkInfo.ipAddr = rankTable.rankList[rankIndex].hostIp;
118 0 : serverinfo.networkInfo.push_back(networkInfo);
119 : std::vector<ServerInfo_t>::iterator found
120 0 : = find(rankTable.serverList.begin(), rankTable.serverList.end(), serverinfo);
121 0 : if (found == rankTable.serverList.end()) {
122 0 : rankTable.serverList.push_back(serverinfo);
123 : }
124 0 : }
125 : }
126 0 : serverIndex++;
127 : }
128 :
129 0 : u32 rankId = INVALID_VALUE_RANKID;
130 0 : std::string errormessage = "";
131 0 : if (SalStrToULong(identify_, HCCL_BASE_DECIMAL, rankId) != HCCL_SUCCESS) {
132 0 : errormessage = "Value [" + identify_
133 0 : + "] for rankTable variable [rank_id] is invalid, expected value is a valid integer.";
134 0 : HCCL_ERROR(
135 : "[%s][%s]errNo[0x%016llx] [%s]", LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_RANKTABLE_CHECK.c_str(),
136 : HCOM_ERROR_CODE(HCCL_E_PARA), errormessage.c_str());
137 0 : return HCCL_E_PARA;
138 : }
139 : // 校验rank id合法性
140 0 : if (rankId >= rankTable.rankList.size()) {
141 0 : errormessage = "Value [" + std::to_string(rankId)
142 0 : + "] for rankTable variable [rank_id] is invalid, "
143 0 : "expected value is a valid rank ID in [0, "
144 0 : + std::to_string(rankTable.rankList.size() - 1) + "].";
145 0 : HCCL_ERROR(
146 : "[%s][%s] [%s]", LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_RANKTABLE_CHECK.c_str(),
147 : errormessage.c_str());
148 0 : return HCCL_E_PARA;
149 : }
150 0 : errormessage = "The current node's rankId [" + std::to_string(rankId)
151 0 : + "] does not match "
152 0 : "the rankId ["
153 0 : + std::to_string(rankTable.rankList[rankId].rankId) + "] in the rankTable.";
154 0 : CHK_PRT_RET(
155 : rankId != rankTable.rankList[rankId].rankId,
156 : HCCL_ERROR(
157 : "[%s][%s] [%s]", LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_RANKTABLE_CHECK.c_str(),
158 : errormessage.c_str()),
159 : HCCL_E_UNAVAIL);
160 :
161 : // params内容填入
162 0 : params.rank = rankId;
163 0 : params.logicDevId = rankTable.rankList[rankId].deviceInfo.devicePhyId;
164 0 : params.serverId = rankTable.rankList[rankId].serverId;
165 0 : params.totalRanks = rankTable.rankNum;
166 0 : params.deviceType = deviceType_;
167 0 : }
168 0 : return HCCL_SUCCESS;
169 : }
170 :
171 0 : HcclResult TopoinfoRanktableHeterog::GetRanktableInfo(RankTable_t& clusterInfo)
172 : {
173 : // 清空list
174 0 : clusterInfo.serverList.clear();
175 0 : clusterInfo.rankList.clear();
176 :
177 : // 获取信息
178 0 : std::string collective_id;
179 0 : nlohmann::json node_list;
180 0 : std::string version;
181 0 : std::string mode;
182 :
183 0 : std::string heterogSubVersion;
184 : // 解析91093-ES专属标志
185 0 : if (fileContent_.find("heterog_sub_version") != fileContent_.end()) {
186 0 : CHK_RET(GetJsonProperty(fileContent_, "heterog_sub_version", heterogSubVersion, false));
187 0 : CHK_RET(CheckHeterogSubVersion(heterogSubVersion));
188 0 : HCCL_DEBUG("[Get][RanktableInfo] heterog_sub_version exists!");
189 0 : is91093_ = true;
190 : }
191 :
192 0 : CHK_RET(GetJsonProperty(fileContent_, "collective_id", collective_id, false));
193 0 : if (collective_id.length() > COLLECTIVEID_MAX_LEN) {
194 0 : HCCL_ERROR(
195 : "[Get][RanktableInfo]errNo[0x%016llx] collectiveId length is over than %d bytes.",
196 : HCOM_ERROR_CODE(HCCL_E_PARA), collective_id.length());
197 0 : return HCCL_E_PARA;
198 : }
199 0 : CHK_RET(GetJsonProperty(fileContent_, "node_list", node_list, false));
200 0 : CHK_RET(GetJsonProperty(fileContent_, "version", version, false));
201 :
202 0 : if (fileContent_.find("mode") != fileContent_.end()) {
203 0 : CHK_RET(GetJsonProperty(fileContent_, "mode", mode, false));
204 0 : CHK_RET(CheckMode(mode));
205 : }
206 :
207 0 : HCCL_DEBUG("[rankTableJson] -> collectiveId: [%s], nodeListSize: [%zu]", collective_id.c_str(), node_list.size());
208 :
209 : // 保存serverNum
210 0 : clusterInfo.serverNum = node_list.size();
211 0 : if (clusterInfo.serverNum == 0) {
212 0 : HCCL_ERROR("[Get][RanktableInfo]errNo[0x%016llx] node num is zero", HCOM_ERROR_CODE(HCCL_E_PARA));
213 0 : return HCCL_E_PARA;
214 : }
215 : // 获得single node信息
216 0 : for (u32 index = 0; index < clusterInfo.serverNum; index++) {
217 0 : CHK_RET(GetSingleNode(node_list, index, clusterInfo));
218 : }
219 :
220 : // 保存deviceNum和rankNum
221 0 : CHK_RET(GetDevNum(clusterInfo.rankList, clusterInfo.deviceNum));
222 0 : clusterInfo.rankNum = clusterInfo.rankList.size();
223 0 : clusterInfo.collectiveId = collective_id;
224 0 : clusterInfo.version = version;
225 0 : clusterInfo.mode = mode;
226 0 : return HCCL_SUCCESS;
227 0 : }
228 :
229 0 : HcclResult TopoinfoRanktableHeterog::CheckNicDeployConsistence(RankTable_t& clusterInfo) const
230 : {
231 : // 检查rankList的大小
232 0 : CHK_PRT_RET(
233 : clusterInfo.rankList.size() == 0, HCCL_DEBUG("rank list size is 0, skip nic deeply check."), HCCL_SUCCESS);
234 0 : NICDeployment tmpNicDeply = clusterInfo.rankList.begin()->hostIp.IsInvalid() ?
235 : NICDeployment::NIC_DEPLOYMENT_DEVICE :
236 0 : NICDeployment::NIC_DEPLOYMENT_HOST;
237 0 : for (auto& it : clusterInfo.rankList) {
238 0 : CHK_PRT_RET(
239 : (tmpNicDeply == NICDeployment::NIC_DEPLOYMENT_DEVICE && !it.hostIp.IsInvalid())
240 : || (tmpNicDeply == NICDeployment::NIC_DEPLOYMENT_HOST && it.hostIp.IsInvalid()),
241 : HCCL_ERROR(
242 : "[Get][RanktableInfo] errNo[0x%016llx] "
243 : "hostIp config bettewn ranks is different.",
244 : HCOM_ERROR_CODE(HCCL_E_PARA)),
245 : HCCL_E_PARA);
246 : }
247 0 : return HCCL_SUCCESS;
248 : }
249 :
250 0 : HcclResult TopoinfoRanktableHeterog::CheckMode(std::string& mode) const
251 : {
252 0 : if (mode == "tcp" || mode == "rdma") {
253 0 : return HCCL_SUCCESS;
254 : }
255 0 : HCCL_ERROR(
256 : "[Get][RanktableInfo]errNo[0x%016llx] mode[%s] is not supported, support for [tcp] and [rdma]",
257 : HCOM_ERROR_CODE(HCCL_E_PARA), mode.c_str());
258 0 : return HCCL_E_PARA;
259 : }
260 :
261 0 : HcclResult TopoinfoRanktableHeterog::CheckHeterogSubVersion(std::string& subVersion) const
262 : {
263 0 : if (subVersion == "1.2") {
264 0 : return HCCL_SUCCESS;
265 : }
266 :
267 0 : HCCL_ERROR(
268 : "[Get][RanktableInfo]errNo[0x%016llx] subVersion[%s] is not supported, support for 1.2",
269 : HCOM_ERROR_CODE(HCCL_E_PARA), subVersion.c_str());
270 0 : return HCCL_E_PARA;
271 : }
272 :
273 0 : HcclResult TopoinfoRanktableHeterog::GetHostPort(const u32& localRank, u32& hostPort)
274 : {
275 0 : u32 basePort = (GetExternalInputHcclIfBasePort() == HCCL_INVALID_PORT) ? HOST_PARA_BASE_PORT :
276 0 : GetExternalInputHcclIfBasePort();
277 0 : hostPort = basePort + localRank;
278 0 : CHK_PRT_RET(hostPort > MAX_PORT_ID, HCCL_ERROR("[Get][HostPort]invalid port id[%u]", hostPort), HCCL_E_INTERNAL);
279 0 : if (hostPortMap_.find(hostPort) == hostPortMap_.end()) {
280 0 : return HCCL_SUCCESS;
281 : }
282 0 : while (hostPortMap_[hostPort] == HOST_PORT_USED) {
283 0 : hostPort++;
284 0 : CHK_PRT_RET(
285 : hostPort > MAX_PORT_ID, HCCL_ERROR("[Get][HostPort]invalid port id[%u]", hostPort), HCCL_E_INTERNAL);
286 : }
287 0 : return HCCL_SUCCESS;
288 : }
289 :
290 0 : HcclResult TopoinfoRanktableHeterog::GetRanks(
291 : const nlohmann::json& NodeListObj, u32 objIndex, RankTable_t& clusterInfo, std::string& serverId, u32& serverIdx,
292 : HcclIpAddress& nodeIp)
293 : {
294 0 : HCCL_DEBUG("Get Node[%u]: nodeAddr:[%s], nodeIdx:[%u]", objIndex, serverId.c_str(), serverIdx);
295 : // 获取信息
296 0 : nlohmann::json Ranks;
297 0 : CHK_RET(GetJsonArrayMemberProperty(NodeListObj, objIndex, "ranks", Ranks, false));
298 :
299 0 : HCCL_DEBUG("[%s.json] -> rank_list: size:%zu", fileName_.c_str(), Ranks.size());
300 0 : CHK_PRT_RET(Ranks.size() == 0, HCCL_ERROR("[Get][Ranks]Ranks size is zero"), HCCL_E_PARA);
301 :
302 : // 91093的GetSingleRank单独操作
303 0 : if (is91093_) {
304 0 : for (u32 index = 0; index < Ranks.size(); index++) {
305 0 : CHK_RET(GetSingleRank91093(Ranks, index, clusterInfo, serverId, serverIdx, nodeIp));
306 : }
307 : } else {
308 : // 获取单rank信息
309 0 : for (u32 index = 0; index < Ranks.size(); index++) {
310 0 : CHK_RET(GetSingleRank(Ranks, index, clusterInfo, serverId, serverIdx, nodeIp));
311 : }
312 : }
313 :
314 : // 重新分配host port
315 0 : for (auto& rankInfo : clusterInfo.rankList) {
316 0 : if (rankInfo.hostPort == HCCL_INVALID_PORT) {
317 0 : CHK_RET(GetHostPort(rankInfo.localRank, rankInfo.hostPort));
318 : }
319 0 : HCCL_DEBUG("rank id: %u localRank:%u host port: %u", rankInfo.rankId, rankInfo.localRank, rankInfo.hostPort);
320 : }
321 0 : hostPortMap_.clear();
322 0 : return HCCL_SUCCESS;
323 0 : }
324 :
325 : HcclResult
326 0 : TopoinfoRanktableHeterog::GetSingleNode(const nlohmann::json& NodeListObj, u32 objIndex, RankTable_t& clusterInfo)
327 : {
328 : // 获取信息
329 : HcclResult ret;
330 0 : std::string nodeAddr;
331 0 : std::string serverId;
332 0 : CHK_RET(GetJsonArrayMemberProperty(NodeListObj, objIndex, "node_addr", nodeAddr, false));
333 : // 将serverId添加到资源池,内部会进行IP地址校验，如果资源池中有serverId，则报错
334 0 : serverId = nodeAddr;
335 0 : CHK_RET(CheckUniqueAndInsertPool(
336 : JsonUniqueInfoType::UNIQUE_INFO_TYPE_SERVER_ID, serverId, JsonCheckOpType::CHECK_OP_TYPE_INSERT));
337 : // 设置serverIdx
338 : u32 serverIdx;
339 0 : GenerateServerIdx(serverId, serverIdx);
340 :
341 : // 计算node ip
342 0 : HcclIpAddress nodeIp;
343 0 : CHK_RET(ConvertIpAddress(nodeAddr, nodeIp));
344 :
345 : // 处理ranklist
346 0 : ret = GetRanks(NodeListObj, objIndex, clusterInfo, serverId, serverIdx, nodeIp);
347 0 : CHK_PRT_RET(
348 : ret != HCCL_SUCCESS, HCCL_ERROR("[Get][GetRanks]get rank list error:nodeAddr:[%s]", serverId.c_str()), ret);
349 0 : return HCCL_SUCCESS;
350 0 : }
351 :
352 : // 91093暂定所有字段都是必选字段。除了ranks里面的 bind_device_id
353 0 : HcclResult TopoinfoRanktableHeterog::GetSingleRank91093(
354 : const nlohmann::json& ranksObj, u32 objIndex, RankTable_t& clusterInfo, std::string& serverId, u32& serverIdx,
355 : HcclIpAddress& nodeIp)
356 : {
357 0 : HCCL_INFO("Entry-GetSingleRank91093");
358 0 : std::string rankId;
359 0 : CHK_RET(GetJsonArrayMemberProperty(ranksObj, objIndex, "rank_id", rankId, false));
360 :
361 0 : s32 devicePhyId = 0;
362 0 : std::string devPhyIdStr;
363 0 : CHK_RET(GetJsonArrayMemberProperty(ranksObj, objIndex, "device_id", devPhyIdStr, false));
364 0 : CHK_RET(SalStrToInt(devPhyIdStr, HCCL_BASE_DECIMAL, devicePhyId));
365 :
366 0 : s32 port = HCCL_INVALID_PORT;
367 0 : std::string portStr;
368 0 : CHK_RET(GetJsonArrayMemberProperty(ranksObj, objIndex, "port", portStr, false));
369 0 : CHK_RET(SalStrToInt(portStr, HCCL_BASE_DECIMAL, port));
370 :
371 : // 如果device没有网卡，则缺省，通信使用node_addr
372 0 : HcclIpAddress rankIp;
373 0 : std::string rankIpStr;
374 0 : CHK_RET(GetJsonArrayMemberProperty(ranksObj, objIndex, "rank_ip", rankIpStr, false));
375 0 : if (rankIpStr.empty()) {
376 0 : rankIp = nodeIp;
377 : } else {
378 0 : CHK_RET(ConvertIpAddress(rankIpStr, rankIp));
379 : }
380 :
381 0 : s32 sdid = 0;
382 0 : std::string sdidStr;
383 0 : CHK_RET(GetJsonArrayMemberProperty(ranksObj, objIndex, "sdid", sdidStr, false));
384 0 : CHK_RET(SalStrToInt(sdidStr, HCCL_BASE_DECIMAL, sdid));
385 :
386 : // 如果deviceId == -1, 则去获取可选字段
387 0 : s32 bindDeviceId = -1;
388 0 : std::string bindDeviceIdStr;
389 0 : if (devicePhyId == HOST_DEVICE_ID) {
390 0 : CHK_RET(GetJsonArrayMemberProperty(ranksObj, objIndex, "bind_device_id", bindDeviceIdStr, false));
391 0 : CHK_RET(SalStrToInt(bindDeviceIdStr, HCCL_BASE_DECIMAL, bindDeviceId));
392 : }
393 :
394 : // rankList
395 0 : RankInfo_t rankInfo;
396 0 : rankInfo.localRank = objIndex;
397 0 : rankInfo.serverId = serverId;
398 0 : rankInfo.serverIdx = serverIdx;
399 0 : rankInfo.hostIp = nodeIp;
400 0 : rankInfo.superDeviceId = sdid;
401 0 : rankInfo.bindDeviceId = bindDeviceId;
402 0 : rankInfo.deviceInfo.devicePhyId = devicePhyId;
403 0 : rankInfo.deviceInfo.port = port;
404 0 : rankInfo.deviceInfo.deviceIp.push_back(rankIp);
405 :
406 0 : std::string errormessage = "";
407 0 : if (SalStrToULong(rankId, HCCL_BASE_DECIMAL, rankInfo.rankId) != HCCL_SUCCESS) {
408 0 : errormessage = "Value [" + rankId
409 0 : + "] for rankTable variable [rank_id] is invalid, expected value is a non-negative integer.";
410 0 : HCCL_ERROR(
411 : "[%s][%s]errNo[0x%016llx] [%s]", LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_RANKTABLE_CHECK.c_str(),
412 : HCOM_ERROR_CODE(HCCL_E_PARA), errormessage.c_str());
413 0 : return HCCL_E_PARA;
414 : }
415 :
416 0 : rankInfo.podName = ""; // podname在新场景下置空
417 : // ranktable中port无效，设置为环境变量HCCL_IF_BASE_PORT+该rank的local_rank_id,否则按照配置的port使用
418 0 : if (port == 0) {
419 0 : rankInfo.hostPort = HCCL_INVALID_PORT;
420 : } else {
421 0 : rankInfo.hostPort = port;
422 0 : hostPortMap_[rankInfo.hostPort] = HOST_PORT_USED;
423 : }
424 0 : clusterInfo.rankList.push_back(rankInfo);
425 0 : HCCL_DEBUG("[%s.json]->rankId[%u], nodeAddr[%s]", fileName_.c_str(), rankInfo.rankId, rankInfo.serverId.c_str());
426 :
427 0 : return HCCL_SUCCESS;
428 0 : }
429 :
430 0 : HcclResult TopoinfoRanktableHeterog::GetSingleRank(
431 : const nlohmann::json& ranksObj, u32 objIndex, RankTable_t& clusterInfo, std::string& serverId, u32& serverIdx,
432 : HcclIpAddress& nodeIp)
433 : {
434 : // 获取rank_id
435 0 : std::string rankId;
436 0 : CHK_RET(GetJsonArrayMemberProperty(ranksObj, objIndex, "rank_id", rankId, false));
437 :
438 0 : s32 devicePhyId = 0;
439 0 : std::string devPhyIdStr;
440 0 : if (GetJsonArrayMemberProperty(ranksObj, objIndex, "device_id", devPhyIdStr, true) == HCCL_E_NOT_FOUND) {
441 0 : devicePhyId = HOST_DEVICE_ID;
442 : } else {
443 0 : HCCL_DEBUG("[Get][GetRanks]device_id:[%s]", devPhyIdStr.c_str());
444 0 : CHK_RET(SalStrToInt(devPhyIdStr, HCCL_BASE_DECIMAL, devicePhyId));
445 : }
446 :
447 0 : s32 port = HCCL_INVALID_PORT;
448 0 : std::string portStr;
449 0 : if (GetJsonArrayMemberProperty(ranksObj, objIndex, "port", portStr, true) == HCCL_E_NOT_FOUND) {
450 0 : port = HCCL_INVALID_PORT;
451 : } else {
452 0 : CHK_RET(SalStrToInt(portStr, HCCL_BASE_DECIMAL, port));
453 : }
454 :
455 : // 如果device没有网卡，则缺省，通信使用node_addr
456 0 : HcclIpAddress rankIp;
457 0 : std::string rankIpStr;
458 0 : if (GetJsonArrayMemberProperty(ranksObj, objIndex, "rank_ip", rankIpStr, true) == HCCL_E_NOT_FOUND) {
459 0 : rankIp = nodeIp;
460 : } else {
461 0 : if (rankIpStr.empty()) {
462 0 : rankIp = nodeIp;
463 : } else {
464 0 : CHK_RET(ConvertIpAddress(rankIpStr, rankIp));
465 : }
466 : }
467 :
468 : // rankList
469 0 : RankInfo_t rankInfo;
470 0 : rankInfo.localRank = objIndex;
471 0 : rankInfo.serverId = serverId;
472 0 : rankInfo.serverIdx = serverIdx;
473 0 : rankInfo.hostIp = nodeIp;
474 0 : rankInfo.deviceInfo.devicePhyId = devicePhyId;
475 0 : rankInfo.deviceInfo.port = port;
476 0 : rankInfo.deviceInfo.deviceIp.push_back(rankIp);
477 0 : std::string errormessage = "";
478 0 : if (SalStrToULong(rankId, HCCL_BASE_DECIMAL, rankInfo.rankId) != HCCL_SUCCESS) {
479 0 : errormessage = "Value [" + rankId
480 0 : + "] for rankTable variable [rank_id] is invalid, expected value is a non-negative integer.";
481 0 : HCCL_ERROR(
482 : "[%s][%s]errNo[0x%016llx] [%s]", LOG_KEYWORDS_INIT_GROUP.c_str(), LOG_KEYWORDS_RANKTABLE_CHECK.c_str(),
483 : HCOM_ERROR_CODE(HCCL_E_PARA), errormessage.c_str());
484 0 : return HCCL_E_PARA;
485 : }
486 0 : rankInfo.podName = ""; // podname在新场景下置空
487 : // ranktable中port无效，设置为环境变量HCCL_IF_BASE_PORT+该rank的local_rank_id,否则按照配置的port使用
488 0 : if (port == 0) {
489 0 : rankInfo.hostPort = HCCL_INVALID_PORT;
490 : } else {
491 0 : rankInfo.hostPort = port;
492 0 : hostPortMap_[rankInfo.hostPort] = HOST_PORT_USED;
493 : }
494 0 : clusterInfo.rankList.push_back(rankInfo);
495 0 : HCCL_DEBUG("[%s.json]->rankId[%u], nodeAddr[%s]", fileName_.c_str(), rankInfo.rankId, rankInfo.serverId.c_str());
496 :
497 0 : return HCCL_SUCCESS;
498 0 : }
|
