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 <ios>
      12              : #include <iostream>
      13              : 
      14              : #include "log.h"
      15              : 
      16              : #include "ccu_instruction_broadcast_mesh2d_mem2mem.h"
      17              : #include "ccu_rank_group.h"
      18              : #include "ccu_ctx_creator_registry.h"
      19              : #include "ccu_ins_group.h"
      20              : #include "ccu_context_broadcast_mesh2d_mem2mem.h"
      21              : #include "ccu_temp_broadcast_mesh_2D_mem2mem.h"
      22              : #include "template_utils.h"
      23              : namespace Hccl {
      24              : 
      25              : static CcuInstRegister<CcuContextBroadcastMeshMem2Mem2D>
      26              :     g_registrarBroadcastMesh2D_Mem2mem(CcuInstType::CCU_BROADCAST_MESH_2D_MEM2MEM);
      27              : 
      28            0 : CcuTempBroadcastMeshMem2Mem2D::CcuTempBroadcastMeshMem2Mem2D(
      29              :     const RankId virtualRank, const u32 tempRankSize, const std::vector<std::vector<RankId>>& tempVTopo,
      30            0 :     const std::map<RankId, u32>& tempVirtRankMap)
      31            0 :     : CcuAlgTemplateBase(virtualRank, tempRankSize, tempVTopo, tempVirtRankMap)
      32              : {
      33            0 :     if (tempVTopo_.size() != NUM_TWO || tempVTopo_[0].size() <= 1
      34            0 :         || tempVTopo_[1].size() <= 1) { // concurrmesh的topoMatch返回的vTopo大小应当为2，对应X轴和Y轴的大小
      35            0 :         THROW<InvalidParamsException>(StringFormat(
      36              :             "[CcuTempBroadcastMeshMem2Mem2D] Rank[%d], Invalid tempVTopo "
      37              :             "Size[%u] or Invalid tempVTopo[0] size [%u] or tempVTopo[1] size [%u].",
      38            0 :             myRank_, tempVTopo_.size(), tempVTopo_[0].size(), tempVTopo_[1].size()));
      39              :     }
      40            0 :     dimSize_.emplace_back(tempVTopo[0].size());
      41            0 :     dimSize_.emplace_back(tempVTopo[1].size());
      42            0 : }
      43              : 
      44            0 : CcuTempBroadcastMeshMem2Mem2D::~CcuTempBroadcastMeshMem2Mem2D() {}
      45              : 
      46            0 : HcclResult CcuTempBroadcastMeshMem2Mem2D::CalcRes(AlgTempResReq& tempResReq)
      47              : {
      48              :     // 按照IODienum来确定stream数量，支持2D和2D的template
      49            0 :     tempResReq.queNum = 1; // 只申请一个insQue，填充一个insGroup，由框架将其中的ins放在多个stream上
      50            0 :     tempResReq.streamNum = tempResReq.queNum + 1; // 多申请一个 stream 给 ccuInsGroup
      51            0 :     uint32_t dieNum = tempVTopo_.size();
      52            0 :     if (dieNum != NUM_TWO) { // concurrmesh的topoMatch返回的vTopo大小应当为2，对应X轴和Y轴的大小
      53            0 :         HCCL_ERROR("[CcuTempBroadcastMeshMem2Mem2D] Rank[%d], Invalid IODieNum[%zu].", myRank_, tempVTopo_.size());
      54            0 :         return HcclResult::HCCL_E_PARA;
      55              :     }
      56            0 :     HCCL_INFO(
      57              :         "[CcuTempBroadcastMeshMem2Mem2D] Rank[%d] requiredQueNum[%u] VtopoSize[%u], VtopoSize0[%u] VtopoSize1[%u].",
      58              :         myRank_, tempResReq.queNum, tempVTopo_.size(), tempVTopo_[0].size(), tempVTopo_[1].size());
      59              : 
      60              :     uint32_t myAlgRank;
      61            0 :     for (u32 dim = 0; dim < tempVTopo_.size(); dim++) {
      62            0 :         CHK_RET(GetAlgRank(myRank_, tempVTopo_[dim], myAlgRank));
      63            0 :         for (u32 queIdx = 0; queIdx < tempVTopo_[dim].size() - 1; queIdx++) {
      64              :             // find neighbors -> virtualRank
      65            0 :             u32 neighborAlgRank = (myAlgRank + 1 + queIdx) % (tempVTopo_[dim].size());
      66            0 :             RankId neighborRank = tempVTopo_[dim][neighborAlgRank];
      67            0 :             HCCL_INFO(
      68              :                 "[CollAlgFactory] [CcuTempBroadcastMeshMem2Mem2D] Rank[%d], Dim[%u], NeighborRank[%d].", myRank_, dim,
      69              :                 neighborRank);
      70              :             // LinkNum
      71            0 :             tempResReq.links[neighborRank] = 1;
      72              :         }
      73              :     }
      74            0 :     return HcclResult::HCCL_SUCCESS;
      75              : }
      76              : 
      77            0 : HcclResult CcuTempBroadcastMeshMem2Mem2D::PrepareLinks(const ResLinks& tempLinks)
      78              : {
      79              :     // 分别记录两个Die上的link，构造rankGroup
      80            0 :     for (auto pair : tempLinks) {
      81            0 :         if (pair.second.size() == 0 || pair.second[0].GetHop() != 1) { // ESL环境上暂只有直连链路
      82            0 :             THROW<InvalidParamsException>(StringFormat(
      83            0 :                 "[CcuTempBroadcastMeshMem2Mem2D] Rank[%d]--Peer[%d], InvalidHop[%u].", myRank_, pair.first,
      84            0 :                 pair.second[0].GetHop()));
      85              :         }
      86            0 :         if ((pair.first / dimSize_[0] == myRank_ / dimSize_[0]) && pair.second[0].GetHop() == 1) {
      87            0 :             HCCL_INFO(
      88              :                 "[CcuTempBroadcastMeshMem2Mem2D][GenExtIns] Rank[%d] insert link to Rank[%d] in linksX", myRank_,
      89              :                 pair.first);
      90            0 :             linksX_.emplace_back(pair.second[0]);
      91            0 :         } else if ((pair.first % dimSize_[0] == myRank_ % dimSize_[0]) && pair.second[0].GetHop() == 1) {
      92            0 :             HCCL_INFO(
      93              :                 "[CcuTempBroadcastMeshMem2Mem2D][GenExtIns] Rank[%d] insert link to Rank[%d] in linksY", myRank_,
      94              :                 pair.first);
      95            0 :             linksY_.emplace_back(pair.second[0]);
      96              :         } else {
      97            0 :             THROW<InvalidParamsException>(StringFormat(
      98              :                 "[CcuTempBroadcastMeshMem2Mem2D] Rank[%d], Unexpected peerRank[%d] in tempLinks.", myRank_,
      99            0 :                 pair.first));
     100              :         }
     101            0 :     }
     102            0 :     return HcclResult::HCCL_SUCCESS;
     103              : }
     104              : 
     105            0 : HcclResult CcuTempBroadcastMeshMem2Mem2D::GenExtIns(
     106              :     const TempFuncs& tempFuncs, const TemplateDataParams& templateDataParams, const ResLinks& tempLinks,
     107              :     std::vector<InsQuePtr>& tempInsQues)
     108              : {
     109            0 :     opMode_ = tempFuncs.opMode;
     110            0 :     buffInfo_ = templateDataParams.buffInfo;
     111              : 
     112            0 :     CHK_RET(PrepareLinks(tempLinks));
     113              : 
     114            0 :     RankGroup rankGroupX;
     115            0 :     RankGroup rankGroupY;
     116            0 :     AddRanksToGroup(tempVTopo_, rankGroupX, rankGroupY);
     117              : 
     118            0 :     uint64_t inputAddr = BufferTypeToAddr(buffInfo_.inBuffType) + buffInfo_.inBuffBaseOff;
     119              : 
     120            0 :     uint64_t sliceSize = templateDataParams.sliceSize; // 获取本rank需要处理的数据量
     121              :     uint64_t token;
     122            0 :     CHK_RET(GetToken(op_, token));
     123              : 
     124            0 :     std::vector<uint32_t> dimId;
     125            0 :     dimId.emplace_back(myRank_ % dimSize_[0]);
     126            0 :     dimId.emplace_back(myRank_ / dimSize_[0]);
     127            0 :     std::unique_ptr<CcuInsGroup> insGroupPtr = std::make_unique<CcuInsGroup>();
     128            0 :     for (uint32_t axisId = 0; axisId < NUM_TWO; axisId++) { // 2D算法，需要执行两次
     129              :         // 计算每次编译的偏移量和数据量
     130            0 :         uint64_t xAxisSize = sliceSize * dimSize_[0] / (dimSize_[axisId] + dimSize_[1 - axisId]);
     131            0 :         uint64_t yAxisSize = sliceSize - xAxisSize;
     132            0 :         HCCL_INFO(
     133              :             "[CcuTempBroadcastMeshMem2Mem2D] [GenExtIns]: dimSize0[%llu], dimSize1[%llu], myRank_[%d],"
     134              :             "inputAddr[%llu], sliceSize[%llu], xAxisSize[%llu], yAxisSize[%llu],axisId[%u]",
     135              :             dimSize_[0], dimSize_[1], myRank_, inputAddr, sliceSize, xAxisSize, yAxisSize, axisId);
     136            0 :         CcuInstructionBroadcastMeshMem2Mem2D ccuInsBroadcastMeshMem2Mem2D;
     137            0 :         ccuInsBroadcastMeshMem2Mem2D.Init(
     138            0 :             dimSize_, static_cast<uint32_t>(myRank_), inputAddr, axisId, sliceSize, xAxisSize, yAxisSize, token, op_,
     139            0 :             tempVTopo_);
     140            0 :         ccuInsBroadcastMeshMem2Mem2D.SetLinks(axisId == 0 ? linksX_ : linksY_);
     141            0 :         ccuInsBroadcastMeshMem2Mem2D.SetRankGroup(axisId == 0 ? rankGroupX : rankGroupY);
     142            0 :         u32 ckeNum = 5;
     143            0 :         ccuInsBroadcastMeshMem2Mem2D.SetCntCkeNum(ckeNum); // 每个transport用5个CKE
     144            0 :         ccuInsBroadcastMeshMem2Mem2D.Describe();
     145            0 :         insGroupPtr->Append(
     146            0 :             std::move(std::make_unique<CcuInstructionBroadcastMeshMem2Mem2D>(ccuInsBroadcastMeshMem2Mem2D)));
     147            0 :     }
     148            0 :     tempInsQues[0]->Append(std::move(insGroupPtr)); // 只有一条流
     149            0 :     return HcclResult::HCCL_SUCCESS;
     150            0 : }
     151              : } // namespace Hccl