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 "coll_scatter_ring_executor.h"
12 :
13 : namespace hccl {
14 0 : CollScatterRingExecutor::CollScatterRingExecutor(
15 0 : const HcclDispatcher dispatcher, std::unique_ptr<TopoMatcher>& topoMatcher)
16 0 : : CollScatterExecutor(dispatcher, topoMatcher)
17 0 : {}
18 :
19 0 : HcclResult CollScatterRingExecutor::CalcLevel0CommInfo(
20 : TransportMemType inputType, TransportMemType outputType, std::vector<LevelNSubCommTransport>& opTransport)
21 : {
22 0 : HCCL_INFO("[CollScatterRingExecutor][CalcLevel0CommInfo]tag[%s] start", tag_.c_str());
23 0 : CommParaInfo commParaLevel0(COMM_LEVEL0, CommType::COMM_TAG_RING_INNER);
24 :
25 0 : CHK_RET(CalcCommPlaneInfo(tag_, commParaLevel0, opTransport[COMM_LEVEL0], inputType, outputType));
26 0 : HCCL_INFO("[CollScatterRingExecutor][CalcLevel0CommInfo]tag[%s] Calc RingComm finish", tag_.c_str());
27 0 : return HCCL_SUCCESS;
28 0 : }
29 :
30 0 : HcclResult CollScatterRingExecutor::CalcStreamNum(u32& streamNum)
31 : {
32 0 : u32 totalStreamNum = LEVEL0_PLANE_NUM_IN_NPRING_SINGLE;
33 0 : if (algType_.algoLevel0 == AlgTypeLevel0::ALG_LEVEL0_8P_RING) {
34 0 : totalStreamNum = LEVEL0_PLANE_NUM_IN_8PRING;
35 : }
36 0 : streamNum = totalStreamNum - 1;
37 0 : HCCL_INFO("[CollScatterRingExecutor][CalcStreamNum] tag[%s] streamNum[%u]", tag_.c_str(), streamNum);
38 0 : return HCCL_SUCCESS;
39 : }
40 :
41 0 : HcclResult CollScatterRingExecutor::KernelRun(const OpParam& param, ExecMem& execMem)
42 : {
43 0 : HCCL_CONFIG_INFO(HCCL_ALG, "[CollScatterRingExecutor] scatter starts.");
44 0 : Stream& stream = const_cast<Stream&>(param.stream);
45 :
46 0 : u32 perDataSize = SIZE_TABLE[param.DataDes.dataType];
47 :
48 0 : SubCommInfo level0CommInfo = GetSubCommInfo(COMM_LEVEL0, COMM_INDEX_0);
49 0 : u32 level0LocalRank = level0CommInfo.localRank;
50 0 : u32 level0LocalRankSize = level0CommInfo.localRankSize;
51 :
52 0 : u32 commIndex = (topoType_ == TopoType::TOPO_TYPE_8P_RING) ? topoAttr_.devicePhyId : level0LocalRank;
53 :
54 0 : CHK_RET(CheckCommSize(COMM_LEVEL1, commIndex + 1));
55 0 : SubCommInfo level1CommInfo = GetSubCommInfo(COMM_LEVEL1, commIndex);
56 0 : u32 level1LocalRank = level1CommInfo.localRank;
57 0 : u32 level1LocalRankSize = level1CommInfo.localRankSize;
58 :
59 0 : bool bRet = level0LocalRankSize == 0;
60 0 : CHK_PRT_RET(
61 : bRet, HCCL_ERROR("[CollScatterRingExecutor][KernelRun]tag[%s],comm level0 is empty", tag_.c_str()),
62 : HCCL_E_INTERNAL);
63 :
64 : /* ***********第一步: 节点间scatter ****************************/
65 0 : u32 subRoot = INVALID_VALUE_RANKID;
66 0 : CHK_RET(topoMatcher_->GetSubRootForScatter(param.root, subRoot));
67 0 : CHK_PRT_RET(
68 : subRoot == INVALID_VALUE_RANKID,
69 : HCCL_ERROR(
70 : "[CollScatterRingExecutor][KernelRun]GetSubRootForScatter failed, "
71 : "userRank[%u], root[%u], subRoot[%u]",
72 : topoAttr_.userRank, param.root, subRoot),
73 : HCCL_E_INTERNAL);
74 0 : HCCL_DEBUG(
75 : "[CollScatterRingExecutor][KernelRun]GetSubRootForScatter, userRank[%u], root[%u], subRoot[%u]",
76 : topoAttr_.userRank, param.root, subRoot);
77 0 : CHK_RET(KernelRunLevel1(
78 : execMem.inputMem, execMem.count, param.DataDes.dataType, commIndex, param.root, subRoot, COMM_LEVEL1, stream));
79 :
80 : /* ***********第二步: 节点内scatter*****************************/
81 0 : u32 sliceNum = level0LocalRankSize;
82 0 : std::vector<Slice> dataSegsSlice;
83 0 : u32 outputOffset = level0LocalRank;
84 0 : CHK_RET(PrepareScatterRingSliceData(execMem.count, perDataSize, sliceNum, dataSegsSlice, outputOffset));
85 :
86 : // 每个server分配的slice大小
87 0 : u64 serverSliceSize = execMem.inputMem.size() / level1LocalRankSize;
88 : // 每个服务器对应的偏移
89 0 : u64 serverSliceOffset = serverSliceSize * level1LocalRank;
90 0 : DeviceMem scatterRingInput = execMem.inputMem.range(serverSliceOffset, serverSliceSize);
91 0 : CHK_SMART_PTR_NULL(scatterRingInput);
92 0 : DeviceMem scatterRingOutput = execMem.inputMem.range(serverSliceOffset, serverSliceSize);
93 0 : CHK_SMART_PTR_NULL(scatterRingOutput);
94 :
95 : std::unique_ptr<AlgTemplateBase> level0TempAlg
96 0 : = AlgTemplateRegistry::Instance().GetAlgTemplate(TemplateType::TEMPLATE_SCATTER_RING, dispatcher_);
97 0 : CHK_SMART_PTR_NULL(level0TempAlg);
98 0 : HCCL_CONFIG_INFO(HCCL_ALG, "[%s] Run TEMPLATE_SCATTER_RING in COMM_LEVEL0", __func__);
99 :
100 : // 偏移需要带入prepare
101 0 : u32 rootRankLevel0 = 0;
102 0 : CHK_RET(GetRankByUserRank(COMM_LEVEL0, COMM_INDEX_0, subRoot, rootRankLevel0));
103 0 : CHK_PRT_RET(
104 : rootRankLevel0 == INVALID_VALUE_RANKID,
105 : HCCL_ERROR(
106 : "[CollScatterRingExecutor][KernelRun]rootRankLevel0[%u] is invalid, userRank[%u], subRoot[%u]",
107 : rootRankLevel0, topoAttr_.userRank, subRoot),
108 : HCCL_E_INTERNAL);
109 :
110 0 : CHK_RET(level0TempAlg->Prepare(
111 : scatterRingInput, scatterRingOutput, execMem.inputMem, execMem.count, param.DataDes.dataType, stream,
112 : HCCL_REDUCE_RESERVED, rootRankLevel0, dataSegsSlice, serverSliceOffset));
113 :
114 0 : HcclResult ret = RunTemplate(level0TempAlg, level0CommInfo);
115 0 : CHK_PRT_RET(
116 : ret != HCCL_SUCCESS,
117 : HCCL_ERROR("[CollScatterRingExecutor][KernelRun]scatter(ring) RunTemplate failed,return[%d]", ret), ret);
118 :
119 : // 将scratchMem赋值给outputMem
120 0 : u8* scatterRingOutputPtr = static_cast<u8*>(scatterRingOutput.ptr());
121 0 : DeviceMem resultMem(scatterRingOutputPtr + execMem.outputMem.size() * outputOffset, execMem.outputMem.size());
122 0 : CHK_RET(HcclD2DMemcpyAsync(dispatcher_, execMem.outputMem, resultMem, stream));
123 0 : return HCCL_SUCCESS;
124 0 : }
125 :
126 0 : HcclResult CollScatterRingExecutor::PrepareScatterRingSliceData(
127 : u64 dataCount, u32 unitSize, u32 sliceNum, std::vector<Slice>& dataSlice, u32& outputOffset)
128 : {
129 0 : CHK_PRT_RET(
130 : (sliceNum == 0), HCCL_ERROR("[CollScatterRingExecutor][PrepareScatterRingSliceData]sliceNum is zero."),
131 : HCCL_E_PARA);
132 :
133 : // 根据数据量算每个环上数据的偏移和大小
134 0 : CHK_RET(PrepareDataSlice(dataCount, unitSize, sliceNum, dataSlice));
135 :
136 0 : if (topoType_ == TopoType::TOPO_TYPE_8P_RING) {
137 0 : std::vector<u32> tmpRing0 = {0, 1, 2, 6, 5, 4, 7, 3};
138 0 : outputOffset = tmpRing0[outputOffset];
139 0 : CHK_RET(ReorderSlice(dataSlice, tmpRing0));
140 0 : }
141 0 : return HCCL_SUCCESS;
142 : }
143 :
144 : REGISTER_EXEC("ScatterRingExecutor", ScatterRing, CollScatterRingExecutor);
145 :
146 : } // namespace hccl
|
