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