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