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 "topo_match_mesh_ring.h"
      12              : 
      13              : namespace Hccl {
      14            0 : TopoMatchMeshRing::TopoMatchMeshRing(const RankId vRank, const u32 rankSize, const RankGraph *rankGraph,
      15            0 :                                      const DevType devType)
      16            0 :     : TopoMatchBase(vRank, rankSize, rankGraph, devType)
      17              : {
      18            0 : }
      19              : 
      20            0 : TopoMatchMeshRing::~TopoMatchMeshRing()
      21              : {
      22            0 : }
      23              : 
      24            0 : HcclResult TopoMatchMeshRing::MatchTopo(std::vector<std::vector<std::vector<RankId>>> &vTopo,
      25              :                                         std::vector<std::vector<RankId>>              &virtRanks,
      26              :                                         std::vector<std::map<RankId, u32>>            &virtRankMap)
      27              : {
      28              :     // 获取并校验当前通信层数
      29            0 :     std::set<u32> levelSet = rankGraph_->GetLevels(myRank_);
      30            0 :     CHK_PRT_RET((levelSet.size() == COMM_LEVEL_SIZE_0),   //获取当前rank通信层数
      31              :                 HCCL_ERROR("[CollAlgFactory] [TopoMatchMeshRing] Rank [%d], Invalid virtual topo.", myRank_),
      32              :                 HcclResult::HCCL_E_PARA);
      33              : 
      34              :     // 获取 level0 Topo 信息
      35            0 :     const NetInstance* netInstance = rankGraph_->GetNetInstanceByRankId(0, myRank_);
      36            0 :     if(netInstance == nullptr) {
      37            0 :         HCCL_ERROR("TopoMatchMeshRing::MatchTopo netInstance is nullptr");
      38            0 :         return HcclResult::HCCL_E_PTR;
      39              :     }
      40            0 :     std::set<RankId> rankSetR0 = netInstance->GetRankIds();
      41            0 :     CHK_RET(CalcRankOnSamePlaneOfR0(rankOnSameBoardVector_, rankOnSameSlotVector_, numRanksPerBoard_));
      42              : 
      43            0 :     if (levelSet.size() == COMM_LEVEL_SIZE_1) {
      44              :         // 判断level0上的拓扑是否符合 m x n 要求
      45              :         const auto minmxPair =
      46            0 :             std::minmax_element(numRanksPerBoard_.begin(), numRanksPerBoard_.end());
      47            0 :         u32 minNumRankPerBoard = *minmxPair.first;
      48            0 :         u32 maxNumRankPerBoard = *minmxPair.second;
      49            0 :         CHK_PRT_RET((minNumRankPerBoard != maxNumRankPerBoard),
      50              :                     HCCL_ERROR("[CollAlgFactory] [TopoMatchMeshRing] Rank [%d], Invalid virtual topo for "
      51              :                         "mesh_ring, min numRanksPerBoard_[%u], max numRanksPerBoard_[%u].",
      52              :                         myRank_, minNumRankPerBoard, maxNumRankPerBoard), HcclResult::HCCL_E_PARA);
      53              : 
      54            0 :         CHK_PRT_RET(((rankSize_ == 1) || (numRanksPerBoard_[0] * numRanksPerBoard_.size() != rankSize_)),
      55              :                     HCCL_ERROR("[CollAlgFactory] [TopoMatchMeshRing] Rank [%d], Invalid virtual topo for "
      56              :                         "mesh_ring algorithm with rankSize [%u], ranksPerBoard [%u], ranksPerSlot [%lu].",
      57              :                         myRank_, rankSize_, numRanksPerBoard_[0], numRanksPerBoard_.size()), HcclResult::HCCL_E_PARA);
      58              : 
      59              :         // 计算R0的AlgTopoInfo
      60            0 :         u32 myLocalId = rankGraph_->GetReplacedLocalId(myRank_);
      61            0 :         virtRanks.push_back(rankOnSameBoardVector_[myLocalId / RANK_SIZE_EIGHT]);
      62            0 :         virtRanks.push_back(rankOnSameSlotVector_[myLocalId % RANK_SIZE_EIGHT]);
      63            0 :         for (auto vRankIter = virtRanks.begin(); vRankIter != virtRanks.end(); vRankIter++) {
      64            0 :             vTopo.push_back({*vRankIter});
      65              :         }
      66              :     } else {
      67            0 :         CHK_RET(MeshRingTopoForAllLevel(rankSetR0, vTopo, virtRanks));
      68              :     }
      69              :     // generate rank mapping
      70            0 :     CHK_PRT_RET(
      71              :         GenVirtRankMappingMultiLevel(virtRanks, virtRankMap) != HcclResult::HCCL_SUCCESS,
      72              :         HCCL_ERROR("[CollAlgFactory] [TopoMatchMeshRing] Rank [%d], Fail to generate virtRankMapping.", myRank_),
      73              :         HcclResult::HCCL_E_INTERNAL);
      74            0 :     return HcclResult::HCCL_SUCCESS;
      75            0 : }
      76              : 
      77            0 : HcclResult TopoMatchMeshRing::MeshRingTopoForAllLevel(std::set<RankId> rankSetR0,
      78              :                                                       std::vector<std::vector<std::vector<RankId>>> &vTopo,
      79              :                                                       std::vector<std::vector<RankId>> &virtRanks)
      80              : {
      81              :     // 计算R0的virtRanks
      82            0 :     if (numRanksPerBoard_.size() != 1 && numRanksPerBoard_[0] != 1) {
      83            0 :         if (!IsAllRanksFullMeshConnected(rankSetR0)) {
      84            0 :             HCCL_ERROR("[CollAlgFactory] [TopoMatchMeshRing] Rank [%d], Invalid virtual topo for "
      85              :                         "mesh_ring in level0.", myRank_);
      86            0 :             return HcclResult::HCCL_E_PARA;
      87              :         }
      88            0 :         std::vector<RankId> ranksPerRack(rankSetR0.size());
      89            0 :         for (RankId rankId : rankSetR0) {
      90            0 :             ranksPerRack.push_back(rankId);
      91              :         }
      92            0 :         virtRanks.push_back(ranksPerRack);
      93            0 :     }
      94              :     // 计算R1的virtRanks
      95            0 :     const NetInstance* fabGroupLevel1 = rankGraph_->GetNetInstanceByRankId(1, myRank_);
      96            0 :     if(fabGroupLevel1  == nullptr) {
      97            0 :         HCCL_ERROR("[CollAlgFactory] [TopoMatchMeshRing] Rank [%d],fabGroupLevel1 is nullptr", myRank_);
      98            0 :         return HcclResult::HCCL_E_PTR;
      99              :     }
     100            0 :     std::set<RankId> rankSetLevel1 = fabGroupLevel1->GetRankIds();
     101            0 :     std::vector<RankId> rankOnSamePlaneVector(rankSetLevel1.size());
     102              :     // 获取所有rank在level1的平面
     103            0 :     for (RankId rankId : rankSetLevel1) {
     104            0 :         rankOnSamePlaneVector.push_back(rankId);
     105              :     }
     106            0 :     virtRanks.push_back(rankOnSamePlaneVector);
     107              :     // 计算vTopo
     108            0 :     for (u32 i = 0; i < virtRanks.size(); i++) {
     109            0 :         vTopo.push_back({virtRanks[i]});
     110              :     }
     111            0 :     return HcclResult::HCCL_SUCCESS;
     112            0 : }
     113              : 
     114              : } // namespace Hccl