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 "log.h"
12 :
13 : #include "alg_data_trans_wrapper.h"
14 : #include "ins_alg_template/ins_temp_broadcast_nhr.h"
15 :
16 : namespace Hccl {
17 0 : InsTempBroadcastNHR::InsTempBroadcastNHR(
18 : const RankId virtualRank, const u32 tempRankSize, const std::vector<std::vector<RankId>>& tempVTopo,
19 0 : const std::map<RankId, u32>& tempVirtRankMap)
20 0 : : InsAlgTemplateBase(virtualRank, tempRankSize, tempVTopo, tempVirtRankMap)
21 0 : {}
22 :
23 0 : InsTempBroadcastNHR::~InsTempBroadcastNHR() {}
24 :
25 0 : HcclResult InsTempBroadcastNHR::CalcRes(AlgTempResReq& tempResReq)
26 : {
27 : // NHR 需要的 que Num 为 1
28 0 : tempResReq.queNum = 1;
29 0 : tempResReq.streamNum = tempResReq.queNum;
30 0 : tempResReq.queNotifys = CreateMasterSlaveQueNotifiesRequest(tempResReq.queNum);
31 0 : CHK_PRT_RET(
32 : CalcResLinksNHR(myRank_, tempRankSize_, tempVTopo_, tempResReq) != HcclResult::HCCL_SUCCESS,
33 : HCCL_ERROR("[CollAlgFactory] [InsTempBroadCastNHR] Rank [%d], resLinks calculation error!", myRank_),
34 : HcclResult::HCCL_E_INTERNAL);
35 :
36 0 : return HcclResult::HCCL_SUCCESS;
37 : }
38 :
39 0 : u32 InsTempBroadcastNHR::CalcScratchMultiple(BufferType inBuffType, BufferType outBuffType)
40 : {
41 : (void)inBuffType;
42 : (void)outBuffType;
43 0 : if (op_.opMode == OpMode::OPBASE) {
44 0 : return 1;
45 : } else {
46 0 : return 0;
47 : }
48 : }
49 :
50 : // SliceInfoVec for NHR
51 0 : HcclResult InsTempBroadcastNHR::CalcDataSliceInfo(const u64 dataSize, RankSliceInfo& sliceInfoVec)
52 : {
53 0 : AllignInfo allignInfo = {false, 0, dataType_};
54 :
55 : u64 unitAllignSize;
56 0 : CHK_RET(GetUnitAllignSize(allignInfo, unitAllignSize));
57 0 : sliceInfoVec.clear();
58 0 : sliceInfoVec.resize(tempRankSize_);
59 :
60 0 : u64 chunkSize = RoundUp(dataSize, (tempRankSize_ * unitAllignSize)) * unitAllignSize;
61 :
62 0 : u64 accumOff = 0;
63 0 : for (u32 rankIdx = 0; rankIdx < tempRankSize_; rankIdx++) {
64 0 : u64 currChunkSize = ((dataSize - accumOff) > chunkSize) ? chunkSize : (dataSize - accumOff);
65 0 : SliceInfo slice = {accumOff, currChunkSize};
66 0 : sliceInfoVec[rankIdx].push_back(slice);
67 0 : accumOff += currChunkSize;
68 : }
69 :
70 0 : CHK_PRT_RET(
71 : (sliceInfoVec[tempRankSize_ - 1][0].offset + sliceInfoVec[tempRankSize_ - 1][0].size != dataSize),
72 : HCCL_ERROR("[InsTempBroadcastNHR] Rank [%d], SliceInfo calculation error!", myRank_),
73 : HcclResult::HCCL_E_INTERNAL);
74 :
75 0 : return HcclResult::HCCL_SUCCESS;
76 : }
77 :
78 : HcclResult
79 0 : InsTempBroadcastNHR::PostCopy(const TemplateDataParams& tempAlgParams, std::vector<InsQuePtr>& tempInsQues) const
80 : {
81 0 : if (opMode_ == OpMode::OPBASE && (u32(myRank_) != root_)) {
82 0 : HCCL_INFO("[InsTempBroadcastNHR][PostCopy] Opbase && isBottom, copy from outBuff to userOut");
83 0 : u64 inOffset = tempAlgParams.buffInfo.scratchBuffBaseOff;
84 :
85 0 : DataSlice usrInSlice = DataSlice(BufferType::SCRATCH, inOffset, tempAlgParams.sliceSize);
86 : DataSlice usrOutSlice
87 0 : = DataSlice(BufferType::INPUT, tempAlgParams.buffInfo.outBuffBaseOff, tempAlgParams.sliceSize);
88 :
89 0 : HCCL_INFO(
90 : "PostCopy usrInSlice: %s, usrOutSlice: %s", usrInSlice.Describe().c_str(), usrOutSlice.Describe().c_str());
91 :
92 0 : CHK_RET(LocalCopy(tempInsQues[0], usrInSlice, usrOutSlice));
93 : } else {
94 0 : HCCL_INFO("[InsTempBroadcastNHR][PostCopy] Offload Model, skip postcopy");
95 : }
96 :
97 0 : return HcclResult::HCCL_SUCCESS;
98 : }
99 :
100 : HcclResult
101 0 : InsTempBroadcastNHR::PreCopy(const TemplateDataParams& tempAlgParams, std::vector<InsQuePtr>& tempInsQues) const
102 : {
103 0 : if (opMode_ == OpMode::OPBASE && (u32(myRank_) == root_)) {
104 : DataSlice usrInSlice
105 0 : = DataSlice(BufferType::INPUT, tempAlgParams.buffInfo.inBuffBaseOff, tempAlgParams.sliceSize);
106 : DataSlice usrOutSlice
107 0 : = DataSlice(BufferType::SCRATCH, tempAlgParams.buffInfo.scratchBuffBaseOff, tempAlgParams.sliceSize);
108 0 : CHK_PRT_RET(
109 : LocalCopy(tempInsQues[0], usrInSlice, usrOutSlice),
110 : HCCL_ERROR("[InsTempBroadcastNHR] RunScatter userIn to cclIn copy failed"),
111 :
112 : HcclResult::HCCL_E_INTERNAL);
113 : } else {
114 0 : HCCL_INFO("[InsTempBroadcastNHR][PostCopy] Offload Model, skip postcopy");
115 : }
116 :
117 0 : return HcclResult::HCCL_SUCCESS;
118 : }
119 :
120 0 : HcclResult InsTempBroadcastNHR::GetAllGatherStepInfo(u32 step, u32 nSteps, AicpuNHRStepInfo& stepInfo)
121 : {
122 0 : u32 rankIdx = tempVirtRankMap_[myRank_];
123 0 : stepInfo.txSliceIdxs.clear();
124 0 : stepInfo.rxSliceIdxs.clear();
125 0 : stepInfo.step = step;
126 0 : stepInfo.myRank = rankIdx;
127 :
128 : // 计算通信对象
129 0 : u32 deltaRank = 1 << (nSteps - 1 - step);
130 0 : u32 recvFrom = (rankIdx + tempRankSize_ - deltaRank) % tempRankSize_;
131 0 : u32 sendTo = (rankIdx + deltaRank) % tempRankSize_;
132 :
133 : // 数据份数和数据编号增量
134 0 : u32 nSlices = (tempRankSize_ - 1 + (1 << (nSteps - 1 - step))) / (1 << (nSteps - step));
135 0 : u32 deltaSliceIndex = 1 << (nSteps - step);
136 0 : u32 txSliceIdx = rankIdx;
137 0 : u32 rxSliceIdx = (rankIdx - (1 << (nSteps - 1 - step)) + tempRankSize_) % tempRankSize_;
138 :
139 0 : stepInfo.nSlices = nSlices;
140 0 : stepInfo.toRank = sendTo;
141 0 : stepInfo.fromRank = recvFrom;
142 :
143 0 : for (u32 i = 0; i < nSlices; i++) {
144 0 : stepInfo.txSliceIdxs.push_back(txSliceIdx);
145 0 : stepInfo.rxSliceIdxs.push_back(rxSliceIdx);
146 :
147 0 : HCCL_DEBUG(
148 : "[InsTempBroadcastNHR][GetStepInfoForAllGather] i[%u] txSliceIdx[%u] rxSliceIdx[%u]", i, txSliceIdx,
149 : rxSliceIdx);
150 :
151 0 : txSliceIdx = (txSliceIdx + tempRankSize_ - deltaSliceIndex) % tempRankSize_;
152 0 : rxSliceIdx = (rxSliceIdx + tempRankSize_ - deltaSliceIndex) % tempRankSize_;
153 : }
154 0 : return HcclResult::HCCL_SUCCESS;
155 : }
156 :
157 : // NHR每步的算法描述原理函数
158 0 : HcclResult InsTempBroadcastNHR::GetScatterStepInfo(u32 step, u32 nSteps, AicpuNHRStepInfo& stepInfo) const
159 : {
160 0 : u32 rankIdx = tempVirtRankMap_.at(myRank_);
161 0 : u32 rootIdx = tempVirtRankMap_.at(root_);
162 0 : u32 rankSize = tempRankSize_;
163 :
164 0 : stepInfo.txSliceIdxs.clear();
165 0 : stepInfo.rxSliceIdxs.clear();
166 0 : stepInfo.nSlices = 0;
167 0 : stepInfo.toRank = INVALID_U32;
168 0 : stepInfo.fromRank = INVALID_U32;
169 0 : stepInfo.step = step;
170 0 : stepInfo.myRank = rankIdx;
171 :
172 0 : u32 deltaRoot = (rootIdx + rankSize - rankIdx) % rankSize;
173 0 : u32 deltaRankPair = 1 << step;
174 :
175 : // 数据份数和数据编号增量
176 0 : u32 nSlices = (rankSize - 1 + (1 << step)) / (1 << (step + 1));
177 0 : u32 deltaSliceIndex = 1 << (step + 1);
178 :
179 : // 判断是否是2的幂
180 0 : u32 nRanks = 0; // 本步需要进行收/发的rank数
181 0 : bool isPerfect = (rankSize & (rankSize - 1)) == 0;
182 0 : if (!isPerfect && step == nSteps - 1) {
183 0 : nRanks = rankSize - deltaRankPair;
184 : } else {
185 0 : nRanks = deltaRankPair;
186 : }
187 :
188 0 : if (deltaRoot < nRanks) { // 需要发
189 0 : u32 sendTo = (rankIdx + rankSize - deltaRankPair) % rankSize;
190 0 : u32 txSliceIdx = sendTo;
191 0 : for (u32 i = 0; i < nSlices; i++) {
192 0 : u32 targetTxSliceIdx = txSliceIdx;
193 0 : stepInfo.txSliceIdxs.push_back(targetTxSliceIdx);
194 0 : txSliceIdx = (txSliceIdx + rankSize - deltaSliceIndex) % rankSize;
195 : }
196 :
197 0 : stepInfo.toRank = sendTo;
198 0 : stepInfo.nSlices = nSlices;
199 0 : } else if (deltaRoot >= deltaRankPair && deltaRoot < nRanks + deltaRankPair) { // 需要收
200 0 : u32 recvFrom = (rankIdx + deltaRankPair) % rankSize;
201 0 : u32 rxSliceIdx = rankIdx;
202 0 : for (u32 i = 0; i < nSlices; i++) {
203 0 : u32 targetRxSliceIdx = rxSliceIdx;
204 0 : stepInfo.rxSliceIdxs.push_back(targetRxSliceIdx);
205 0 : rxSliceIdx = (rxSliceIdx + rankSize - deltaSliceIndex) % rankSize;
206 : }
207 :
208 0 : stepInfo.fromRank = recvFrom;
209 0 : stepInfo.nSlices = nSlices;
210 : }
211 0 : return HcclResult::HCCL_SUCCESS;
212 : }
213 :
214 0 : HcclResult InsTempBroadcastNHR::RunScatter(
215 : const RankSliceInfo& sliceInfoVec, const ResLinks& tempLinks, std::vector<InsQuePtr>& tempInsQues)
216 : {
217 : // nhr主体部分,从ScratchIn计算，结果放至ScratchOut上, 该部分均从inType搬运到outType
218 0 : u32 nSteps = GetNHRStepNum(tempRankSize_);
219 0 : for (u32 step = 0; step < nSteps; step++) {
220 0 : AicpuNHRStepInfo stepInfo;
221 0 : CHK_RET(GetScatterStepInfo(step, nSteps, stepInfo));
222 0 : CHK_PRT_RET(
223 : BatchTxRx(stepInfo, tempLinks, tempInsQues[0], sliceInfoVec),
224 : HCCL_ERROR("[InsTempBroadcastNHR] BatchTxRx failed"), HcclResult::HCCL_E_INTERNAL);
225 0 : }
226 :
227 0 : return HcclResult::HCCL_SUCCESS;
228 : }
229 :
230 0 : RankId InsTempBroadcastNHR::GetRankFromMap(const u32 rankIdx) const
231 : {
232 0 : RankId rank = -1;
233 0 : for (auto& pair : tempVirtRankMap_) {
234 0 : if (pair.second == rankIdx) {
235 0 : rank = pair.first;
236 0 : break;
237 : }
238 : }
239 0 : return rank;
240 : }
241 :
242 0 : HcclResult InsTempBroadcastNHR::RunAllGather(
243 : const RankSliceInfo& sliceInfoVec, const ResLinks& tempLinks, std::vector<InsQuePtr>& tempInsQues)
244 : {
245 0 : u32 nSteps = GetNHRStepNum(tempRankSize_);
246 :
247 0 : BufferType buffType = opMode_ == OpMode::OPBASE ? buffInfo_.scratBuffType : buffInfo_.outBuffType;
248 0 : u64 memOffset = opMode_ == OpMode::OPBASE ? buffInfo_.scratchBuffBaseOff : buffInfo_.outBuffBaseOff;
249 :
250 0 : for (u32 step = 0; step < nSteps; step++) {
251 0 : AicpuNHRStepInfo stepInfo;
252 0 : CHK_RET(GetAllGatherStepInfo(step, nSteps, stepInfo));
253 :
254 0 : const std::vector<LinkData>& linkRecv = tempLinks.at(GetRankFromMap(stepInfo.fromRank));
255 0 : const std::vector<LinkData>& linkSend = tempLinks.at(GetRankFromMap(stepInfo.toRank));
256 :
257 0 : std::vector<DataSlice> txSlices;
258 0 : std::vector<DataSlice> rxSlices;
259 :
260 0 : HCCL_DEBUG(
261 : "[InsTempBroadcastNHR] rank[%d] rankSize[%u] recvFrom[%u] sendTo[%u] step[%u] nSteps[%u] nSlices[%u]",
262 : myRank_, tempRankSize_, stepInfo.fromRank, stepInfo.toRank, step, nSteps, stepInfo.nSlices);
263 :
264 0 : for (u32 i = 0; i < stepInfo.nSlices; i++) {
265 0 : u64 txOffset = sliceInfoVec[stepInfo.txSliceIdxs[i]][0].offset + memOffset;
266 0 : u64 txSize = sliceInfoVec[stepInfo.txSliceIdxs[i]][0].size;
267 0 : u64 rxOffset = sliceInfoVec[stepInfo.rxSliceIdxs[i]][0].offset + memOffset;
268 0 : u64 rxSize = sliceInfoVec[stepInfo.rxSliceIdxs[i]][0].size;
269 0 : DataSlice txSlice = DataSlice(buffType, txOffset, txSize);
270 0 : DataSlice rxSlice = DataSlice(buffType, rxOffset, rxSize);
271 0 : txSlices.push_back(txSlice);
272 0 : rxSlices.push_back(rxSlice);
273 : }
274 :
275 0 : TxRxLinks sendRecvLinks(linkSend[0], linkRecv[0]);
276 0 : TxRxSlicesList sendRecvSlicesList({txSlices, txSlices}, {rxSlices, rxSlices});
277 :
278 0 : SendRecvInfo sendRecvInfo(sendRecvLinks, sendRecvSlicesList);
279 0 : CHK_PRT_RET(
280 : SendRecv(sendRecvInfo, tempInsQues[0], 0, true, dmaMode_),
281 : HCCL_ERROR("[InsTempBroadcastNHR] RunAllGather send failed"), HcclResult::HCCL_E_INTERNAL);
282 0 : }
283 0 : return HcclResult::HCCL_SUCCESS;
284 : }
285 :
286 : // Send multiple DataSlices
287 0 : HcclResult InsTempBroadcastNHR::BatchTxRx(
288 : AicpuNHRStepInfo& stepInfo, const ResLinks& tempLinks, InsQuePtr& queue, const RankSliceInfo& sliceInfoVec)
289 : {
290 0 : BufferType memType = (opMode_ == OpMode::OPBASE) ? BufferType::SCRATCH : BufferType::INPUT;
291 0 : u64 memOffset = (opMode_ == OpMode::OPBASE) ? buffInfo_.scratchBuffBaseOff : buffInfo_.inBuffBaseOff;
292 : // 只有Tx,使用send指令
293 0 : if (stepInfo.txSliceIdxs.size() > 0 && stepInfo.rxSliceIdxs.size() == 0) {
294 0 : CHK_RET(BatchSend(stepInfo, tempLinks, queue, sliceInfoVec, memType, memOffset));
295 : }
296 : // 只有Rx，使用recv指令
297 0 : else if (stepInfo.txSliceIdxs.size() == 0 && stepInfo.rxSliceIdxs.size() > 0) {
298 0 : CHK_RET(BatchRecv(stepInfo, tempLinks, queue, sliceInfoVec, memType, memOffset));
299 : }
300 : // 既有Tx又有Rx，使用SendRecv指令
301 0 : else if (stepInfo.txSliceIdxs.size() > 0 && stepInfo.rxSliceIdxs.size() > 0) {
302 0 : CHK_RET(BatchSR(stepInfo, tempLinks, queue, sliceInfoVec, memType, memOffset));
303 : }
304 0 : return HcclResult::HCCL_SUCCESS;
305 : }
306 :
307 0 : HcclResult InsTempBroadcastNHR::BatchSend(
308 : AicpuNHRStepInfo& stepInfo, const ResLinks& tempLinks, InsQuePtr& queue, const RankSliceInfo& sliceInfoVec,
309 : BufferType memType, u64 memOffset) const
310 : {
311 0 : const LinkData& linkSend = tempLinks.at(GetRankFromMap(stepInfo.toRank))[0];
312 0 : std::vector<DataSlice> txSlices;
313 0 : for (u32 i = 0; i < stepInfo.txSliceIdxs.size(); i++) {
314 0 : u32 txId = stepInfo.txSliceIdxs[i];
315 : DataSlice txSrcDstSlice
316 0 : = DataSlice(memType, memOffset + sliceInfoVec[txId][0].offset, sliceInfoVec[txId][0].size);
317 0 : txSlices.push_back(txSrcDstSlice);
318 : }
319 0 : SlicesList txSlicesList(txSlices, txSlices);
320 0 : DataInfo sendData(linkSend, txSlicesList);
321 0 : CHK_PRT_RET(
322 : Send(sendData, queue), HCCL_ERROR("[InsTempBroadcastNHR] BatchSend failed"), HcclResult::HCCL_E_INTERNAL);
323 0 : return HcclResult::HCCL_SUCCESS;
324 0 : }
325 :
326 0 : HcclResult InsTempBroadcastNHR::BatchRecv(
327 : AicpuNHRStepInfo& stepInfo, const ResLinks& tempLinks, InsQuePtr& queue, const RankSliceInfo& sliceInfoVec,
328 : BufferType memType, u64 memOffset) const
329 : {
330 0 : const LinkData& linkRecv = tempLinks.at(GetRankFromMap(stepInfo.fromRank))[0];
331 0 : std::vector<DataSlice> rxSlices;
332 0 : for (u32 i = 0; i < stepInfo.rxSliceIdxs.size(); i++) {
333 0 : u32 rxId = stepInfo.rxSliceIdxs[i];
334 : DataSlice rxSrcDstSlice
335 0 : = DataSlice(memType, memOffset + sliceInfoVec[rxId][0].offset, sliceInfoVec[rxId][0].size);
336 0 : rxSlices.push_back(rxSrcDstSlice);
337 : }
338 0 : SlicesList rxSlicesList(rxSlices, rxSlices);
339 0 : DataInfo recvData(linkRecv, rxSlicesList);
340 0 : CHK_PRT_RET(
341 : Recv(recvData, queue), HCCL_ERROR("[InsTempBroadcastNHR] BatchTxRx Recv failed"), HcclResult::HCCL_E_INTERNAL);
342 0 : return HcclResult::HCCL_SUCCESS;
343 0 : }
344 :
345 0 : HcclResult InsTempBroadcastNHR::BatchSR(
346 : AicpuNHRStepInfo& stepInfo, const ResLinks& tempLinks, InsQuePtr& queue, const RankSliceInfo& sliceInfoVec,
347 : BufferType memType, u64 memOffset) const
348 : {
349 0 : const LinkData& linkSend = tempLinks.at(GetRankFromMap(stepInfo.toRank))[0];
350 0 : const LinkData& linkRecv = tempLinks.at(GetRankFromMap(stepInfo.fromRank))[0];
351 0 : TxRxLinks linkSendRecv = {linkSend, linkRecv};
352 :
353 0 : std::vector<DataSlice> txSlices;
354 0 : for (u32 i = 0; i < stepInfo.txSliceIdxs.size(); i++) {
355 0 : u32 txId = stepInfo.txSliceIdxs[i];
356 : DataSlice txSrcDstSlice
357 0 : = DataSlice(memType, memOffset + sliceInfoVec[txId][0].offset, sliceInfoVec[txId][0].size);
358 0 : txSlices.push_back(txSrcDstSlice);
359 : }
360 0 : SlicesList txSlicesList(txSlices, txSlices);
361 0 : std::vector<DataSlice> rxSlices;
362 0 : for (u32 i = 0; i < stepInfo.rxSliceIdxs.size(); i++) {
363 0 : u32 rxId = stepInfo.rxSliceIdxs[i];
364 : DataSlice rxSrcDstSlice
365 0 : = DataSlice(memType, memOffset + sliceInfoVec[rxId][0].offset, sliceInfoVec[rxId][0].size);
366 0 : rxSlices.push_back(rxSrcDstSlice);
367 : }
368 0 : SlicesList rxSlicesList(rxSlices, rxSlices);
369 0 : TxRxSlicesList txRxSlicesList(txSlicesList, rxSlicesList);
370 0 : SendRecvInfo sendRecvInfo(linkSendRecv, txRxSlicesList);
371 0 : CHK_PRT_RET(
372 : SendRecv(sendRecvInfo, queue, 0, true, dmaMode_), HCCL_ERROR("[InsTempBroadcastNHR] BatchTxRx SendRecv failed"),
373 : HcclResult::HCCL_E_INTERNAL);
374 0 : return HcclResult::HCCL_SUCCESS;
375 0 : }
376 :
377 0 : HcclResult InsTempBroadcastNHR::GenExtIns(
378 : const TempFuncs& tempFuncs, const TemplateDataParams& templateDataParams, const ResLinks& tempLinks,
379 : std::vector<InsQuePtr>& tempInsQues)
380 : {
381 0 : if (IsPcieLink(tempLinks)) {
382 0 : dmaMode_ = DmaMode::GET;
383 : }
384 0 : opMode_ = tempFuncs.opMode;
385 0 : enableCounterNotify_ = tempFuncs.enableCounterNotify;
386 0 : buffInfo_ = templateDataParams.buffInfo;
387 0 : HCCL_INFO("[InsTempBroadcastNHR] BroadcastNHR entry.");
388 :
389 0 : RankSliceInfo sliceInfoVec;
390 0 : CHK_RET(CalcDataSliceInfo(templateDataParams.sliceSize, sliceInfoVec));
391 :
392 0 : queNum_ = tempVTopo_.size();
393 : ;
394 0 : CHK_PRT_RET(
395 : queNum_ != tempInsQues.size(),
396 : HCCL_ERROR("[CollAlgFactory] [InsTempBroadcastNHR] Rank [%d], requiredQue Error.", myRank_),
397 : HcclResult::HCCL_E_INTERNAL);
398 :
399 0 : HCCL_INFO("[InsTempBroadcastNHR Run]RankID:[%d], root:[%u]", myRank_, root_);
400 :
401 0 : CHK_RET(PreCopy(templateDataParams, tempInsQues));
402 0 : CHK_RET(RunScatter(sliceInfoVec, tempLinks, tempInsQues));
403 0 : CHK_RET(RunAllGather(sliceInfoVec, tempLinks, tempInsQues));
404 0 : CHK_RET(PostCopy(templateDataParams, tempInsQues));
405 :
406 0 : HCCL_INFO("[InsTempBroadcastNHR] BroadcastNHR finish.");
407 :
408 0 : return HcclResult::HCCL_SUCCESS;
409 0 : }
410 :
411 : } // namespace Hccl
|
