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 : #include "alg_data_trans_wrapper.h"
13 : #include "ins_temp_all_reduce_nhr.h"
14 :
15 : namespace Hccl {
16 0 : InsTempAllReduceNHR::InsTempAllReduceNHR(const RankId virtualRank, const u32 tempRankSize,
17 : const std::vector<std::vector<RankId>> &tempVTopo,
18 0 : const std::map<RankId, u32> &tempVirtRankMap)
19 0 : : InsAlgTemplateBase(virtualRank, tempRankSize, tempVTopo, tempVirtRankMap)
20 : {
21 0 : }
22 :
23 0 : InsTempAllReduceNHR::~InsTempAllReduceNHR()
24 : {
25 0 : }
26 :
27 0 : HcclResult InsTempAllReduceNHR::CalcRes(AlgTempResReq &tempResReq)
28 : {
29 : // NHR 需要的 que Num 为 1
30 0 : CHK_PRT_RET(CalcResLinksNHR(myRank_, tempRankSize_, tempVTopo_, tempResReq) != HcclResult::HCCL_SUCCESS,
31 : HCCL_ERROR("[CollAlgFactory] [InsTempAllReduceNHR] Rank [%d], resLinks calculation error!", myRank_),
32 : HcclResult::HCCL_E_INTERNAL);
33 0 : auto& linkReq = tempResReq.links;
34 0 : u32 pathNum = 0;
35 0 : for (auto resReqIter = linkReq.begin(); resReqIter != linkReq.end(); resReqIter++) {
36 0 : auto remoteRank = resReqIter->first;
37 0 : if (rank2PathNumMap_.find(remoteRank) == rank2PathNumMap_.end() || rank2PathNumMap_[remoteRank] == 0) {
38 0 : HCCL_ERROR("[InsTempAllReduceNHR] No path to remoteRank[%d]", remoteRank);
39 0 : return HcclResult::HCCL_E_INTERNAL;
40 : }
41 0 : if (pathNum == 0) {
42 0 : pathNum = rank2PathNumMap_[remoteRank];
43 0 : } else if (rank2PathNumMap_[remoteRank] != pathNum) {
44 0 : HCCL_ERROR("[InsTempAllReduceNHR] Inconsistency pathNum to remoteRanks, Previous consistent pathNum=[%u], mismatched "
45 : "remoteRank=[%d], pathNum=[%u]",
46 : pathNum,
47 : remoteRank,
48 : rank2PathNumMap_[remoteRank]);
49 0 : return HcclResult::HCCL_E_INTERNAL;
50 : }
51 0 : resReqIter->second = pathNum;
52 : }
53 0 : tempResReq.queNum = 1 * pathNum;
54 0 : HCCL_INFO("[InsTempAllReduceNHR] tempResReq.queNum = %u",tempResReq.queNum);
55 0 : tempResReq.streamNum = tempResReq.queNum;
56 0 : tempResReq.queNotifys = CreateMasterSlaveQueNotifiesRequest(tempResReq.queNum);
57 :
58 0 : return HcclResult::HCCL_SUCCESS;
59 : }
60 :
61 : /*
62 : * Desc: 将数据按照rank切分为chuck 块，给后续的allreduce操作使用
63 : * param: dataSize: 待处理的输入数据大小
64 : * return: sliceInfoVec: 存储数据切分结果
65 : * return: HcclResult
66 : */
67 0 : HcclResult InsTempAllReduceNHR::CalcSlice(const u64 dataSize, const u64 baseOff, RankSliceInfo &sliceInfoVec)
68 : {
69 0 : std::vector<SliceInfo> tmp(tempVTopo_.size());
70 0 : sliceInfoVec.resize(tempRankSize_, tmp);
71 :
72 0 : u64 unitAllignSize = DataTypeSizeGet(dataType_);
73 0 : u64 chunkSize = RoundUp(dataSize, (tempRankSize_ * unitAllignSize)) * unitAllignSize;
74 :
75 0 : u64 accumOff = 0;
76 0 : for (u32 rankIdx = 0; rankIdx < tempRankSize_; rankIdx++) {
77 0 : u64 currChunkSize = ((dataSize - accumOff) > chunkSize) ? chunkSize : (dataSize - accumOff);
78 0 : SliceInfo slice = {accumOff + baseOff, currChunkSize};
79 0 : sliceInfoVec[rankIdx][0] = slice;
80 0 : accumOff += currChunkSize;
81 : }
82 :
83 0 : CHK_PRT_RET((sliceInfoVec[tempRankSize_ - 1][0].offset + sliceInfoVec[tempRankSize_ - 1][0].size != baseOff + dataSize),
84 : HCCL_ERROR("[InsTempAllReduceNHR] chunkSize:[%llu], Rank:[%d], SliceInfo calculation error!", chunkSize, myRank_),
85 : HcclResult::HCCL_E_INTERNAL);
86 0 : return HcclResult::HCCL_SUCCESS;
87 0 : }
88 :
89 : /*
90 : * Desc: 返回当前rank能处理的数据量和scratch buffer之间的比例关系
91 : * param: input: 输入数据位置
92 : * param: output 输出数据位置
93 : */
94 0 : u32 InsTempAllReduceNHR::CalcScratchMultiple(BufferType input, BufferType output)
95 : {
96 : (void)input;
97 : (void)output;
98 : // 单算子模式，cclBuffer和usrIn一样大，图模式，不需要cclBuffer
99 0 : u32 multiple = 0;
100 0 : if (op_.opMode == OpMode::OPBASE) {
101 0 : multiple = 1;
102 : }
103 :
104 0 : return multiple;
105 : }
106 :
107 0 : HcclResult InsTempAllReduceNHR::GenExtIns(const TempFuncs &tempFuncs, const TemplateDataParams &tempAlgParams,
108 : const ResLinks &tempLinks, std::vector<InsQuePtr> &tempInsQues)
109 : {
110 0 : HCCL_INFO("[InsTempAllReduceNHR][GenExtIns] AllReduceNHR begin: rank[%d] start", myRank_);
111 0 : if (IsPcieLink(tempLinks)) {
112 0 : dmaMode_ = DmaMode::GET;
113 : }
114 :
115 0 : opMode_ = tempFuncs.opMode;
116 0 : enableCounterNotify_ = tempFuncs.enableCounterNotify;
117 :
118 0 : uint32_t linkNum = tempLinks.begin()->second.size();
119 : // 流的数量不能少于linkNum
120 0 : CHK_PRT_RET(linkNum > tempInsQues.size(), HCCL_ERROR("[CollAlgFactory] [InsTempAllReduceNHR] Rank [%d], requiredQue Error.", myRank_),
121 : HcclResult::HCCL_E_INTERNAL);
122 :
123 0 : std::vector<float> dataSplitRate(linkNum);
124 0 : CHK_RET(CalcDataSplitRateForLinks(tempLinks.begin()->second, dataSplitRate));
125 :
126 0 : RankSliceInfo sliceInfoVec;
127 0 : CHK_RET(CalcSlice(tempAlgParams.sliceSize, 0, sliceInfoVec));
128 :
129 : //将一个RankSliceInfo，拆分成linkNum 个RankSliceInfo
130 0 : u64 typeSize = DataTypeSizeGet(dataType_);
131 0 : std::vector<RankSliceInfo> sliceInfoVecForAllLinks(linkNum);
132 0 : for(auto sliceInfoPerRank: sliceInfoVec){
133 0 : std::vector<std::vector<SliceInfo>>sliceInfoPerRankForAllLinks(linkNum);
134 0 : for(auto sliceInfo:sliceInfoPerRank){
135 0 : u64 size=sliceInfo.size;
136 0 : u64 offset=sliceInfo.offset;
137 0 : u64 AccSize=0;
138 0 : u64 dataCnt = size / typeSize;
139 0 : vector<SliceInfo>sliceInfoForAllLinks(linkNum);
140 0 : for(u32 linkIdx = 0; linkIdx < linkNum; linkIdx++){
141 0 : if (linkIdx != linkNum - 1) {
142 0 : sliceInfoForAllLinks[linkIdx].size = static_cast<u64>(static_cast<float>(dataCnt) * dataSplitRate[linkIdx]) * typeSize;
143 : }
144 : else{
145 0 : sliceInfoForAllLinks[linkIdx].size = size - AccSize;
146 : }
147 0 : sliceInfoForAllLinks[linkIdx].offset = offset + AccSize;
148 0 : AccSize += sliceInfoForAllLinks[linkIdx].size;
149 : }
150 0 : for(u32 linkIdx = 0; linkIdx < linkNum; linkIdx++){
151 0 : sliceInfoPerRankForAllLinks[linkIdx].emplace_back(sliceInfoForAllLinks[linkIdx]);
152 : }
153 0 : }
154 0 : for(u32 linkIdx = 0; linkIdx < linkNum; linkIdx++){
155 0 : sliceInfoVecForAllLinks[linkIdx].emplace_back(sliceInfoPerRankForAllLinks[linkIdx]);
156 : }
157 0 : }
158 :
159 : // 预拷贝
160 0 : CHK_RET(PreCopy(tempAlgParams, tempInsQues));
161 :
162 0 : u32 mainQueIdx = 0;
163 : // 流间前同步，主流通知从流，只有一个流则不做任何事
164 0 : CHK_RET(PreSyncQues(tempInsQues, mainQueIdx));
165 :
166 : // 主从流执行nhr
167 : // 待修改数据切分方式
168 0 : for (uint32_t linkIdx = 0; linkIdx < linkNum; linkIdx++) {
169 0 : CHK_RET(RunReduceScatter(sliceInfoVecForAllLinks[linkIdx], tempLinks, tempInsQues, linkIdx));
170 0 : CHK_RET(PrepareDataForAllGather(sliceInfoVecForAllLinks[linkIdx], tempInsQues, linkIdx));
171 0 : CHK_RET(RunAllGather(sliceInfoVecForAllLinks[linkIdx], tempLinks, tempInsQues, linkIdx));
172 : }
173 : // 流间后同步，从流通知主流
174 0 : CHK_RET(PostSyncQues(tempInsQues, mainQueIdx));
175 : // 结果拷贝
176 0 : CHK_RET(PostCopy(tempAlgParams, tempInsQues));
177 0 : HCCL_INFO("[InsTempAllReduceNHR][GenExtIns] AllReduceNHR finished: rank[%d] end", myRank_);
178 0 : return HcclResult::HCCL_SUCCESS;
179 0 : }
180 :
181 0 : HcclResult InsTempAllReduceNHR::PreCopy(const TemplateDataParams &tempAlgParams, std::vector<InsQuePtr> &tempInsQues)
182 : {
183 : // 单算子模式，需要先将数据拷贝到cclBuffer
184 0 : if (opMode_ == OpMode::OPBASE) {
185 0 : nhrInBuffType_ = BufferType::SCRATCH;
186 0 : nhrInBuffBaseOff_ = tempAlgParams.buffInfo.inBuffBaseOff;
187 :
188 0 : if (tempAlgParams.buffInfo.inBuffType != BufferType::SCRATCH) {
189 0 : HCCL_INFO("[InsTempAllReduceNHR][PreCopy] Opbase copy from userIn to scratchBuffer");
190 0 : DataSlice usrInSlices = DataSlice(tempAlgParams.buffInfo.inBuffType, tempAlgParams.buffInfo.inBuffBaseOff, tempAlgParams.sliceSize);
191 0 : DataSlice scratchSlices = DataSlice(BufferType::SCRATCH, tempAlgParams.buffInfo.scratchBuffBaseOff, tempAlgParams.sliceSize);
192 0 : CHK_RET(LocalCopy(tempInsQues[0], usrInSlices, scratchSlices));
193 :
194 0 : nhrInBuffBaseOff_ = tempAlgParams.buffInfo.scratchBuffBaseOff;
195 : } else {
196 0 : HCCL_INFO("[InsTempAllReduceNHR][PreCopy] skip precopy");
197 : }
198 : } else {
199 0 : HCCL_INFO("[InsTempAllReduceNHR][PreCopy] offload skip precopy");
200 0 : nhrInBuffType_ = tempAlgParams.buffInfo.inBuffType;
201 0 : nhrInBuffBaseOff_ = tempAlgParams.buffInfo.inBuffBaseOff;
202 : }
203 :
204 0 : nhrOutBuffType_ = tempAlgParams.buffInfo.outBuffType;
205 0 : nhrOutBuffBaseOff_ = tempAlgParams.buffInfo.outBuffBaseOff;
206 :
207 0 : return HcclResult::HCCL_SUCCESS;
208 : }
209 :
210 : // 将reduceScatter之后的数据先放到usrOut
211 0 : HcclResult InsTempAllReduceNHR::PrepareDataForAllGather(const RankSliceInfo &sliceInfoVec, std::vector<InsQuePtr> &tempInsQues, u32 linkIdx)
212 : {
213 : // 如果是单算子模式，在原来的位置要先做完allGather，然后postCopy把数据放到usrOut
214 : // 如果是图模式，直接把数据放到usrOUt，然后在usrOut上做allGather
215 0 : HCCL_INFO("[InsTempAllReduceNHR][PrepareDataForAllGather] prepare data for allGather");
216 :
217 0 : if (opMode_ == OpMode::OFFLOAD) {
218 0 : u64 size = sliceInfoVec[tempVirtRankMap_[myRank_]][0].size;
219 0 : u64 srcOffset = sliceInfoVec[tempVirtRankMap_[myRank_]][0].offset;
220 0 : u64 dstOffset = sliceInfoVec[tempVirtRankMap_[myRank_]][0].offset;
221 0 : DataSlice srcSlice = DataSlice(nhrInBuffType_, nhrInBuffBaseOff_ + srcOffset, size);
222 0 : DataSlice dstSlice = DataSlice(nhrOutBuffType_, nhrOutBuffBaseOff_ + dstOffset, size);
223 0 : CHK_RET(LocalCopy(tempInsQues[linkIdx], srcSlice, dstSlice));
224 :
225 0 : nhrInBuffType_ = nhrOutBuffType_;
226 0 : nhrInBuffBaseOff_ = nhrOutBuffBaseOff_;
227 : }
228 :
229 0 : return HcclResult::HCCL_SUCCESS;
230 : }
231 :
232 0 : HcclResult InsTempAllReduceNHR::PostCopy(const TemplateDataParams &tempAlgParams, std::vector<InsQuePtr> &tempInsQues)
233 : {
234 : // 单算子模式，需要将数据拷贝到usrOut
235 0 : if (opMode_ == OpMode::OPBASE) {
236 0 : HCCL_INFO("[InsTempAllReduceNHR][PostCopy] Opbase copy from scratchBuffer to userOut");
237 0 : DataSlice scratchSlices = DataSlice(nhrInBuffType_, nhrInBuffBaseOff_, tempAlgParams.sliceSize);
238 0 : DataSlice usrOutSlices = DataSlice(nhrOutBuffType_, nhrOutBuffBaseOff_, tempAlgParams.sliceSize);
239 0 : CHK_RET(LocalCopy(tempInsQues[0], scratchSlices, usrOutSlices));
240 : } else {
241 0 : HCCL_INFO("[InsTempAllReduceNHR][PostCopy] offload skip postcopy");
242 : }
243 :
244 0 : return HcclResult::HCCL_SUCCESS;
245 : }
246 :
247 0 : HcclResult InsTempAllReduceNHR::RunReduceScatter(const RankSliceInfo &sliceInfoVec, const ResLinks &tempLinks,
248 : std::vector<InsQuePtr> &tempInsQues, u32 linkIdx)
249 : {
250 0 : std::vector<AicpuNHRStepInfo> stepInfoList;
251 0 : GetStepInfoList(stepInfoList);
252 0 : for(auto& stepInfo : stepInfoList) {
253 0 : HCCL_DEBUG("[InsTempAllReduceNHR][RunReduceScatter] step[%u], myRank[%u], toRank[%u], fromRank[%u], nSlices[%u].",
254 : stepInfo.step, stepInfo.myRank, stepInfo.toRank, stepInfo.fromRank, stepInfo.nSlices);
255 :
256 0 : const std::vector<LinkData> &linkRecv = tempLinks.at(GetRankFromMap(stepInfo.fromRank));
257 0 : const std::vector<LinkData> &linkSend = tempLinks.at(GetRankFromMap(stepInfo.toRank));
258 0 : std::vector<DataSlice> txSlices;
259 0 : std::vector<DataSlice> rxSlices;
260 :
261 : // 在 nhrInBuffType_ 上进行 ReduceScatter 操作
262 0 : for (u32 i = 0; i < stepInfo.nSlices; i++) {
263 0 : u64 txOffset = sliceInfoVec[stepInfo.txSliceIdxs[i]][0].offset + nhrInBuffBaseOff_;
264 0 : u64 txSize = sliceInfoVec[stepInfo.txSliceIdxs[i]][0].size;
265 0 : u64 rxOffset = sliceInfoVec[stepInfo.rxSliceIdxs[i]][0].offset + nhrInBuffBaseOff_;
266 0 : u64 rxSize = sliceInfoVec[stepInfo.rxSliceIdxs[i]][0].size;
267 0 : DataSlice txSlice = DataSlice(nhrInBuffType_, txOffset, txSize);
268 0 : DataSlice rxSlice = DataSlice(nhrInBuffType_, rxOffset, rxSize);
269 0 : txSlices.push_back(txSlice);
270 0 : rxSlices.push_back(rxSlice);
271 : }
272 : SendRecvReduceInfo sendRecvReduceInfo{
273 0 : {linkSend[linkIdx],linkRecv[linkIdx]},
274 : {{txSlices, txSlices},{rxSlices, rxSlices}}, dataType_, redOp_
275 0 : };
276 0 : CHK_PRT_RET(SendRecvReduce(sendRecvReduceInfo, tempInsQues[linkIdx], 0, true, dmaMode_) != HcclResult::HCCL_SUCCESS,
277 : HCCL_ERROR("[InsTempAllReduceNHR] RunReduceScatter SendRecvReduce failed"),
278 : HcclResult::HCCL_E_INTERNAL);
279 0 : }
280 0 : return HcclResult::HCCL_SUCCESS;
281 0 : }
282 :
283 0 : HcclResult InsTempAllReduceNHR::RunAllGather(const RankSliceInfo &sliceInfoVec, const ResLinks &tempLinks,
284 : std::vector<InsQuePtr> &tempInsQues, u32 linkIdx)
285 : {
286 0 : u32 nSteps = GetNHRStepNum(tempRankSize_);
287 0 : for (u32 step = 0; step < nSteps; step++) {
288 0 : AicpuNHRStepInfo stepInfo;
289 0 : CHK_RET(GetStepInfo(step, nSteps, stepInfo));
290 :
291 0 : const std::vector<LinkData> &linkRecv = tempLinks.at(GetRankFromMap(stepInfo.fromRank));
292 0 : const std::vector<LinkData> &linkSend = tempLinks.at(GetRankFromMap(stepInfo.toRank));
293 :
294 0 : std::vector<DataSlice> txSlices;
295 0 : std::vector<DataSlice> rxSlices;
296 :
297 0 : HCCL_DEBUG("[InsTempAllReduceNHR] rank[%d] rankSize[%u] recvFrom[%u] sendTo[%u] step[%u] nSteps[%u] nSlices[%u]",
298 : myRank_, tempRankSize_, stepInfo.fromRank, stepInfo.toRank, step, nSteps, stepInfo.nSlices);
299 :
300 0 : for (u32 i = 0; i < stepInfo.nSlices; i++) {
301 0 : u64 txOffset = sliceInfoVec[stepInfo.txSliceIdxs[i]][0].offset + nhrInBuffBaseOff_;
302 0 : u64 txSize = sliceInfoVec[stepInfo.txSliceIdxs[i]][0].size;
303 0 : u64 rxOffset = sliceInfoVec[stepInfo.rxSliceIdxs[i]][0].offset + nhrInBuffBaseOff_;
304 0 : u64 rxSize = sliceInfoVec[stepInfo.rxSliceIdxs[i]][0].size;
305 0 : DataSlice txSlice = DataSlice(nhrInBuffType_, txOffset, txSize);
306 0 : DataSlice rxSlice = DataSlice(nhrInBuffType_, rxOffset, rxSize);
307 0 : txSlices.push_back(txSlice);
308 0 : rxSlices.push_back(rxSlice);
309 : }
310 :
311 0 : TxRxLinks sendRecvLinks(linkSend[linkIdx], linkRecv[linkIdx]);
312 0 : TxRxSlicesList sendRecvSlicesList({txSlices, txSlices}, {rxSlices, rxSlices});
313 :
314 0 : SendRecvInfo sendRecvInfo(sendRecvLinks, sendRecvSlicesList);
315 0 : CHK_PRT_RET(SendRecv(sendRecvInfo, tempInsQues[linkIdx], 0, true, dmaMode_) != HcclResult::HCCL_SUCCESS,
316 : HCCL_ERROR("[InsTempAllReduceNHR] RunAllGather send/recv failed"),
317 : HcclResult::HCCL_E_INTERNAL);
318 0 : }
319 0 : return HcclResult::HCCL_SUCCESS;
320 : }
321 :
322 0 : HcclResult InsTempAllReduceNHR::GetStepInfo(u32 step, u32 nSteps, AicpuNHRStepInfo &stepInfo)
323 : {
324 0 : u32 rankIdx = tempVirtRankMap_[myRank_];
325 0 : stepInfo.txSliceIdxs.clear();
326 0 : stepInfo.rxSliceIdxs.clear();
327 0 : stepInfo.step = step;
328 0 : stepInfo.myRank = rankIdx;
329 :
330 : // 计算通信对象
331 0 : u32 deltaRank = 1 << (nSteps - 1 - step);
332 0 : u32 recvFrom = (rankIdx + tempRankSize_ - deltaRank) % tempRankSize_;
333 0 : u32 sendTo = (rankIdx + deltaRank) % tempRankSize_;
334 :
335 : // 数据份数和数据编号增量
336 0 : u32 nSlices = (tempRankSize_ - 1 + (1 << (nSteps - 1 - step))) / (1 << (nSteps - step));
337 0 : u32 deltaSliceIndex = 1 << (nSteps - step);
338 0 : u32 txSliceIdx = rankIdx;
339 0 : u32 rxSliceIdx = (rankIdx - (1 << (nSteps - 1 - step)) + tempRankSize_) % tempRankSize_;
340 :
341 0 : stepInfo.nSlices = nSlices;
342 0 : stepInfo.toRank = sendTo;
343 0 : stepInfo.fromRank = recvFrom;
344 :
345 0 : for (u32 i = 0; i < nSlices; i++) {
346 0 : stepInfo.txSliceIdxs.push_back(txSliceIdx);
347 0 : stepInfo.rxSliceIdxs.push_back(rxSliceIdx);
348 :
349 0 : HCCL_DEBUG("[InsTempAllReduceNHR][GetStepInfo] i[%u] txSliceIdx[%u] rxSliceIdx[%u]", i, txSliceIdx, rxSliceIdx);
350 :
351 0 : txSliceIdx = (txSliceIdx + tempRankSize_ - deltaSliceIndex) % tempRankSize_;
352 0 : rxSliceIdx = (rxSliceIdx + tempRankSize_ - deltaSliceIndex) % tempRankSize_;
353 : }
354 0 : return HcclResult::HCCL_SUCCESS;
355 : }
356 :
357 : // 计算每轮收发的对端以及slice编号
358 0 : HcclResult InsTempAllReduceNHR::GetStepInfoList(std::vector<AicpuNHRStepInfo> &stepInfoList)
359 : {
360 : // 将本 rank 号转换成算法使用的索引号
361 0 : u32 rankIdx = tempVirtRankMap_[myRank_];
362 0 : stepInfoList.clear();
363 :
364 0 : u32 nSteps = GetNHRStepNum(tempRankSize_);
365 0 : stepInfoList.resize(nSteps);
366 0 : for (u32 step = 0; step < nSteps; step++) {
367 : // 计算通信对象
368 0 : u32 deltaRank = 1 << step;
369 0 : u32 sendTo = (rankIdx + tempRankSize_ - deltaRank) % tempRankSize_;
370 0 : u32 recvFrom = (rankIdx + deltaRank) % tempRankSize_;
371 :
372 : // 数据份数和数据编号增量
373 0 : u32 nSlices = (tempRankSize_ - 1 + (1 << step)) / (1 << (step + 1));
374 0 : u32 deltaSliceIndex = 1 << (step + 1);
375 0 : u32 txSliceIdx = sendTo;
376 0 : u32 rxSliceIdx = rankIdx;
377 :
378 0 : AicpuNHRStepInfo &currStepInfo = stepInfoList[step];
379 0 : currStepInfo.step = step;
380 0 : currStepInfo.myRank = rankIdx;
381 0 : currStepInfo.nSlices = nSlices;
382 0 : currStepInfo.toRank = sendTo;
383 0 : currStepInfo.fromRank = recvFrom;
384 :
385 : // 计算本rank在每轮收/发中的slice编号
386 0 : currStepInfo.txSliceIdxs.reserve(nSlices);
387 0 : currStepInfo.rxSliceIdxs.reserve(nSlices);
388 0 : for (u32 i = 0; i < nSlices; i++) {
389 0 : currStepInfo.txSliceIdxs.push_back(txSliceIdx);
390 0 : currStepInfo.rxSliceIdxs.push_back(rxSliceIdx);
391 0 : HCCL_DEBUG("[InsTempAllReduceNHR][GetStepInfoList] i[%u] txSliceIdx[%u] rxSliceIdx[%u]", i, txSliceIdx, rxSliceIdx);
392 0 : txSliceIdx = (txSliceIdx + tempRankSize_ - deltaSliceIndex) % tempRankSize_;
393 0 : rxSliceIdx = (rxSliceIdx + tempRankSize_ - deltaSliceIndex) % tempRankSize_;
394 : }
395 : }
396 0 : return HcclResult::HCCL_SUCCESS;
397 : }
398 :
399 0 : RankId InsTempAllReduceNHR::GetRankFromMap(const u32 rankIdx)
400 : {
401 0 : RankId rank = -1;
402 0 : HCCL_INFO("[InsTempAllReduceNHR] GetRankFromMap");
403 0 : for (auto &pair : tempVirtRankMap_) {
404 0 : if (pair.second == rankIdx) {
405 0 : rank = pair.first;
406 0 : break;
407 : }
408 : }
409 0 : return rank;
410 : }
411 : } // namespace Hccl
|
