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