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 "ins_temp_scatter_nhr.h"
12 : #include "ins_temp_all_gather_nhr.h"
13 : #include "alg_data_trans_wrapper.h"
14 : #include "dev_mode.h"
15 : #include "log.h"
16 :
17 : namespace Hccl {
18 0 : InsTempScatterNHR::InsTempScatterNHR(const RankId virtualRank, const u32 tempRankSize,
19 0 : const std::vector<std::vector<RankId>> &tempVTopo, const std::map<RankId, u32> &tempVirtRankMap)
20 0 : : InsAlgTemplateBase(virtualRank, tempRankSize, tempVTopo, tempVirtRankMap)
21 : {
22 0 : }
23 :
24 0 : InsTempScatterNHR::~InsTempScatterNHR()
25 : {
26 0 : }
27 :
28 0 : HcclResult InsTempScatterNHR::CalcRes(AlgTempResReq &tempResReq)
29 : {
30 0 : CHK_PRT_RET(CalcResLinksNHR(myRank_, tempRankSize_, tempVTopo_, tempResReq) != HcclResult::HCCL_SUCCESS,
31 : HCCL_ERROR("[CollAlgFactory] [InsTempScatterNHR] 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("[InsTempScatterNHR] 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("[InsTempScatterNHR] Inconsistency pathNum to remoteRanks, Previous consistent pathNum=[%u], "
45 : "mismatched "
46 : "remoteRank=[%d], pathNum=[%u]",
47 : pathNum, remoteRank, rank2PathNumMap_[remoteRank]);
48 0 : return HcclResult::HCCL_E_INTERNAL;
49 : }
50 0 : resReqIter->second = pathNum;
51 : }
52 :
53 : // NHR 需要的 que Num 为 1
54 0 : tempResReq.queNum = 1 * pathNum;
55 0 : HCCL_INFO("[InsTempScatterNHR] tempResReq.queNum = %u", tempResReq.queNum);
56 0 : tempResReq.streamNum = tempResReq.queNum;
57 0 : tempResReq.queNotifys = CreateMasterSlaveQueNotifiesRequest(tempResReq.queNum);
58 :
59 0 : return HcclResult::HCCL_SUCCESS;
60 : }
61 :
62 0 : uint64_t InsTempScatterNHR::GetExpandedMode() const
63 : {
64 0 : return DeviceMode::AICPU;
65 : }
66 :
67 0 : HcclResult InsTempScatterNHR::PreCopy(const TemplateDataParams &templateDataParams, std::vector<InsQuePtr> &tempInsQues)
68 : {
69 0 : if (u32(myRank_) != root_ || buffInfo_.inBuffType == BufferType::SCRATCH) {
70 0 : return HCCL_SUCCESS;
71 : }
72 : // root卡需要将发送的数据刷新为尾部数据长度,保护一下tailSize=0认为没有
73 0 : u64 tailSize = templateDataParams.tailSize == 0 ? templateDataParams.sliceSize : templateDataParams.tailSize;
74 0 : for (u32 r = 0; r < templateDataParams.repeatNum; r++) {
75 0 : for (u32 algRank = 0; algRank < tempRankSize_; algRank++) {
76 0 : u64 srcOffset = r * templateDataParams.inputRepeatStride + templateDataParams.inputSliceStride * algRank
77 0 : + buffInfo_.inBuffBaseOff;
78 0 : DataSlice srcSlice(BufferType::INPUT, srcOffset, tailSize);
79 0 : u64 dstOffset = r * ((tempRankSize_ - 1) * templateDataParams.sliceSize + tailSize)
80 0 : + buffInfo_.scratchBuffBaseOff + algRank * templateDataParams.sliceSize;
81 0 : DataSlice dstSlice(BufferType::SCRATCH, dstOffset, tailSize);
82 0 : LocalCopy(tempInsQues[0], srcSlice, dstSlice);
83 : }
84 : }
85 :
86 0 : return HcclResult::HCCL_SUCCESS;
87 : }
88 :
89 0 : HcclResult InsTempScatterNHR::PostCopy(const TemplateDataParams &templateDataParams, std::vector<InsQuePtr> &tempInsQues)
90 : {
91 : u32 myAlgRank;
92 0 : GetAlgRank(myRank_, tempVTopo_[0], myAlgRank);
93 : // root卡需要将发送的数据刷新为尾部数据长度,保护一下tailSize=0认为没有
94 0 : u64 tailSize = templateDataParams.tailSize == 0 ? templateDataParams.sliceSize : templateDataParams.tailSize;
95 : // 支持不均匀切分的情况下需要把尾部数据放到最后一张卡上
96 0 : u64 sliceSize = myAlgRank == tempVTopo_[0].size() - 1 ? tailSize : templateDataParams.sliceSize;
97 :
98 0 : for (u32 r = 0; r < templateDataParams.repeatNum; r++) {
99 0 : u64 dstOffset = buffInfo_.outBuffBaseOff + r * templateDataParams.sliceSize;
100 0 : u64 srcOffset = r * ((tempRankSize_ - 1) * templateDataParams.sliceSize + tailSize)
101 0 : + buffInfo_.scratchBuffBaseOff + myAlgRank * templateDataParams.sliceSize;
102 0 : DataSlice dstSlice(buffInfo_.outBuffType, dstOffset, sliceSize);
103 0 : DataSlice srcSlice(BufferType::SCRATCH, srcOffset, sliceSize);
104 0 : if (buffInfo_.outBuffType == BufferType::SCRATCH && srcOffset == dstOffset) {
105 0 : continue;
106 : }
107 0 : LocalCopy(tempInsQues[0], srcSlice, dstSlice);
108 : }
109 0 : return HcclResult::HCCL_SUCCESS;
110 : }
111 :
112 0 : HcclResult InsTempScatterNHR::RunNHR(
113 : TemplateDataParams &templateDataParams, ResLinks &tempLinks, std::vector<InsQuePtr> &tempInsQues) const
114 : {
115 0 : u32 mainQueIdx = 0;
116 : // 流间前同步，主流通知从流，只有一个流则不做任何事
117 0 : CHK_RET(PreSyncQues(tempInsQues, mainQueIdx));
118 :
119 : // nhr主体部分
120 0 : u32 nSteps = GetNHRStepNum(tempRankSize_);
121 0 : for (u32 r = 0; r < templateDataParams.repeatNum; r++) {
122 0 : for (u32 step = 0; step < nSteps; step++) {
123 0 : AicpuNHRStepInfo stepInfo;
124 0 : GetStepInfo(step, nSteps, stepInfo);
125 :
126 : // 只有Tx,使用send指令
127 0 : if (stepInfo.txSliceIdxs.size() > 0 && stepInfo.rxSliceIdxs.size() == 0) {
128 0 : CHK_RET(BatchSend(stepInfo, tempLinks, tempInsQues, templateDataParams, r));
129 : }
130 : // 只有Rx，使用recv指令
131 0 : else if (stepInfo.txSliceIdxs.size() == 0 && stepInfo.rxSliceIdxs.size() > 0) {
132 0 : CHK_RET(BatchRecv(stepInfo, tempLinks, tempInsQues, templateDataParams, r));
133 : }
134 : // 既有Tx又有Rx，使用SendRecv指令
135 0 : else if (stepInfo.txSliceIdxs.size() > 0 && stepInfo.rxSliceIdxs.size() > 0) {
136 0 : CHK_RET(BatchSR(stepInfo, tempLinks, tempInsQues, templateDataParams, r));
137 : }
138 0 : }
139 : }
140 : // 流间后同步，从流通知主流
141 0 : CHK_RET(PostSyncQues(tempInsQues, mainQueIdx));
142 0 : return HCCL_SUCCESS;
143 : }
144 :
145 : // 需要支持input->scratch, scratch->output, input->output
146 0 : HcclResult InsTempScatterNHR::GenExtIns(TempFuncs &tempFuncs, TemplateDataParams &templateDataParams,
147 : ResLinks &tempLinks, std::vector<InsQuePtr> &tempInsQues)
148 : {
149 0 : if (IsPcieLink(tempLinks)) {
150 0 : dmaMode_ = DmaMode::GET;
151 : } else {
152 0 : dmaMode_ = DmaMode::PUT;
153 : }
154 0 : opMode_ = tempFuncs.opMode;
155 0 : enableCounterNotify_ = tempFuncs.enableCounterNotify;
156 0 : buffInfo_ = templateDataParams.buffInfo;
157 :
158 0 : HCCL_INFO("[InsTempScatterNHR] Run start");
159 0 : uint32_t linkNum = tempLinks.begin()->second.size();
160 : // 流的数量不能少于linkNum
161 0 : CHK_PRT_RET(linkNum < tempInsQues.size(),
162 : HCCL_ERROR("[CollAlgFactory] [InsTempScatterNHR] Rank [%d], requiredQue Error.", myRank_),
163 : HcclResult::HCCL_E_INTERNAL);
164 :
165 0 : HCCL_INFO("[InsTempScatterNHR Run]RankID:[%d], root:[%u], isForepart:[%d], isBottom:[%d]", myRank_, root_,
166 : tempFuncs.isForepart, tempFuncs.isBottom);
167 0 : CHK_RET(PreCopy(templateDataParams, tempInsQues));
168 0 : CHK_RET(RunNHR(templateDataParams, tempLinks, tempInsQues));
169 0 : CHK_RET(PostCopy(templateDataParams, tempInsQues));
170 0 : return HCCL_SUCCESS;
171 : }
172 :
173 0 : u32 InsTempScatterNHR::CalcScratchMultiple(BufferType inBuffType, BufferType outBuffType) const
174 : {
175 : (void)inBuffType;
176 : (void)outBuffType;
177 0 : return tempRankSize_;
178 : }
179 :
180 0 : HcclResult InsTempScatterNHR::BatchSend(AicpuNHRStepInfo &stepInfo, const ResLinks &tempLinks,
181 : std::vector<InsQuePtr> &tempInsQues, TemplateDataParams &templateDataParams, u32 repeat) const
182 : {
183 0 : const std::vector<LinkData> &linkSend = tempLinks.at(stepInfo.toRank);
184 0 : u32 linkNum = rank2PathNumMap_.at(stepInfo.toRank);
185 0 : std::vector<float> dataSplitRate(linkNum);
186 0 : CHK_RET(CalcDataSplitRateForLinks(linkSend, dataSplitRate));
187 : // root卡需要将发送的数据刷新为尾部数据长度,保护一下tailSize=0认为没有
188 0 : u64 tailSize = templateDataParams.tailSize == 0 ? templateDataParams.sliceSize : templateDataParams.tailSize;
189 :
190 0 : const u32 sliceCount = stepInfo.txSliceIdxs.size();
191 0 : const u64 baseOffset = repeat * ((tempRankSize_ - 1) * templateDataParams.sliceSize + tailSize)
192 0 : + buffInfo_.scratchBuffBaseOff;
193 0 : std::vector<DataSlice> srcDstSlices;
194 0 : srcDstSlices.reserve(sliceCount);
195 0 : for (u32 j = 0; j < linkNum; j++) {
196 0 : srcDstSlices.clear();
197 0 : for (u32 i = 0; i < sliceCount; i++) {
198 0 : u64 srcDstOffset = baseOffset + stepInfo.txSliceIdxs[i] * templateDataParams.sliceSize;
199 : // 发送的一定是root
200 0 : DataSlice srcDstSlice(templateDataParams.buffInfo.scratBuffType, srcDstOffset, tailSize);
201 0 : srcDstSlices.emplace_back(CalcDataSliceForLinks(srcDstSlice, dataSplitRate, j, dataType_));
202 : }
203 0 : SlicesList txSlicesList(srcDstSlices, srcDstSlices);
204 0 : DataInfo sendData(linkSend[j], std::move(txSlicesList));
205 0 : CHK_PRT_RET(Send(sendData, tempInsQues[j], 0, true, dmaMode_),
206 : HCCL_ERROR("[InsTempScatterNHR] BatchSend failed"), HcclResult::HCCL_E_INTERNAL);
207 0 : }
208 :
209 0 : return HcclResult::HCCL_SUCCESS;
210 0 : }
211 :
212 0 : HcclResult InsTempScatterNHR::BatchRecv(AicpuNHRStepInfo &stepInfo, const ResLinks &tempLinks,
213 : std::vector<InsQuePtr> &tempInsQues, TemplateDataParams &templateDataParams, u32 repeat) const
214 : {
215 : u32 myAlgRank;
216 0 : GetAlgRank(myRank_, tempVTopo_[0], myAlgRank);
217 : // root卡需要将发送的数据刷新为尾部数据长度,保护一下tailSize=0认为没有
218 0 : u64 tailSize = templateDataParams.tailSize == 0 ? templateDataParams.sliceSize : templateDataParams.tailSize;
219 : // 支持不均匀切分的情况下需要把尾部数据放到最后一张卡上
220 0 : u64 sliceSize = myAlgRank == tempVTopo_[0].size() - 1 ? tailSize : templateDataParams.sliceSize;
221 0 : const std::vector<LinkData> &linkRecv = tempLinks.at(stepInfo.fromRank);
222 0 : u32 linkNum = rank2PathNumMap_.at(stepInfo.fromRank);
223 0 : std::vector<float> dataSplitRate(linkNum);
224 0 : CHK_RET(CalcDataSplitRateForLinks(linkRecv, dataSplitRate));
225 0 : const u32 sliceCount = stepInfo.txSliceIdxs.size();
226 0 : const u64 baseOffset = repeat * ((tempRankSize_ - 1) * templateDataParams.sliceSize + templateDataParams.tailSize)
227 0 : + buffInfo_.scratchBuffBaseOff;
228 0 : std::vector<DataSlice> srcDstSlices;
229 0 : srcDstSlices.reserve(sliceCount);
230 :
231 0 : for (u32 j = 0; j < linkNum; j++) {
232 0 : srcDstSlices.clear();
233 0 : for (u32 i = 0; i < sliceCount; i++) {
234 0 : u64 srcDstOffset = baseOffset + stepInfo.rxSliceIdxs[i] * templateDataParams.sliceSize;
235 0 : DataSlice srcDstSlice(templateDataParams.buffInfo.scratBuffType, srcDstOffset, sliceSize);
236 0 : srcDstSlices.emplace_back(CalcDataSliceForLinks(srcDstSlice, dataSplitRate, j, dataType_));
237 : }
238 0 : SlicesList rxSlicesList(srcDstSlices, srcDstSlices);
239 0 : DataInfo recvData(linkRecv[j], std::move(rxSlicesList));
240 0 : CHK_PRT_RET(Recv(recvData, tempInsQues[j], 0, true, dmaMode_),
241 : HCCL_ERROR("[InsTempScatterNHR] BatchTxRx Recv failed"), HcclResult::HCCL_E_INTERNAL);
242 0 : }
243 :
244 0 : return HcclResult::HCCL_SUCCESS;
245 0 : }
246 :
247 0 : HcclResult InsTempScatterNHR::BatchSR(AicpuNHRStepInfo &stepInfo, const ResLinks &tempLinks,
248 : std::vector<InsQuePtr> &tempInsQues, TemplateDataParams &templateDataParams, u32 repeat) const
249 : {
250 0 : const std::vector<LinkData> &linkRecv = tempLinks.at(stepInfo.fromRank);
251 0 : const std::vector<LinkData> &linkSend = tempLinks.at(stepInfo.toRank);
252 :
253 0 : HCCL_INFO("BatchSR(stepInfo.fromRank)=%u", stepInfo.fromRank);
254 0 : u32 linkNum = rank2PathNumMap_.at(stepInfo.fromRank);
255 0 : if (linkNum > linkRecv.size()) {
256 0 : HCCL_ERROR("InsTempScatterNHR::RunMesh linkNum > linkRecv.size()");
257 0 : return HcclResult::HCCL_E_INTERNAL;
258 : }
259 0 : std::vector<float> dataSplitRate(linkNum);
260 0 : CHK_RET(CalcDataSplitRateForLinks(linkRecv, dataSplitRate));
261 :
262 0 : const u32 txSliceCount = stepInfo.txSliceIdxs.size();
263 0 : const u32 rxSliceCount = stepInfo.rxSliceIdxs.size();
264 0 : std::vector<DataSlice> txSrcDstSlices;
265 0 : std::vector<DataSlice> rxSrcDstSlices;
266 0 : txSrcDstSlices.reserve(txSliceCount);
267 0 : rxSrcDstSlices.reserve(rxSliceCount);
268 : u32 myAlgRank;
269 0 : GetAlgRank(myRank_, tempVTopo_[0], myAlgRank);
270 : // root卡需要将发送的数据刷新为尾部数据长度,保护一下tailSize=0认为没有
271 0 : u64 tailSize = templateDataParams.tailSize == 0 ? templateDataParams.sliceSize : templateDataParams.tailSize;
272 : // 支持不均匀切分的情况下需要把尾部数据放到最后一张卡上
273 0 : u64 sliceSize = myAlgRank == tempVTopo_[0].size() - 1 ? tailSize : templateDataParams.sliceSize;
274 0 : const u64 baseOffset = repeat * ((tempRankSize_ - 1) * templateDataParams.sliceSize + tailSize)
275 0 : + buffInfo_.scratchBuffBaseOff;
276 :
277 0 : for (u32 j = 0; j < linkNum; j++) {
278 0 : txSrcDstSlices.clear();
279 0 : rxSrcDstSlices.clear();
280 0 : for (u32 i = 0; i < txSliceCount; i++) {
281 0 : u64 srcDstOffset = baseOffset + stepInfo.txSliceIdxs[i] * templateDataParams.sliceSize;
282 0 : u64 sliceSize = templateDataParams.sliceSize;
283 0 : DataSlice txSrcDstSlice(templateDataParams.buffInfo.scratBuffType, srcDstOffset, sliceSize);
284 0 : txSrcDstSlices.emplace_back(CalcDataSliceForLinks(txSrcDstSlice, dataSplitRate, j, dataType_));
285 : }
286 0 : SlicesList txSlicesList(txSrcDstSlices, txSrcDstSlices);
287 0 : for (u32 i = 0; i < rxSliceCount; i++) {
288 0 : u64 srcDstOffset = baseOffset + stepInfo.rxSliceIdxs[i] * templateDataParams.sliceSize;
289 0 : DataSlice rxSrcDstSlice(templateDataParams.buffInfo.scratBuffType, srcDstOffset, sliceSize);
290 0 : rxSrcDstSlices.emplace_back(CalcDataSliceForLinks(rxSrcDstSlice, dataSplitRate, j, dataType_));
291 : }
292 0 : SlicesList rxSlicesList(rxSrcDstSlices, rxSrcDstSlices);
293 0 : TxRxSlicesList txRxSlicesList(std::move(txSlicesList), std::move(rxSlicesList));
294 0 : TxRxLinks sendRecvLinks(linkSend[j], linkRecv[j]);
295 0 : SendRecvInfo sendRecvInfo(sendRecvLinks, std::move(txRxSlicesList));
296 0 : CHK_PRT_RET(SendRecv(sendRecvInfo, tempInsQues[j], 0, true, dmaMode_),
297 : HCCL_ERROR("[InsTempScatterNHR] sendrecv failed (j=%u)", j), HcclResult::HCCL_E_INTERNAL);
298 0 : }
299 0 : return HcclResult::HCCL_SUCCESS;
300 0 : }
301 :
302 : // NHR每步的算法描述原理函数
303 0 : HcclResult InsTempScatterNHR::GetStepInfo(u32 step, u32 nSteps, AicpuNHRStepInfo &stepInfo) const
304 : {
305 0 : u32 rankSize = tempRankSize_;
306 : u32 myAlgRank;
307 : u32 rootAlgRank;
308 0 : GetAlgRank(myRank_, tempVTopo_[0], myAlgRank);
309 0 : GetAlgRank(root_, tempVTopo_[0], rootAlgRank);
310 0 : stepInfo.txSliceIdxs.clear();
311 0 : stepInfo.rxSliceIdxs.clear();
312 0 : stepInfo.nSlices = 0;
313 0 : stepInfo.toRank = rankSize;
314 0 : stepInfo.fromRank = rankSize;
315 0 : stepInfo.step = step;
316 0 : stepInfo.myRank = myRank_;
317 :
318 0 : u32 deltaRoot = (rootAlgRank + rankSize - myAlgRank) % rankSize;
319 0 : u32 deltaRankPair = 1 << step;
320 :
321 : // 数据份数和数据编号增量
322 0 : u32 nSlices = (rankSize - 1 + (1 << step)) / (1 << (step + 1));
323 0 : u32 deltaSliceIndex = 1 << (step + 1);
324 :
325 : // 判断是否是2的幂
326 0 : u32 nRanks = 0; // 本步需要进行收/发的rank数
327 0 : bool isPerfect = (rankSize & (rankSize - 1)) == 0;
328 0 : if (!isPerfect && step == nSteps - 1) {
329 0 : nRanks = rankSize - deltaRankPair;
330 : } else {
331 0 : nRanks = deltaRankPair;
332 : }
333 :
334 0 : if (deltaRoot < nRanks) { // 需要发
335 0 : u32 sendTo = (myAlgRank + rankSize - deltaRankPair) % rankSize;
336 0 : u32 txSliceIdx = sendTo;
337 0 : for (u32 i = 0; i < nSlices; i++) {
338 0 : u32 targetTxSliceIdx = txSliceIdx;
339 0 : stepInfo.txSliceIdxs.push_back(targetTxSliceIdx);
340 0 : txSliceIdx = (txSliceIdx + rankSize - deltaSliceIndex) % rankSize;
341 : }
342 :
343 0 : stepInfo.toRank = tempVTopo_[0][sendTo];
344 0 : stepInfo.nSlices = nSlices;
345 0 : } else if (deltaRoot >= deltaRankPair && deltaRoot < nRanks + deltaRankPair) { // 需要收
346 0 : u32 recvFrom = (myAlgRank + deltaRankPair) % rankSize;
347 0 : u32 rxSliceIdx = myAlgRank;
348 0 : for (u32 i = 0; i < nSlices; i++) {
349 0 : u32 targetRxSliceIdx = rxSliceIdx;
350 0 : stepInfo.rxSliceIdxs.push_back(targetRxSliceIdx);
351 0 : rxSliceIdx = (rxSliceIdx + rankSize - deltaSliceIndex) % rankSize;
352 : }
353 :
354 0 : stepInfo.fromRank = tempVTopo_[0][recvFrom];
355 0 : stepInfo.nSlices = nSlices;
356 : }
357 0 : return HcclResult::HCCL_SUCCESS;
358 : }
359 :
360 : } // namespace Hccl
|
