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 : #ifndef COMMON_H
12 : #define COMMON_H
13 :
14 : #include "adapter_hccp_common.h"
15 : #include "hccl_ip_address.h"
16 : #include "hccl_common.h"
17 : #include "alg_cmd_type.h"
18 : #include "transport_pub.h"
19 : #include "externalinput_pub.h"
20 : #include "template_v1_utils.h"
21 : #include "comm_utils.h"
22 :
23 : // sub stream 相关
24 : constexpr s64 HCCL_SUB_STREAM_NUM_ZERO = 0; // subStream 数量为0
25 : constexpr s64 HCCL_SUB_STREAM_NUM_DOUBLE_RING = 1; // subStream 数量为1
26 : constexpr s64 HCCL_SUB_STREAM_NUM_4P_MESH = 2; // subStream 数量为2
27 : constexpr s64 HCCL_SUB_STREAM_NUM_8P_RING = 3; // subStream 数量为3
28 : constexpr s64 HCCL_SUB_STREAM_NP_MESH = 2; // NP MESH场景下subStream数应为ranksize - 2
29 :
30 : // HCCL通信算法类型
31 : enum class HcclAlgoType {
32 : HCCL_ALGO_TYPE_DEFAULT = 0, // 默认算法，配置为此时，使用HCCL内藏算法选择逻辑
33 : HCCL_ALGO_TYPE_RING,
34 : HCCL_ALGO_TYPE_PIPELINE,
35 : HCCL_ALGO_TYPE_FULLMESH,
36 : HCCL_ALGO_TYPE_HDR,
37 : HCCL_ALGO_TYPE_PAIRWISE,
38 : HCCL_ALGO_TYPE_NHR,
39 : HCCL_ALGO_TYPE_NHR_V1,
40 : HCCL_ALGO_TYPE_NB,
41 : HCCL_ALGO_TYPE_NULL,
42 : HCCL_ALGO_TYPE_NA,
43 : HCCL_ALGO_TYPE_AHC,
44 : HCCL_ALGO_TYPE_AHC_BROKE,
45 : };
46 :
47 : // 对内拓扑算法枚举
48 : enum class AlgTypeLevel0 {
49 : ALG_LEVEL0_WHOLE_RING = 0, // 单层拓扑, 所有level均为Whole ring时，组成一个大环
50 : ALG_LEVEL0_8P_RING, // 拓扑组合0层, Ring 节点内4个固定stream
51 : ALG_LEVEL0_4P_MESH, // 拓扑组合0层, Mesh 节点内3个固定stream
52 : ALG_LEVEL0_2P_MESH, // 拓扑组合0层, Mesh
53 : ALG_LEVEL0_1P_MESH, // 拓扑组合0层, Mesh
54 : ALG_LEVEL0_4P_RING, // 拓扑组合0层, Ring
55 : ALG_LEVEL0_NP_SINGLE_RING, // 拓扑组合0层, Ring
56 : ALG_LEVEL0_NP_DOUBLE_RING, // 拓扑组合0层, double Ring
57 : ALG_LEVEL0_NP_MESH, // 拓扑组合0层, 服务器内3~8p rank组成MESH
58 : ALG_LEVEL0_NP_HD, // 拓扑组合0层, HD
59 : ALG_LEVEL0_NP_STAR,
60 : ALG_LEVEL0_PAIRWISE,
61 : ALG_LEVEL0_RESERVED
62 : };
63 :
64 : enum class AlgTypeLevel1 {
65 : ALG_LEVEL1_WHOLE_RING = 0, // 单层拓扑, 所有level均为Whole ring时，组成一个大环
66 : ALG_LEVEL1_HD, // 拓扑组合1层, HDR
67 : ALG_LEVEL1_RING, // 拓扑组合1层, Ring
68 : ALG_LEVEL1_PIPELINE, // 拓扑组合1层, Pipeline
69 : ALG_LEVEL1_STAR,
70 : ALG_LEVEL1_NHR, // 拓扑组合1层，NHR
71 : ALG_LEVEL1_NHR_V1, // 拓扑组合1层，NHR_V1
72 : ALG_LEVEL1_NB, // 拓扑组合1层，NB
73 : ALG_LEVEL1_AHC, // 拓扑组合1层，AHC
74 : ALG_LEVEL1_AHC_BROKE, // 拓扑组合1层，AHC_BROKE
75 : ALG_LEVEL1_RESERVED
76 : };
77 :
78 : enum class AlgTypeLevel2 {
79 : ALG_LEVEL2_WHOLE_RING = 0, // 单层拓扑, 所有leve2均为Whole ring时，组成一个大环
80 : ALG_LEVEL2_HD, // 拓扑组合2层, HDR
81 : ALG_LEVEL2_RING, // 拓扑组合2层, Ring
82 : ALG_LEVEL2_NHR, // 拓扑组合2层, NHR
83 : ALG_LEVEL2_NB, // 拓扑组合2层, NB
84 : ALG_LEVEL2_PIPELINE, // 拓扑组合2层, Pipeline
85 : ALG_LEVEL2_RESERVED
86 : };
87 :
88 :
89 : using AlgType = struct TagAlgType {
90 : AlgTypeLevel0 algoLevel0;
91 : AlgTypeLevel1 algoLevel1;
92 : AlgTypeLevel2 algoLevel2;
93 59311 : TagAlgType() : algoLevel0(AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING), algoLevel1(AlgTypeLevel1::ALG_LEVEL1_WHOLE_RING),
94 59311 : algoLevel2(AlgTypeLevel2::ALG_LEVEL2_WHOLE_RING)
95 : {
96 59311 : }
97 :
98 : explicit TagAlgType(AlgTypeLevel0 algoLevel0) : algoLevel0(algoLevel0), algoLevel1(AlgTypeLevel1::ALG_LEVEL1_WHOLE_RING),
99 : algoLevel2(AlgTypeLevel2::ALG_LEVEL2_WHOLE_RING)
100 : {
101 : }
102 : TagAlgType(AlgTypeLevel0 algoLevel0, AlgTypeLevel1 algoLevel1) : algoLevel0(algoLevel0),
103 : algoLevel1(algoLevel1), algoLevel2(AlgTypeLevel2::ALG_LEVEL2_WHOLE_RING)
104 : {
105 : }
106 :
107 : TagAlgType(AlgTypeLevel0 algoLevel0, AlgTypeLevel2 algoLevel2) : algoLevel0(algoLevel0),
108 : algoLevel1(AlgTypeLevel1::ALG_LEVEL1_WHOLE_RING), algoLevel2(algoLevel2)
109 : {
110 : }
111 :
112 60 : TagAlgType(AlgTypeLevel0 algoLevel0, AlgTypeLevel1 algoLevel1, AlgTypeLevel2 algoLevel2) : algoLevel0(algoLevel0),
113 60 : algoLevel1(algoLevel1), algoLevel2(algoLevel2)
114 : {
115 60 : }
116 : explicit TagAlgType(AlgTypeLevel1 algoLevel1) : algoLevel0(AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING), algoLevel1(algoLevel1),
117 : algoLevel2(AlgTypeLevel2::ALG_LEVEL2_WHOLE_RING)
118 : {
119 : }
120 :
121 : TagAlgType(AlgTypeLevel1 algoLevel1, AlgTypeLevel2 algoLevel2) : algoLevel0(AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING),
122 : algoLevel1(algoLevel1), algoLevel2(algoLevel2)
123 : {
124 : }
125 :
126 : explicit TagAlgType(AlgTypeLevel2 algoLevel2) : algoLevel0(AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING),
127 : algoLevel1(AlgTypeLevel1::ALG_LEVEL1_WHOLE_RING), algoLevel2(algoLevel2)
128 : {
129 : }
130 :
131 60 : static TagAlgType Reserved() {
132 60 : return TagAlgType(AlgTypeLevel0::ALG_LEVEL0_RESERVED, AlgTypeLevel1::ALG_LEVEL1_RESERVED, AlgTypeLevel2::ALG_LEVEL2_RESERVED);
133 : }
134 :
135 18750 : TagAlgType(const TagAlgType &that) : algoLevel0(that.algoLevel0), algoLevel1(that.algoLevel1), algoLevel2(that.algoLevel2)
136 : {
137 18750 : }
138 :
139 2486938 : TagAlgType &operator=(const TagAlgType &that)
140 : {
141 2486938 : if (&that != this) {
142 2486938 : algoLevel0 = that.algoLevel0;
143 2486938 : algoLevel1 = that.algoLevel1;
144 2486938 : algoLevel2 = that.algoLevel2;
145 : }
146 2486938 : return *this;
147 : }
148 : };
149 :
150 : namespace hccl {
151 : // 通信域内rank信息
152 : using RankInfo = struct TagRankInfo {
153 : public:
154 : /* * 用户的原始属性 */
155 : u32 userRank{INVALID_UINT}; // 当前rank的user rank ID
156 : u32 worldRank{INVALID_UINT}; // 当前rank的global user rank ID
157 : u32 localRank{INVALID_UINT}; // 当前rank在server内的rank ID
158 : s32 devicePhyId{-1}; // 当前rank在操作的设备物理编号
159 : DevType deviceType{DevType::DEV_TYPE_NOSOC}; // 当前rank在操作的设备属性
160 : std::vector<HcclIpAddress> nicIp; // 当前rank所归属网卡的IP值(实际建链所用网卡IP)
161 : std::vector<HcclIpAddress> backupNicIp; // 当前rank所在卡备用网卡的IP值
162 : u32 deviceNicPort{HCCL_INVALID_PORT}; // 当前rank使用的device socket port
163 : u32 deviceVnicPort{HCCL_INVALID_PORT}; // 当前rank使用的device socket port
164 : u32 backupDevicePort{HCCL_INVALID_PORT}; // 当前rank使用的备用网卡的device socket port
165 : std::vector<u32> nicIdx; // 当前rank在server内的所有device网卡位置（devicePhyId）
166 : NICDeployment nicDeploy{NICDeployment::NIC_DEPLOYMENT_DEVICE}; // 参数平面位置 0:host 1:device other:reserve
167 : HcclIpAddress hostIp; // 当前rank使用的host socket addr
168 : u32 hostPort{HCCL_INVALID_PORT}; // 当前rank使用的host socket port
169 : std::string serverId{""}; // 当前rank所在服务器的唯一标识值 (rank_table中的server id)
170 : u32 serverIdx{INVALID_UINT}; // Server在ranktable中的自然顺序（用户指定）
171 : u32 superDeviceId{INVALID_UINT}; // 当前rank所在的超节点内的device id（sdid）
172 : std::string superPodId{""}; // 当前rank所在超节点id
173 : u32 superPodIdx{INVALID_UINT}; // SuperPod在ranktable中的自然顺序（用户指定)
174 : HcclIpAddress deviceVnicIp; // 当前rank所归属网卡的虚拟ip // 当前rank所在通信域的server数
175 : };
176 :
177 : constexpr s64 HCCL_SMALL_COUNT_128_KB = 128 * 1024; // hccl 910B/310P duo卡单算子小数据量标准，暂定128kb
178 : constexpr s64 HCCL_SMALL_COUNT_GRAPH_64_KB = 64 * 1024; // hccl图模式小数据量标准，暂定64KB
179 : constexpr s64 HCCL_MEDIUM_COUNT_GRAPH_4_MB = 4 * 1024 * 1024; // hccl图模式中数据量标准，暂定4MB
180 : constexpr s64 HCCL_SMALL_COUNT_256_KB = 256 * 1024; // 910B/310p V卡hccl小数据量标准，暂定256KB
181 :
182 : constexpr s64 HCCL_ALIGN_COUNT_32_B = 32; // 910B aiv+rdma，中数据量情况下按照32B对齐
183 : constexpr s64 HCCL_SMALL_COUNT_190_KB = 190 * 1024; // 910B aiv+rdma，暂定从OutAIVBuffer的512K位置开始存放标记
184 : constexpr s64 HCCL_SMALL_COUNT_512_KB = 512 * 1024; // 910B aiv+rdma，暂定从OutAIVBuffer的512K位置开始存放标记
185 : constexpr s64 HCCL_SMALL_COUNT_1_MB = 1024 * 1024; // 910BB aiv+rdma，AIVIN的最后1M空间用作标记区
186 : constexpr s64 HCCL_SMALL_COUNT_2_MB = 2048 * 1024;
187 : constexpr s64 HCCL_SMALL_COUNT_4_MB = 4096 * 1024;
188 : constexpr s64 HCCL_SMALL_COUNT_8_MB = 8192 * 1024;
189 : constexpr s64 HCCL_SMALL_COUNT_16_KB = 16 * 1024; // A3打平ROCE
190 : constexpr s64 HCCL_MID_COUNT_16_MB = 16 * 1024 * 1024; // 910B aiv+rdma 中数据量支持上限
191 : constexpr s64 HCCL_MID_COUNT_32_MB = 32 * 1024 * 1024;
192 :
193 : constexpr u32 HCCL_INTER_SERVER_RING_ALGO_MAX_SUPPORT_SERVER_NUM = 8; // server 间 ring 算法支持的最大server数: 8
194 :
195 : constexpr u32 HCCL_ALLTOALLV_P2P_SIZE = 2; // alltoallv不区分全连接、分级的最大ranksize
196 :
197 : constexpr u32 HCCL_MEMSIZE_HD_FACTOR = 4;
198 :
199 : // a2a前置allgather和a2a注册的notify资源要隔离, tag不能包含HCCL_ALLTOALL字符串
200 : const std::string HCCL_ALLTOALL_PARA_ALLGATHER = "AllgatherForCollectA2APara";
201 :
202 : // 标识MC2多机的tag后缀，用于区分单机和多机MC2场景，避免资源复用出错
203 : const std::string HCCL_MC2_MULTISERVER_SUFFIX = "_MC2MultiServer";
204 :
205 : const std::map<AlgTypeLevel0, std::string> HCCL_ALGO_LEVEL0_NAME_MAP = {
206 : {AlgTypeLevel0::ALG_LEVEL0_NP_DOUBLE_RING, "ring"},
207 : {AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING, "ring"},
208 : {AlgTypeLevel0::ALG_LEVEL0_8P_RING, "ring"},
209 : {AlgTypeLevel0::ALG_LEVEL0_4P_MESH, "fullmesh"},
210 : {AlgTypeLevel0::ALG_LEVEL0_2P_MESH, "fullmesh"},
211 : {AlgTypeLevel0::ALG_LEVEL0_1P_MESH, "fullmesh"},
212 : {AlgTypeLevel0::ALG_LEVEL0_4P_RING, "ring"},
213 : {AlgTypeLevel0::ALG_LEVEL0_NP_SINGLE_RING, "ring"},
214 : {AlgTypeLevel0::ALG_LEVEL0_NP_MESH, "fullmesh"},
215 : {AlgTypeLevel0::ALG_LEVEL0_NP_HD, "HD"},
216 : {AlgTypeLevel0::ALG_LEVEL0_NP_STAR, "star"},
217 : {AlgTypeLevel0::ALG_LEVEL0_RESERVED, "null"},
218 : };
219 :
220 : const std::map<AlgTypeLevel1, std::string> HCCL_ALGO_LEVEL1_NAME_MAP = {
221 : {AlgTypeLevel1::ALG_LEVEL1_WHOLE_RING, "ring"},
222 : {AlgTypeLevel1::ALG_LEVEL1_HD, "H-D"},
223 : {AlgTypeLevel1::ALG_LEVEL1_RING, "ring"},
224 : {AlgTypeLevel1::ALG_LEVEL1_PIPELINE, "pipeline"},
225 : {AlgTypeLevel1::ALG_LEVEL1_NHR, "NHR"},
226 : {AlgTypeLevel1::ALG_LEVEL1_NHR_V1, "NHR_V1"},
227 : {AlgTypeLevel1::ALG_LEVEL1_AHC, "AHC"},
228 : {AlgTypeLevel1::ALG_LEVEL1_AHC_BROKE, "AHC_BROKE"},
229 : {AlgTypeLevel1::ALG_LEVEL1_NB, "NB"},
230 : {AlgTypeLevel1::ALG_LEVEL1_RESERVED, "null"},
231 : };
232 :
233 : const std::map<AlgTypeLevel2, std::string> HCCL_ALGO_LEVEL2_NAME_MAP = {
234 : {AlgTypeLevel2::ALG_LEVEL2_WHOLE_RING, "ring"},
235 : {AlgTypeLevel2::ALG_LEVEL2_HD, "H-D"},
236 : {AlgTypeLevel2::ALG_LEVEL2_RING, "ring"},
237 : {AlgTypeLevel2::ALG_LEVEL2_NHR, "NHR"},
238 : {AlgTypeLevel2::ALG_LEVEL2_NB, "NB"},
239 : {AlgTypeLevel2::ALG_LEVEL2_PIPELINE, "pipeline"},
240 : {AlgTypeLevel2::ALG_LEVEL2_RESERVED, "null"},
241 : };
242 :
243 : const std::map<AlgTypeLevel0, std::string> HCCL_ALGO_LEVEL0_MAP = {
244 : {AlgTypeLevel0::ALG_LEVEL0_NP_DOUBLE_RING, "RING"},
245 : {AlgTypeLevel0::ALG_LEVEL0_WHOLE_RING, "RING"},
246 : {AlgTypeLevel0::ALG_LEVEL0_8P_RING, "RING"},
247 : {AlgTypeLevel0::ALG_LEVEL0_4P_MESH, "MESH"},
248 : {AlgTypeLevel0::ALG_LEVEL0_2P_MESH, "MESH"},
249 : {AlgTypeLevel0::ALG_LEVEL0_1P_MESH, "MESH"},
250 : {AlgTypeLevel0::ALG_LEVEL0_4P_RING, "RING"},
251 : {AlgTypeLevel0::ALG_LEVEL0_NP_SINGLE_RING, "RING"},
252 : {AlgTypeLevel0::ALG_LEVEL0_NP_MESH, "MESH"},
253 : {AlgTypeLevel0::ALG_LEVEL0_NP_HD, "HD"},
254 : {AlgTypeLevel0::ALG_LEVEL0_NP_STAR, "STAR"},
255 : {AlgTypeLevel0::ALG_LEVEL0_PAIRWISE, "PAIRWISE"},
256 : {AlgTypeLevel0::ALG_LEVEL0_RESERVED, "NA"},
257 : };
258 :
259 : const std::map<AlgTypeLevel1, std::string> HCCL_ALGO_LEVEL1_MAP = {
260 : {AlgTypeLevel1::ALG_LEVEL1_WHOLE_RING, "RING"},
261 : {AlgTypeLevel1::ALG_LEVEL1_HD, "HD"},
262 : {AlgTypeLevel1::ALG_LEVEL1_RING, "RING"},
263 : {AlgTypeLevel1::ALG_LEVEL1_PIPELINE, "PIPELINE"},
264 : {AlgTypeLevel1::ALG_LEVEL1_NHR, "NHR"},
265 : {AlgTypeLevel1::ALG_LEVEL1_NHR_V1, "NHR_V1"},
266 : {AlgTypeLevel1::ALG_LEVEL1_AHC, "AHC"},
267 : {AlgTypeLevel1::ALG_LEVEL1_AHC_BROKE, "AHC_BROKE"},
268 : {AlgTypeLevel1::ALG_LEVEL1_NB, "NB"},
269 : {AlgTypeLevel1::ALG_LEVEL1_STAR, "STAR"},
270 : {AlgTypeLevel1::ALG_LEVEL1_RESERVED, "NA"},
271 : };
272 :
273 : const std::map<AlgTypeLevel2, std::string> HCCL_ALGO_LEVEL2_MAP = {
274 : {AlgTypeLevel2::ALG_LEVEL2_WHOLE_RING, "RING"},
275 : {AlgTypeLevel2::ALG_LEVEL2_HD, "HD"},
276 : {AlgTypeLevel2::ALG_LEVEL2_RING, "RING"},
277 : {AlgTypeLevel2::ALG_LEVEL2_NHR, "NHR"},
278 : {AlgTypeLevel2::ALG_LEVEL2_NB, "NB"},
279 : {AlgTypeLevel2::ALG_LEVEL2_PIPELINE, "PIPELINE"},
280 : {AlgTypeLevel2::ALG_LEVEL2_RESERVED, "NA"},
281 : };
282 :
283 13 : inline std::string TransferAlgType(AlgType algType)
284 : {
285 13 : std::string algTypeStr;
286 13 : auto level0Iter = HCCL_ALGO_LEVEL0_MAP.find(algType.algoLevel0);
287 13 : auto level1Iter = HCCL_ALGO_LEVEL1_MAP.find(algType.algoLevel1);
288 13 : auto level2Iter = HCCL_ALGO_LEVEL2_MAP.find(algType.algoLevel2);
289 13 : if (level0Iter == HCCL_ALGO_LEVEL0_MAP.end() || level1Iter == HCCL_ALGO_LEVEL1_MAP.end() || level2Iter == HCCL_ALGO_LEVEL2_MAP.end()) {
290 0 : algTypeStr = "not found";
291 0 : HCCL_WARNING("No matching algLevel0 or algLevel1 or algLevel2 is found.");
292 : } else {
293 26 : algTypeStr.append(static_cast<std::string>(level0Iter->second)).append("-").append(static_cast<std::string>(level1Iter->second))
294 13 : .append("-").append(static_cast<std::string>(level2Iter->second));
295 13 : HCCL_INFO("The algtype for profiling is [%s]", algTypeStr.c_str());
296 : }
297 :
298 13 : return algTypeStr;
299 0 : }
300 :
301 0 : inline bool TransferStrToAlgType(const std::string& algTypeStr, AlgType& algType)
302 : {
303 : // 分割字符串
304 0 : std::vector<std::string> parts;
305 0 : std::stringstream ss(algTypeStr);
306 0 : std::string part;
307 0 : constexpr u32 algTypeLevelNum = 3;
308 :
309 0 : while (std::getline(ss, part, '-')) {
310 0 : parts.push_back(part);
311 : }
312 :
313 : // 检查格式
314 0 : if (parts.size() != algTypeLevelNum) {
315 0 : HCCL_ERROR("Invalid algType string format: %s", algTypeStr.c_str());
316 0 : return false;
317 : }
318 0 : int level0Val = std::stoi(parts[0]);
319 0 : int level1Val = std::stoi(parts[1]);
320 0 : int level2Val = std::stoi(parts[2]);
321 0 : if (level0Val >= static_cast<int>(AlgTypeLevel0::ALG_LEVEL0_RESERVED) || level0Val < 0
322 0 : || level1Val >= static_cast<int>(AlgTypeLevel1::ALG_LEVEL1_RESERVED) || level1Val < 0
323 0 : || level2Val >= static_cast<int>(AlgTypeLevel2::ALG_LEVEL2_RESERVED) || level2Val < 0)
324 : {
325 0 : HCCL_ERROR("Invalid algType string format: %s", algTypeStr.c_str());
326 0 : return false;
327 : }
328 0 : algType.algoLevel0 = static_cast<AlgTypeLevel0>(level0Val);
329 0 : algType.algoLevel1 = static_cast<AlgTypeLevel1>(level1Val);
330 0 : algType.algoLevel2 = static_cast<AlgTypeLevel2>(level2Val);
331 :
332 0 : HCCL_INFO("Successfully parsed algType from string: %s", algTypeStr.c_str());
333 0 : return true;
334 0 : }
335 :
336 : } // namespace hccl
337 :
338 : enum class TopoType {
339 : TOPO_TYPE_COMMON = 0, // 普通拓扑类型 ，default单层拓扑使用
340 : TOPO_TYPE_8P_RING = 1, // 特殊场景, 服务器内8 rank组成一个ring，4个逻辑环
341 : TOPO_TYPE_4P_MESH = 2, // 特殊场景, 服务器内4 rank组成MESH
342 : TOPO_TYPE_2P_MESH = 3, // 特殊场景, 服务器内2 rank组成MESH。仅用于测试和自验证
343 : TOPO_TYPE_1P_MESH = 4, // 特殊场景, 服务器内1 rank组成MESH。仅用于测试和自验证
344 : TOPO_TYPE_4P_RING = 5, // 特殊场景，服务器内4 rank组成ring
345 : TOPO_TYPE_NP_SINGLE_RING = 6, // 特殊场景, 服务器内n rank组成单 ring。目前仅用于标卡
346 : TOPO_TYPE_8P_MESH = 7, // 特殊场景, 服务器内8 rank通过RDMA组成MESH
347 : TOPO_TYPE_NP_MESH = 8, // 特殊场景, 服务器内3~8p rank组成MESH
348 : TOPO_TYPE_NP_DOUBLE_RING = 9, // 特殊场景, 910_93场景
349 : TOPO_TYPE_HETEROG = 10,
350 : TOPO_TYPE_ES_MESH = 11,
351 : TOPO_TYPE_RESERVED
352 : };
353 :
354 : #endif /* COMMON_H */
|
