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_temp_scatter_mesh_2d.h"
15 :
16 : const u32 CONST_NUM_TWO = 2;
17 :
18 : namespace Hccl {
19 0 : InsTempScatterMesh2D::InsTempScatterMesh2D(
20 : const RankId virtualRank, const u32 tempRankSize, const std::vector<std::vector<RankId>>& tempVTopo,
21 0 : const std::map<RankId, u32>& tempVirtRankMap)
22 0 : : InsAlgTemplateBase(virtualRank, tempRankSize, tempVTopo, tempVirtRankMap)
23 0 : {}
24 :
25 0 : InsTempScatterMesh2D::~InsTempScatterMesh2D() {}
26 :
27 0 : HcclResult InsTempScatterMesh2D::CalcRes(AlgTempResReq& tempResReq)
28 : {
29 0 : HCCL_DEBUG("Enter InsTempScatterMesh2D::CalcRes");
30 :
31 : // 计算所需streamNum
32 0 : u32 queNum = (tempVTopo_[0].size() + tempVTopo_[1].size()) - CONST_NUM_TWO;
33 0 : tempResReq.queNum = queNum > 0 ? queNum : 1;
34 0 : tempResReq.streamNum = queNum;
35 0 : tempResReq.queNotifys = CreateMasterSlaveQueNotifiesRequest(tempResReq.queNum);
36 :
37 0 : HCCL_DEBUG("InsTempScatterMesh2D::CalcRes queNotifys size[%zu]", tempResReq.queNotifys.size());
38 :
39 0 : QId centerQ = 0;
40 0 : tempResReq.localWaitGroupCntNotify.emplace_back(centerQ, 0);
41 0 : tempResReq.localBcastPostCntNotify.emplace_back(centerQ, 0);
42 :
43 : // 计算建链关系
44 : uint32_t myAlgRank;
45 0 : for (u32 dim = 0; dim < tempVTopo_.size(); dim++) {
46 0 : CHK_RET(GetAlgRank(myRank_, tempVTopo_[dim], myAlgRank));
47 0 : for (u32 queIdx = 0; queIdx < tempVTopo_[dim].size() - 1; queIdx++) {
48 : // find neighbors -> virtualRank
49 0 : u32 neighborAlgRank = (myAlgRank + 1 + queIdx) % (tempVTopo_[dim].size());
50 0 : if (neighborAlgRank > (tempVTopo_[dim].size() - 1)) {
51 0 : HCCL_ERROR(
52 : "[CollAlgFactory] [InsTempScatterMesh2D] neighborAlgRank[%u] is invalid,"
53 : "the Max rank[%zu].",
54 : neighborAlgRank, tempVTopo_[dim].size() - 1);
55 0 : return HcclResult::HCCL_E_PARA;
56 : }
57 :
58 0 : RankId neighborRank = tempVTopo_[dim][neighborAlgRank];
59 0 : HCCL_DEBUG(
60 : "[CollAlgFactory] [InsTempScatterMesh2D] Rank[%d], Dim[%u], NeighborRank[%d].", myRank_, dim,
61 : neighborRank);
62 : // LinkNum
63 0 : tempResReq.links[neighborRank] = 1;
64 : }
65 : }
66 :
67 0 : HCCL_INFO("InsTempScatterMesh2D::CalcRes done");
68 0 : return HcclResult::HCCL_SUCCESS;
69 : }
70 :
71 0 : u32 InsTempScatterMesh2D::CalcScratchMultiple(BufferType inBuffType, BufferType outBuffType) const
72 : {
73 : (void)inBuffType;
74 : (void)outBuffType;
75 :
76 0 : return tempRankSize_;
77 : }
78 :
79 0 : HcclResult InsTempScatterMesh2D::GenExtIns(
80 : TempFuncs& tempFuncs, TemplateDataParams& tempAlgParams, ResLinks& tempResLinks,
81 : std::vector<InsQuePtr>& tempInsQues)
82 : {
83 0 : HCCL_INFO("[InsScatterMesh2D][GenExtIns] Root[%u] Rank[%d], start.", root_, myRank_);
84 0 : opMode_ = tempFuncs.opMode;
85 0 : enableCounterNotify_ = tempFuncs.enableCounterNotify;
86 :
87 0 : queNum_ = (tempVTopo_[0].size() + tempVTopo_[1].size()) - CONST_NUM_TWO;
88 0 : CHK_PRT_RET(
89 : queNum_ != tempInsQues.size(),
90 : HCCL_ERROR("[CollAlgFactory] [InsTempScatterMesh2D] Rank [%d], requiredQue Error.", myRank_),
91 : HcclResult::HCCL_E_INTERNAL);
92 :
93 0 : if (tempVTopo_.size() < CONST_NUM_TWO) {
94 0 : HCCL_DEBUG("[InsTempScatterMesh2D] The size Of tempVTopo_ is less than two.");
95 0 : return HcclResult::HCCL_E_PARA;
96 : }
97 :
98 0 : xRankSize_ = tempVTopo_[0].size(); // x轴的ranksize
99 0 : yRankSize_ = tempVTopo_[1].size(); // y轴的ranksize
100 0 : xQueNum_ = tempVTopo_[0].size() - 1; // x轴的streamNum
101 0 : yQueNum_ = tempVTopo_[1].size() - 1; // y轴的streamNum
102 :
103 0 : for (u32 queIdx = 0; queIdx < queNum_; queIdx++) {
104 0 : if (queIdx < xQueNum_) {
105 0 : xInsQues_.push_back(tempInsQues[queIdx]);
106 : } else {
107 0 : yInsQues_.push_back(tempInsQues[queIdx]);
108 : }
109 : }
110 :
111 0 : CHK_RET(GetAlgRank(myRank_, tempVTopo_[0], myRankX_));
112 0 : CHK_RET(GetAlgRank(myRank_, tempVTopo_[1], myRankY_));
113 : // root节点的x, y坐标
114 0 : rootX_ = root_ % xRankSize_;
115 0 : rootY_ = root_ / xRankSize_;
116 :
117 0 : if (static_cast<u32>(myRank_) == root_ || tempRankSize_ == 1) {
118 : // if root Copy from Input to Output
119 0 : CHK_RET(PreDataCopy(tempAlgParams, tempInsQues));
120 : }
121 :
122 0 : u64 xDataSize = tempAlgParams.sliceSize / 2;
123 0 : u64 yDataSize = tempAlgParams.sliceSize - xDataSize;
124 :
125 : // 主从流前同步
126 0 : CHK_RET(PreSyncInterQueues(tempInsQues));
127 : // first Step
128 0 : if (static_cast<u32>(myRank_) == root_) {
129 : // root发送直达和中转数据块
130 0 : CHK_RET(RootMeshSend(tempAlgParams, tempResLinks, tempVTopo_[0], yRankSize_, 0, 1, 0, xDataSize, xInsQues_));
131 0 : CHK_RET(RootMeshSend(
132 : tempAlgParams, tempResLinks, tempVTopo_[1], xRankSize_, 1, 0, xDataSize, yDataSize, yInsQues_));
133 0 : } else if (myRankX_ == rootX_) {
134 : // root直连rank接收数据块
135 0 : CHK_RET(RankRecvFromRoot(tempAlgParams, tempResLinks, xRankSize_, 1, xDataSize, yDataSize, tempInsQues));
136 0 : } else if (myRankY_ == rootY_) {
137 : // root直连rank接收数据块
138 0 : CHK_RET(RankRecvFromRoot(tempAlgParams, tempResLinks, yRankSize_, xRankSize_, 0, xDataSize, tempInsQues));
139 : }
140 :
141 : // 主从流后同步
142 0 : CHK_RET(PostSyncInterQueues(tempInsQues));
143 0 : CHK_RET(PreSyncInterQueues(tempInsQues));
144 :
145 : // second
146 0 : if (static_cast<u32>(myRank_) != root_) {
147 : // 中转数据块的收发
148 0 : CHK_RET(RunDataCombine(tempAlgParams, tempResLinks, xDataSize, yDataSize, tempInsQues));
149 : }
150 :
151 0 : CHK_RET(PostSyncInterQueues(tempInsQues));
152 :
153 0 : if (static_cast<u32>(myRank_) != root_) {
154 : // if root Copy from Scratch to Output
155 0 : CHK_RET(PostDataCopy(tempAlgParams, tempInsQues));
156 : }
157 :
158 0 : HCCL_INFO("[InsScatterMesh2D][GenExtIns] Root[%u] Rank[%d], success.", root_, myRank_);
159 0 : return HcclResult::HCCL_SUCCESS;
160 : }
161 :
162 : HcclResult
163 0 : InsTempScatterMesh2D::PreDataCopy(const TemplateDataParams& tempAlgParams, std::vector<InsQuePtr>& tempInsQues) const
164 : {
165 0 : u64 inOffset = tempAlgParams.inputSliceStride * myRank_ + tempAlgParams.buffInfo.inBuffBaseOff;
166 :
167 0 : DataSlice usrInSlice = DataSlice(BufferType::INPUT, inOffset, tempAlgParams.sliceSize);
168 : DataSlice usrOutSlice
169 0 : = DataSlice(BufferType::OUTPUT, tempAlgParams.buffInfo.outBuffBaseOff, tempAlgParams.sliceSize);
170 :
171 0 : HCCL_INFO("PreCopy usrInSlice: %s, usrOutSlice: %s", usrInSlice.Describe().c_str(), usrOutSlice.Describe().c_str());
172 :
173 0 : CHK_RET(LocalCopy(tempInsQues[0], usrInSlice, usrOutSlice));
174 :
175 0 : return HcclResult::HCCL_SUCCESS;
176 : }
177 :
178 : HcclResult
179 0 : InsTempScatterMesh2D::PostDataCopy(const TemplateDataParams& tempAlgParams, std::vector<InsQuePtr>& tempInsQues) const
180 : {
181 0 : u64 inOffset = tempAlgParams.sliceSize * myRank_ + tempAlgParams.buffInfo.scratchBuffBaseOff;
182 :
183 0 : DataSlice usrInSlice = DataSlice(BufferType::SCRATCH, inOffset, tempAlgParams.sliceSize);
184 : DataSlice usrOutSlice
185 0 : = DataSlice(BufferType::OUTPUT, tempAlgParams.buffInfo.outBuffBaseOff, tempAlgParams.sliceSize);
186 :
187 0 : HCCL_INFO(
188 : "PostCopy usrInSlice: %s, usrOutSlice: %s", usrInSlice.Describe().c_str(), usrOutSlice.Describe().c_str());
189 :
190 0 : CHK_RET(LocalCopy(tempInsQues[0], usrInSlice, usrOutSlice));
191 :
192 0 : return HcclResult::HCCL_SUCCESS;
193 : }
194 :
195 0 : HcclResult InsTempScatterMesh2D::RootMeshSend(
196 : TemplateDataParams& tempAlgParams, ResLinks& tempResLinks, const std::vector<RankId> vTopo, const u32 xyRankSize,
197 : u32 rankDistX, u32 rankDistY, u64 dataOffSet, u64 tranDataSize, std::vector<InsQuePtr>& tempInsQues) const
198 : {
199 0 : HCCL_DEBUG("[InsTempScatterMesh2D] Entry RootMeshSend");
200 :
201 0 : u32 insQueIndex = 0;
202 0 : for (u32 i = 0; i < vTopo.size(); i++) {
203 0 : u32 remoteRank = vTopo[i];
204 0 : if (static_cast<RankId>(remoteRank) == myRank_) {
205 0 : continue;
206 : }
207 0 : CHK_RET(SendDirect(tempAlgParams, tempInsQues[insQueIndex], tempResLinks[remoteRank][0], remoteRank));
208 0 : CHK_RET(SendTransit(
209 : tempAlgParams, tempInsQues[insQueIndex], tempResLinks[remoteRank][0], remoteRank, xyRankSize, rankDistX,
210 : rankDistY, dataOffSet, tranDataSize));
211 :
212 0 : insQueIndex++;
213 : }
214 :
215 0 : HCCL_DEBUG("[InsTempScatterMesh2D] RootMeshSend Done");
216 :
217 0 : return HcclResult::HCCL_SUCCESS;
218 : }
219 :
220 0 : HcclResult InsTempScatterMesh2D::RankRecvFromRoot(
221 : TemplateDataParams& tempAlgParams, ResLinks& tempResLinks, const u32 xyRankSize, u32 rankDist, u64 dataOffSet,
222 : u64 tranDataSize, std::vector<InsQuePtr>& tempInsQues) const
223 : {
224 0 : HCCL_DEBUG("[InsTempScatterMesh2D] Entry RankRecvFromRoot");
225 :
226 0 : CHK_RET(RecvDirect(tempAlgParams, tempInsQues[0], tempResLinks[root_][0], root_));
227 0 : CHK_RET(RecvTransit(
228 : tempAlgParams, tempInsQues[0], tempResLinks[root_][0], root_, xyRankSize, rankDist, dataOffSet, tranDataSize));
229 :
230 0 : HCCL_DEBUG("[InsTempScatterMesh2D] RankRecvFromRoot Done");
231 :
232 0 : return HcclResult::HCCL_SUCCESS;
233 : }
234 :
235 0 : HcclResult InsTempScatterMesh2D::RunDataCombine(
236 : TemplateDataParams& tempAlgParams, ResLinks& tempResLinks, u64 tranDataSizeX, u64 tranDataSizeY,
237 : std::vector<InsQuePtr>& tempInsQues)
238 : {
239 0 : HCCL_DEBUG("[InsTempScatterMesh2D] Entry RunDataCombine");
240 :
241 0 : if (myRankX_ == rootX_) {
242 0 : CHK_RET(DataCombineSend(tempAlgParams, tempResLinks, tempVTopo_[0], tranDataSizeX, tranDataSizeY, tempInsQues));
243 0 : } else if (myRankY_ == rootY_) {
244 0 : CHK_RET(DataCombineSend(tempAlgParams, tempResLinks, tempVTopo_[1], 0, tranDataSizeX, tempInsQues));
245 : } else {
246 : // 通过x, y坐标计算rank
247 0 : u32 recvSrcRank = 0;
248 0 : CHK_RET(GetRankId(rootX_, myRankY_, recvSrcRank));
249 0 : CHK_RET(
250 : DataCombineRecv(tempAlgParams, tempResLinks[recvSrcRank][0], tranDataSizeX, tranDataSizeY, tempInsQues[0]));
251 :
252 0 : CHK_RET(GetRankId(myRankX_, rootY_, recvSrcRank));
253 0 : CHK_RET(DataCombineRecv(tempAlgParams, tempResLinks[recvSrcRank][0], 0, tranDataSizeX, tempInsQues[0]));
254 : }
255 :
256 0 : HCCL_DEBUG("[InsTempScatterMesh2D] RunDataCombine Done");
257 :
258 0 : return HcclResult::HCCL_SUCCESS;
259 : }
260 :
261 0 : HcclResult InsTempScatterMesh2D::DataCombineSend(
262 : const TemplateDataParams& tempAlgParams, ResLinks& tempResLinks, const std::vector<RankId> vTopo, u64 dataOffSet,
263 : u64 tranDataSize, std::vector<InsQuePtr>& tempInsQues) const
264 : {
265 0 : HCCL_DEBUG("[InsTempScatterMesh2D] Entry DataCombineSend");
266 :
267 0 : u32 insQueIndex = 0;
268 :
269 0 : for (u32 i = 0; i < vTopo.size(); i++) {
270 0 : u32 remoteRank = vTopo[i];
271 0 : if (static_cast<RankId>(remoteRank) == myRank_) {
272 0 : continue;
273 : }
274 :
275 0 : std::vector<DataSlice> txSrcSlices;
276 0 : std::vector<DataSlice> txDstSlices;
277 :
278 0 : u64 txSrcOffset = tempAlgParams.sliceSize * remoteRank + tempAlgParams.buffInfo.scratchBuffBaseOff + dataOffSet;
279 0 : u64 txDstOffset = tempAlgParams.sliceSize * remoteRank + tempAlgParams.buffInfo.scratchBuffBaseOff + dataOffSet;
280 :
281 0 : BufferType txSrcBuffType = BufferType::SCRATCH;
282 0 : BufferType txDtsBuffType = BufferType::SCRATCH;
283 :
284 0 : txSrcSlices.emplace_back(txSrcBuffType, txSrcOffset, tranDataSize);
285 0 : txDstSlices.emplace_back(txDtsBuffType, txDstOffset, tranDataSize);
286 :
287 0 : SlicesList sendDataSlice(txSrcSlices, txDstSlices);
288 0 : DataInfo sendDataInfo(tempResLinks[remoteRank][0], sendDataSlice);
289 :
290 0 : CHK_RET(Send(sendDataInfo, tempInsQues[insQueIndex++], 0, true, DmaMode::PUT));
291 0 : }
292 :
293 0 : HCCL_DEBUG("[InsTempScatterMesh2D] DataCombineSend Done");
294 :
295 0 : return HcclResult::HCCL_SUCCESS;
296 : }
297 :
298 0 : HcclResult InsTempScatterMesh2D::DataCombineRecv(
299 : const TemplateDataParams& tempAlgParams, LinkData link, u64 dataOffSet, u64 tranDataSize, InsQuePtr queue) const
300 : {
301 0 : HCCL_DEBUG("[InsTempScatterMesh2D] Entry DataCombineRecv");
302 :
303 0 : std::vector<DataSlice> rxSrcSlices;
304 0 : std::vector<DataSlice> rxDstSlices;
305 :
306 0 : u64 rxSrcOffset = tempAlgParams.sliceSize * myRank_ + tempAlgParams.buffInfo.scratchBuffBaseOff + dataOffSet;
307 0 : u64 rxDstOffset = tempAlgParams.sliceSize * myRank_ + tempAlgParams.buffInfo.scratchBuffBaseOff + dataOffSet;
308 :
309 0 : BufferType txSrcBuffType = BufferType::SCRATCH;
310 0 : BufferType txDtsBuffType = BufferType::SCRATCH;
311 :
312 0 : rxSrcSlices.emplace_back(txSrcBuffType, rxSrcOffset, tranDataSize);
313 0 : rxDstSlices.emplace_back(txDtsBuffType, rxDstOffset, tranDataSize);
314 :
315 0 : SlicesList rendDataSlice(rxSrcSlices, rxDstSlices);
316 0 : DataInfo rendDataInfo(link, rendDataSlice);
317 :
318 0 : CHK_RET(Recv(rendDataInfo, queue, 0, true, DmaMode::PUT));
319 :
320 0 : HCCL_DEBUG("[InsTempScatterMesh2D] DataCombineRecv Done");
321 :
322 0 : return HcclResult::HCCL_SUCCESS;
323 0 : }
324 :
325 0 : HcclResult InsTempScatterMesh2D::GetRankId(u32 xRank, u32 yRank, u32& rank) const
326 : {
327 0 : rank = (yRank * xRankSize_ + xRank) % tempRankSize_;
328 :
329 0 : return HcclResult::HCCL_SUCCESS;
330 : }
331 :
332 0 : HcclResult InsTempScatterMesh2D::SendDirect(
333 : TemplateDataParams& tempAlgParams, InsQuePtr queue, const LinkData link, u32 remoteRank) const
334 : {
335 : // 发送直达数据块
336 0 : HCCL_DEBUG("[InsTempScatterMesh2D] Entry SendDirect");
337 :
338 0 : std::vector<DataSlice> txSrcSlices;
339 0 : std::vector<DataSlice> txDstSlices;
340 :
341 0 : u64 txSrcOffset = tempAlgParams.inputSliceStride * remoteRank + tempAlgParams.buffInfo.inBuffBaseOff;
342 0 : u64 txDstOffset = tempAlgParams.sliceSize * remoteRank + tempAlgParams.buffInfo.scratchBuffBaseOff;
343 :
344 0 : txSrcSlices.emplace_back(BufferType::INPUT, txSrcOffset, tempAlgParams.sliceSize);
345 0 : txDstSlices.emplace_back(BufferType::SCRATCH, txDstOffset, tempAlgParams.sliceSize);
346 :
347 0 : SlicesList sendDataSlice(txSrcSlices, txDstSlices);
348 0 : DataInfo sendDataInfo(link, sendDataSlice);
349 :
350 0 : CHK_RET(Send(sendDataInfo, queue, 0, true, DmaMode::PUT));
351 :
352 0 : HCCL_DEBUG("[InsTempScatterMesh2D] SendDirect Done");
353 :
354 0 : return HcclResult::HCCL_SUCCESS;
355 0 : }
356 :
357 0 : HcclResult InsTempScatterMesh2D::SendTransit(
358 : const TemplateDataParams& tempAlgParams, InsQuePtr queue, const LinkData link, u32 remoteRank, u32 xyRankSize,
359 : u32 rankDistX, u32 rankDistY, u64 xyOffSet, u64 tranDataSize) const
360 : {
361 : // 发送中转数据块
362 0 : u32 remoteRankX = remoteRank % xRankSize_;
363 0 : u32 remoteRankY = remoteRank / xRankSize_;
364 :
365 0 : for (u32 i = 0; i < xyRankSize - 1; i++) {
366 0 : remoteRankX = (remoteRankX + rankDistX) % xRankSize_;
367 0 : remoteRankY = (remoteRankY + rankDistY) % yRankSize_;
368 :
369 0 : u32 tranRank = 0;
370 0 : CHK_RET(GetRankId(remoteRankX, remoteRankY, tranRank));
371 :
372 0 : std::vector<DataSlice> txSrcSlices;
373 0 : std::vector<DataSlice> txDstSlices;
374 :
375 0 : u64 inputSrcOffset
376 0 : = tempAlgParams.inputSliceStride * tranRank + tempAlgParams.buffInfo.inBuffBaseOff + xyOffSet;
377 0 : u64 scartSrcOffset = tempAlgParams.sliceSize * tranRank + tempAlgParams.buffInfo.scratchBuffBaseOff + xyOffSet;
378 0 : u64 txDstOffset = tempAlgParams.sliceSize * tranRank + tempAlgParams.buffInfo.scratchBuffBaseOff + xyOffSet;
379 :
380 0 : u64 txSrcOffset = static_cast<u32>(myRank_) == root_ ? inputSrcOffset : scartSrcOffset;
381 :
382 0 : BufferType txSrcBuffType = static_cast<u32>(myRank_) == root_ ? BufferType::INPUT : BufferType::SCRATCH;
383 0 : BufferType txDtsBuffType = BufferType::SCRATCH;
384 :
385 0 : txSrcSlices.emplace_back(txSrcBuffType, txSrcOffset, tranDataSize);
386 0 : txDstSlices.emplace_back(txDtsBuffType, txDstOffset, tranDataSize);
387 :
388 0 : SlicesList sendDataSlice(txSrcSlices, txDstSlices);
389 0 : DataInfo sendDataInfo(link, sendDataSlice);
390 :
391 0 : CHK_RET(Send(sendDataInfo, queue, 0, true, DmaMode::PUT));
392 0 : }
393 :
394 0 : return HcclResult::HCCL_SUCCESS;
395 : }
396 :
397 0 : HcclResult InsTempScatterMesh2D::RecvDirect(
398 : TemplateDataParams& tempAlgParams, InsQuePtr queue, const LinkData link, u32 remoteRank) const
399 : {
400 : // 接收直达数据块
401 0 : std::vector<DataSlice> rxSrcSlices;
402 0 : std::vector<DataSlice> rxDstSlices;
403 :
404 0 : u64 rxSrcOffset = tempAlgParams.inputSliceStride * remoteRank + tempAlgParams.buffInfo.inBuffBaseOff;
405 0 : u64 rxDstOffset = tempAlgParams.sliceSize * remoteRank + tempAlgParams.buffInfo.scratchBuffBaseOff;
406 :
407 0 : rxSrcSlices.emplace_back(BufferType::INPUT, rxSrcOffset, tempAlgParams.sliceSize);
408 0 : rxDstSlices.emplace_back(BufferType::SCRATCH, rxDstOffset, tempAlgParams.sliceSize);
409 :
410 0 : SlicesList recvDataSlice(rxSrcSlices, rxDstSlices);
411 0 : DataInfo recvDataInfo(link, recvDataSlice);
412 :
413 0 : CHK_RET(Recv(recvDataInfo, queue, 0, true, DmaMode::PUT));
414 :
415 0 : return HcclResult::HCCL_SUCCESS;
416 0 : }
417 :
418 0 : HcclResult InsTempScatterMesh2D::RecvTransit(
419 : const TemplateDataParams& tempAlgParams, InsQuePtr queue, const LinkData link, u32 remoteRank, u32 xyRankSize,
420 : u32 rankDist, u64 xyOffSet, u64 tranDataSize) const
421 : {
422 : // 接收直达数据块
423 0 : u32 tranIndex = remoteRank;
424 0 : for (u32 i = 0; i < xyRankSize - 1; i++) {
425 0 : tranIndex += rankDist;
426 0 : std::vector<DataSlice> rxSrcSlices;
427 0 : std::vector<DataSlice> rxDstSlices;
428 :
429 0 : u32 tranRank = tranIndex % tempRankSize_;
430 :
431 0 : u64 inputSrcOffset
432 0 : = tempAlgParams.inputSliceStride * remoteRank + tempAlgParams.buffInfo.inBuffBaseOff + xyOffSet;
433 0 : u64 scratDstOffset
434 0 : = tempAlgParams.sliceSize * remoteRank + tempAlgParams.buffInfo.scratchBuffBaseOff + xyOffSet;
435 0 : u64 rxDstOffset = tempAlgParams.sliceSize * tranRank + tempAlgParams.buffInfo.scratchBuffBaseOff + xyOffSet;
436 :
437 0 : u64 rxSrcOffset = inputSrcOffset;
438 :
439 0 : BufferType txSrcBuffType = BufferType::INPUT;
440 0 : BufferType txDtsBuffType = BufferType::SCRATCH;
441 :
442 0 : if (myRankX_ != rootX_ && myRankY_ != rootY_) {
443 0 : rxSrcOffset = scratDstOffset;
444 0 : txSrcBuffType = BufferType::SCRATCH;
445 : }
446 :
447 0 : rxSrcSlices.emplace_back(txSrcBuffType, rxSrcOffset, tranDataSize);
448 0 : rxDstSlices.emplace_back(txDtsBuffType, rxDstOffset, tranDataSize);
449 :
450 0 : SlicesList rendDataSlice(rxSrcSlices, rxDstSlices);
451 0 : DataInfo rendDataInfo(link, rendDataSlice);
452 :
453 0 : CHK_RET(Recv(rendDataInfo, queue, 0, true, DmaMode::PUT));
454 0 : }
455 :
456 0 : return HcclResult::HCCL_SUCCESS;
457 : }
458 : } // namespace Hccl
|
