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 "coll_reduce_ring_for_910_93_executor.h"
12 :
13 : namespace hccl {
14 :
15 0 : CollReduceRingFor91093Executor::CollReduceRingFor91093Executor(
16 0 : const HcclDispatcher dispatcher, std::unique_ptr<TopoMatcher>& topoMatcher)
17 0 : : CollReduceExecutor(dispatcher, topoMatcher)
18 : {
19 0 : desc_.deterministic = 1;
20 0 : }
21 :
22 0 : HcclResult CollReduceRingFor91093Executor::CalcStreamNum(u32& streamNum)
23 : {
24 : // DoubleRing只支持910_93场景
25 0 : u32 totalStreamNum
26 0 : = (topoType_ == TopoType::TOPO_TYPE_NP_DOUBLE_RING ? LEVEL0_PLANE_NUM_IN_NPRING_DOUBLE :
27 : LEVEL0_PLANE_NUM_IN_NPRING_SINGLE);
28 0 : if (workflowMode_ == HcclWorkflowMode::HCCL_WORKFLOW_MODE_OP_BASE) {
29 0 : totalStreamNum *= STREAM_NUM_FOR_DMAREDUCE_ONE_RING;
30 : }
31 0 : streamNum = totalStreamNum - 1;
32 0 : HCCL_INFO("[CollReduceRingFor91093Executor][CalcStreamNum] tag[%s] streamNum_[%u]", tag_.c_str(), streamNum);
33 0 : return HCCL_SUCCESS;
34 : }
35 :
36 0 : HcclResult CollReduceRingFor91093Executor::CalcCommInfo(std::vector<LevelNSubCommTransport>& opTransport)
37 : {
38 0 : TransportMemType inputType = TransportMemType::RESERVED;
39 0 : TransportMemType outputType = TransportMemType::RESERVED;
40 0 : CalcTransportMemType(inputType, outputType);
41 0 : CHK_RET(CalcLevel0CommInfo(inputType, outputType, opTransport));
42 0 : CHK_RET(CalcLevel1CommInfo(inputType, outputType, opTransport));
43 0 : CHK_RET(CalcLevel2CommInfo(inputType, outputType, opTransport));
44 0 : return HCCL_SUCCESS;
45 : }
46 :
47 : HcclResult
48 0 : CollReduceRingFor91093Executor::CalcTransportMemType(TransportMemType& inputType, TransportMemType& outputType)
49 : {
50 0 : if (workflowMode_ == HcclWorkflowMode::HCCL_WORKFLOW_MODE_OP_BASE) {
51 0 : inputType = TransportMemType::CCL_INPUT;
52 0 : outputType = TransportMemType::CCL_OUTPUT;
53 : } else {
54 0 : inputType = TransportMemType::PARAM_INPUT;
55 0 : outputType = TransportMemType::PARAM_OUTPUT;
56 : }
57 0 : HCCL_INFO(
58 : "[CollReduceRingFor91093Executor][CalcTransportMemType] tag[%s] inputType[%d], outputType[%d]", tag_.c_str(),
59 : inputType, outputType);
60 0 : return HCCL_SUCCESS;
61 : }
62 :
63 0 : HcclResult CollReduceRingFor91093Executor::CalcLevel0CommInfo(
64 : TransportMemType inputType, TransportMemType outputType, std::vector<LevelNSubCommTransport>& opTransport)
65 : {
66 0 : HCCL_INFO("[CollReduceRingFor91093Executor][CalcLevel0CommInfo]tag[%s] start.", tag_.c_str());
67 0 : CommParaInfo commParaLevel0(COMM_LEVEL0, CommType::COMM_TAG_RING_INNER);
68 0 : CHK_RET(CalcCommPlaneInfo(tag_, commParaLevel0, opTransport[COMM_LEVEL0], inputType, outputType));
69 0 : HCCL_INFO("[CollReduceRingFor91093Executor][CalcLevel0CommInfo]tag[%s] Calc RingComm finish.", tag_.c_str());
70 0 : return HCCL_SUCCESS;
71 0 : }
72 :
73 0 : HcclResult CollReduceRingFor91093Executor::CalcLevel1CommInfo(
74 : TransportMemType inputType, TransportMemType outputType, std::vector<LevelNSubCommTransport>& opTransport)
75 : {
76 0 : CommParaInfo commParaLevel1(COMM_LEVEL1, CommType::COMM_TAG_RING_INNER);
77 0 : if (algType_.algoLevel1 == AlgTypeLevel1::ALG_LEVEL1_RING) {
78 0 : commParaLevel1.commType = CommType::COMM_TAG_RING_INNER;
79 : } else {
80 0 : commParaLevel1.commType = CommType::COMM_TAG_HALVING_DOUBLING;
81 : }
82 0 : CHK_RET(CalcCommPlaneInfo(tag_, commParaLevel1, opTransport[COMM_LEVEL1], inputType, outputType));
83 0 : HCCL_INFO("[CollReduceRingFor91093Executor][CalcLevel1CommInfo]tag[%s] Calc Level1Comm finish.", tag_.c_str());
84 0 : return HCCL_SUCCESS;
85 0 : }
86 :
87 0 : HcclResult CollReduceRingFor91093Executor::CalcLevel2CommInfo(
88 : TransportMemType inputType, TransportMemType outputType, std::vector<LevelNSubCommTransport>& opTransport)
89 : {
90 0 : CommParaInfo commParaLevel2(COMM_LEVEL2, CommType::COMM_TAG_MAX, root_);
91 0 : if (algType_.algoLevel2 == AlgTypeLevel2::ALG_LEVEL2_RING) {
92 0 : commParaLevel2.commType = CommType::COMM_TAG_RING_INNER;
93 : } else {
94 0 : commParaLevel2.commType = CommType::COMM_TAG_HALVING_DOUBLING;
95 : }
96 0 : CHK_RET(CalcCommPlaneInfo(tag_, commParaLevel2, opTransport[COMM_LEVEL2], inputType, outputType));
97 0 : HCCL_INFO("[CollReduceRingFor91093Executor][CalcLevel2CommInfo]tag[%s] Calc Level2Comm finish.", tag_.c_str());
98 0 : return HCCL_SUCCESS;
99 0 : }
100 :
101 0 : HcclResult CollReduceRingFor91093Executor::KernelRun(const OpParam& param, ExecMem& execMem)
102 : {
103 0 : HCCL_CONFIG_INFO(HCCL_ALG, "[%s] The CollReduceRingFor91093Executor starts.", __func__);
104 0 : u32 perDataSize = 0;
105 0 : CHK_RET(SalGetDataTypeSize(param.DataDes.dataType, perDataSize));
106 0 : CHK_PRT_RET(
107 : perDataSize == 0,
108 : HCCL_ERROR(
109 : "[CollReduceRingFor91093Executor][KernelRun]errNo[0x%01611x] datatype[%d] is invalid",
110 : HCCL_ERROR_CODE(HCCL_E_PARA), param.DataDes.dataType),
111 : HCCL_E_PARA);
112 0 : std::vector<Slice> dataSegsSlice; // 数据分成ranksize份，每份的起始偏移和大小
113 0 : std::vector<std::vector<Slice>> multiRingsSliceZero; // 数据基于该rank上环0的偏移
114 0 : u32 ringNum = LEVEL0_PLANE_NUM_IN_NPRING_SINGLE;
115 0 : if (topoType_ == TopoType::TOPO_TYPE_NP_DOUBLE_RING) {
116 0 : ringNum = LEVEL0_PLANE_NUM_IN_NPRING_DOUBLE;
117 : }
118 :
119 0 : CHK_RET(CheckCommSize(COMM_LEVEL0, COMM_INDEX_0 + 1));
120 0 : SubCommInfo level0CommInfo = GetSubCommInfo(COMM_LEVEL0, COMM_INDEX_0);
121 0 : u32 sliceNum = level0CommInfo.localRankSize;
122 : // 根据数据量计算每个环上数据的偏移和大小
123 0 : CHK_RET(AlgTemplateBase::PrepareSliceData(execMem.count, perDataSize, sliceNum, 0, dataSegsSlice));
124 :
125 : /* 三步算法step1：外层 - 节点内 reduce-scatter */
126 0 : if (topoType_ == TopoType::TOPO_TYPE_NP_DOUBLE_RING) {
127 0 : multiRingsSliceZero = PrepareMultiRingSlice(dataSegsSlice, param.tag, false, topoAttr_.nicList);
128 : } else {
129 0 : multiRingsSliceZero.push_back(dataSegsSlice);
130 : }
131 :
132 0 : CHK_PRT_RET(
133 : multiRingsSliceZero.size() != ringNum,
134 : HCCL_ERROR(
135 : "[CollReduceRingFor91093Executor][Run]"
136 : "ringNum[%u] != multiRingsSliceZero size[%llu]",
137 : ringNum, multiRingsSliceZero.size()),
138 : HCCL_E_INTERNAL);
139 :
140 0 : HcomCollOpInfo* reduceScatterOpInfoPtr = nullptr;
141 :
142 0 : CHK_RET(MultiRingReduceScatter(
143 : param.tag, execMem.inputMem, execMem.outputMem, execMem.count, param.DataDes.dataType, param.reduceType,
144 : multiRingsSliceZero, param.stream, PROF_STAGE_0, 0, reduceScatterOpInfoPtr));
145 0 : HCCL_INFO("[CollReduceRingFor91093Executor]reduce double ring stage0 run success.");
146 :
147 : // step2: 节点间的reduce
148 0 : u64 hdSize = 0;
149 0 : u32 commIndex = 0;
150 0 : u32 segmentIdx = 0;
151 0 : CHK_RET(PrepareLevel1CommInfo(segmentIdx, commIndex, hdSize, level0CommInfo, multiRingsSliceZero, param.tag));
152 0 : u64 hdCount = hdSize / perDataSize;
153 0 : if (topoAttr_.superPodNum <= 1) {
154 0 : DeviceMem reduceInput = execMem.inputMem.range(dataSegsSlice[segmentIdx].offset, hdSize);
155 0 : CHK_SMART_PTR_NULL(reduceInput);
156 0 : DeviceMem reduceOutput = execMem.outputMem.range(dataSegsSlice[segmentIdx].offset, hdSize);
157 0 : CHK_SMART_PTR_NULL(reduceOutput);
158 :
159 0 : CHK_RET(CheckCommSize(COMM_LEVEL1, commIndex + 1));
160 0 : SubCommInfo level1CommInfo = GetSubCommInfo(COMM_LEVEL1, commIndex);
161 :
162 0 : u64 reduceAttr = GetReduceAttr(reduceInput, reduceOutput, param.DataDes.dataType, param.reduceType);
163 0 : std::unique_ptr<AlgTemplateBase> level1TempAlg;
164 0 : if (algType_.algoLevel1 == AlgTypeLevel1::ALG_LEVEL1_RING) {
165 : level1TempAlg
166 0 : = AlgTemplateRegistry::Instance().GetAlgTemplate(TemplateType::TEMPLATE_REDUCE_RING, dispatcher_);
167 0 : HCCL_CONFIG_INFO(HCCL_ALG, "[%s] Run TEMPLATE_REDUCE_RING in COMM_LEVEL1", __func__);
168 : } else {
169 0 : level1TempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
170 0 : TemplateType::TEMPLATE_REDUCE_RECURSIVE_HALVING_DOUBLING, dispatcher_);
171 0 : HCCL_CONFIG_INFO(HCCL_ALG, "[%s] Run TEMPLATE_REDUCE_RECURSIVE_HALVING_DOUBLING in COMM_LEVEL1", __func__);
172 : }
173 0 : CHK_SMART_PTR_NULL(level1TempAlg);
174 0 : CHK_RET(level1TempAlg->Prepare(reduceAttr));
175 :
176 0 : u32 rankSize = level1CommInfo.localRankSize;
177 0 : u32 subUserrankRoot = topoMatcher_->GetSubRootUserRank(topoAttr_.userRank, param.root);
178 0 : CHK_PRT_RET(
179 : subUserrankRoot == INVALID_VALUE_RANKID,
180 : HCCL_ERROR(
181 : "[CollReduceRingFor91093Executor]subUserrankRoot[%u] is invalid,userRank[%u],root[%u]", subUserrankRoot,
182 : topoAttr_.userRank, param.root),
183 : HCCL_E_INTERNAL);
184 0 : u32 planeRoot = 0;
185 0 : CHK_RET(GetRankByUserRank(COMM_LEVEL1, commIndex, subUserrankRoot, planeRoot));
186 : // 节点间的hd 使用环0来记录
187 0 : CHK_RET(level1TempAlg->Prepare(
188 : reduceInput, reduceOutput, reduceOutput, hdCount, param.DataDes.dataType, param.stream, param.reduceType,
189 : planeRoot, std::vector<Slice>(0), dataSegsSlice[segmentIdx].offset));
190 0 : CHK_RET(level1TempAlg->RegisterProfiler(
191 : (rankSize << PROF_RANKSIZE_OFFSET_OF_PLANEID) + level1CommInfo.localRank, PROF_STAGE_1,
192 : HCCL_EXEC_STEP_NOT_SET, param.stream));
193 0 : CHK_RET(RunTemplate(level1TempAlg, level1CommInfo));
194 0 : } else {
195 : // 节点间 reduce scatter
196 0 : CHK_RET(CheckCommSize(COMM_LEVEL1, commIndex + 1));
197 0 : SubCommInfo level1CommInfo = GetSubCommInfo(COMM_LEVEL1, commIndex);
198 0 : u32 level1RankSize = level1CommInfo.localRankSize;
199 0 : u64 level1Offset = dataSegsSlice[segmentIdx].offset;
200 0 : CHK_RET(AlgTemplateBase::PrepareSliceData(hdCount, perDataSize, level1RankSize, 0, dataSegsSlice));
201 :
202 0 : DeviceMem reducescatterInput = execMem.inputMem.range(level1Offset, hdSize);
203 0 : CHK_SMART_PTR_NULL(reducescatterInput);
204 0 : DeviceMem reducescatterOutput = execMem.outputMem.range(level1Offset, hdSize);
205 0 : CHK_SMART_PTR_NULL(reducescatterOutput);
206 :
207 0 : if (level1RankSize > 1) {
208 : u64 reduceAttr
209 0 : = GetReduceAttr(reducescatterInput, reducescatterOutput, param.DataDes.dataType, param.reduceType);
210 0 : std::unique_ptr<AlgTemplateBase> level1RSTempAlg;
211 0 : if (algType_.algoLevel1 == AlgTypeLevel1::ALG_LEVEL1_RING) {
212 0 : level1RSTempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
213 0 : TemplateType::TEMPLATE_REDUCESCATTER_RING, dispatcher_);
214 0 : CHK_SMART_PTR_NULL(level1RSTempAlg);
215 0 : CHK_RET(level1RSTempAlg->Prepare(reduceAttr));
216 0 : HCCL_CONFIG_INFO(HCCL_ALG, "[%s] Run TEMPLATE_REDUCESCATTER_RING in COMM_LEVEL1", __func__);
217 : } else {
218 0 : HCCL_ERROR(
219 : "[CollReduceRingFor91093Executor][superpod]ReduceScatter: algType_[%u] is not supported.",
220 : algType_.algoLevel1);
221 0 : return HCCL_E_NOT_SUPPORT;
222 : }
223 :
224 0 : CHK_RET(level1RSTempAlg->Prepare(
225 : reducescatterInput, reducescatterInput, reducescatterOutput, hdCount, param.DataDes.dataType,
226 : param.stream, param.reduceType, LEVEL0_BRIDGE_RANK_ID, dataSegsSlice, level1Offset));
227 :
228 0 : CHK_RET(level1RSTempAlg->RegisterProfiler(
229 : (level1RankSize << PROF_RANKSIZE_OFFSET_OF_PLANEID) + level1CommInfo.localRank, PROF_STAGE_1,
230 : HCCL_EXEC_STEP_NOT_SET, param.stream));
231 :
232 0 : CHK_RET(RunTemplate(level1RSTempAlg, level1CommInfo));
233 0 : HCCL_INFO("[CollReduceRingFor91093Executor][superpod] level1 ReduceScatter run success.");
234 0 : }
235 :
236 : // 超节点 reduce
237 0 : SubCommInfo level2CommInfo = GetSubCommInfo(COMM_LEVEL2, COMM_INDEX_0);
238 0 : CHK_RET(CheckCommSize(COMM_LEVEL2, COMM_INDEX_0 + 1));
239 0 : u32 rankSize = level2CommInfo.localRankSize;
240 0 : u32 localRank = level1CommInfo.localRank;
241 0 : u32 subUserrankRootSupperPod = topoMatcher_->GetSubRootUserRankWithSuperPod(topoAttr_.userRank, param.root);
242 0 : u32 planeRootSupperPod = 0;
243 0 : CHK_RET(GetRankByUserRank(COMM_LEVEL2, COMM_INDEX_0, subUserrankRootSupperPod, planeRootSupperPod));
244 0 : HCCL_INFO(
245 : "[CollReduceRingFor91093Executor][superpod]subUserRankRootSupperPod:[%u], planeRootSupperPod:[%u].",
246 : subUserrankRootSupperPod, planeRootSupperPod);
247 : DeviceMem reduceInput
248 0 : = reducescatterInput.range(dataSegsSlice[localRank].offset, dataSegsSlice[localRank].size);
249 0 : CHK_SMART_PTR_NULL(reduceInput);
250 : DeviceMem reduceOutput
251 0 : = reducescatterOutput.range(dataSegsSlice[localRank].offset, dataSegsSlice[localRank].size);
252 0 : CHK_SMART_PTR_NULL(reduceOutput);
253 :
254 0 : u64 reduceAttr = GetReduceAttr(reduceInput, reduceOutput, param.DataDes.dataType, param.reduceType);
255 0 : std::unique_ptr<AlgTemplateBase> level1RTempAlg;
256 0 : if (algType_.algoLevel2 == AlgTypeLevel2::ALG_LEVEL2_RING) {
257 : level1RTempAlg
258 0 : = AlgTemplateRegistry::Instance().GetAlgTemplate(TemplateType::TEMPLATE_REDUCE_RING, dispatcher_);
259 0 : HCCL_CONFIG_INFO(HCCL_ALG, "[%s] Run TEMPLATE_REDUCE_RING in COMM_LEVEL2", __func__);
260 : } else {
261 0 : level1RTempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
262 0 : TemplateType::TEMPLATE_REDUCE_RECURSIVE_HALVING_DOUBLING, dispatcher_);
263 0 : HCCL_CONFIG_INFO(HCCL_ALG, "[%s] Run TEMPLATE_REDUCE_RECURSIVE_HALVING_DOUBLING in COMM_LEVEL2", __func__);
264 : }
265 0 : CHK_SMART_PTR_NULL(level1RTempAlg);
266 0 : CHK_RET(level1RTempAlg->Prepare(reduceAttr));
267 0 : u64 arCount = dataSegsSlice[localRank].size / perDataSize;
268 :
269 0 : CHK_RET(level1RTempAlg->Prepare(
270 : reduceInput, reduceOutput, reduceOutput, arCount, param.DataDes.dataType, param.stream, param.reduceType,
271 : planeRootSupperPod, std::vector<Slice>(0), dataSegsSlice[localRank].offset + level1Offset));
272 :
273 0 : CHK_RET(level1RTempAlg->RegisterProfiler(
274 : (rankSize << PROF_RANKSIZE_OFFSET_OF_PLANEID) + level2CommInfo.localRank, PROF_STAGE_1,
275 : HCCL_EXEC_STEP_NOT_SET, param.stream));
276 0 : CHK_RET(RunTemplate(level1RTempAlg, level2CommInfo));
277 0 : HCCL_INFO("[CollReduceRingFor91093Executor][superpod] level2 reduce run success.");
278 : // 节点间 gather
279 0 : u32 subUserrankRoot = topoMatcher_->GetSubRootUserRank(topoAttr_.userRank, param.root);
280 0 : if (level1RankSize > 1 && subUserrankRoot != INVALID_VALUE_RANKID) {
281 0 : u32 planeRoot = 0;
282 0 : CHK_RET(GetRankByUserRank(COMM_LEVEL1, commIndex, subUserrankRoot, planeRoot));
283 0 : HCCL_INFO(
284 : "[CollReduceRingFor91093Executor][superpod]inter-server subUserRankRoot:[%u], planeRoot:[%u].",
285 : subUserrankRoot, planeRoot);
286 0 : std::unique_ptr<AlgTemplateBase> level1GTempAlg;
287 0 : DeviceMem gatherInput = execMem.outputMem.range(level1Offset, hdSize);
288 0 : DeviceMem gatherOutput = execMem.outputMem.range(level1Offset, hdSize);
289 : level1GTempAlg
290 0 : = AlgTemplateRegistry::Instance().GetAlgTemplate(TemplateType::TEMPLATE_GATHER_RING, dispatcher_);
291 0 : HCCL_CONFIG_INFO(HCCL_ALG, "[%s] Run TEMPLATE_GATHER_RING in COMM_LEVEL1", __func__);
292 :
293 0 : CHK_SMART_PTR_NULL(level1GTempAlg);
294 0 : CHK_RET(level1GTempAlg->Prepare(
295 : gatherOutput, gatherOutput, gatherOutput, arCount, param.DataDes.dataType, param.stream,
296 : HcclReduceOp::HCCL_REDUCE_RESERVED, planeRoot, dataSegsSlice, level1Offset));
297 0 : CHK_RET(level1GTempAlg->RegisterProfiler(
298 : (level1RankSize << PROF_RANKSIZE_OFFSET_OF_PLANEID) + level1CommInfo.localRank, PROF_STAGE_1,
299 : HCCL_EXEC_STEP_NOT_SET, param.stream));
300 0 : CHK_RET(RunTemplate(level1GTempAlg, level1CommInfo));
301 0 : HCCL_INFO("[CollReduceRingFor91093Executor][superpod] level1 gather run success.");
302 0 : }
303 0 : }
304 :
305 : // step3: 节点内的gatherring，只有在root所在server内进行gather操作
306 : SingleSubCommTransport& level0TransportInfo
307 0 : = const_cast<SingleSubCommTransport&>(algResResp_->opTransportResponse[COMM_LEVEL0][COMM_INDEX_0]);
308 :
309 0 : if (sliceNum > 1
310 0 : && (level0TransportInfo.userRank2subCommRank.find(param.root)
311 0 : != level0TransportInfo.userRank2subCommRank.end())) {
312 0 : CHK_RET(MultiRingGather(
313 : param.tag, execMem.outputMem, execMem.outputMem, hdCount, param.DataDes.dataType, multiRingsSliceZero,
314 : param.reduceType, param.root, param.stream, PROF_STAGE_2));
315 0 : HCCL_INFO("[CollReduceRingFor91093Executor]MultiRingGather run success.");
316 : }
317 :
318 0 : HCCL_INFO("[CollReduceRingFor91093Executor]reduce double ring stage2 run success.");
319 0 : return HCCL_SUCCESS;
320 0 : }
321 0 : HcclResult CollReduceRingFor91093Executor::Getlevel1CommRank(SubCommInfo& level1CommInfo)
322 : {
323 0 : if (CheckCommSize(COMM_LEVEL2, COMM_INDEX_0 + 1) != HCCL_SUCCESS) {
324 0 : return HCCL_E_UNAVAIL;
325 : }
326 0 : level1CommInfo = GetSubCommInfo(COMM_LEVEL2, COMM_INDEX_0);
327 :
328 0 : return HCCL_SUCCESS;
329 : }
330 :
331 : HcclResult
332 0 : CollReduceRingFor91093Executor::SelectTempAlg(std::unique_ptr<AlgTemplateBase>& level1TempAlg, u32 level1RankSize)
333 : {
334 0 : if (level1RankSize > 1) {
335 0 : if (algType_.algoLevel2 == AlgTypeLevel2::ALG_LEVEL2_RING) {
336 : level1TempAlg
337 0 : = AlgTemplateRegistry::Instance().GetAlgTemplate(TemplateType::TEMPLATE_REDUCE_RING, dispatcher_);
338 0 : HCCL_INFO("[CollReduceRingFor91093Executor][superpod]reduce: using ring algo inter-server.");
339 : } else {
340 0 : level1TempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
341 0 : TemplateType::TEMPLATE_REDUCE_RECURSIVE_HALVING_DOUBLING, dispatcher_);
342 0 : HCCL_INFO("[CollReduceRingFor91093Executor][superpod]reduce: using halving-doubling algo inter-server.");
343 : }
344 0 : CHK_SMART_PTR_NULL(level1TempAlg);
345 0 : return HCCL_SUCCESS;
346 : }
347 0 : return HCCL_E_UNAVAIL;
348 : }
349 : REGISTER_EXEC("ReduceRingFor91093Executor", ReduceRingFor91093, CollReduceRingFor91093Executor);
350 :
351 : } // namespace hccl
|
