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 "socket_handle_manager.h"
      12              : #include "internal_exception.h"
      13              : 
      14              : namespace Hccl {
      15              : 
      16            3 : SocketHandleManager::SocketHandleManager()
      17              : {
      18            3 :     hccpSocketHandleMap.resize(MAX_DEVICE_NUM);
      19          198 :     for (u32 i = 0; i < hccpSocketHandleMap.size(); ++i) {
      20          195 :         hccpSocketHandleMap[i].resize(LINK_PROTO_TYPE_NUM);
      21              :     }
      22            3 : }
      23              : 
      24            3 : SocketHandleManager::~SocketHandleManager()
      25              : {
      26            3 :     DECTOR_TRY_CATCH("SocketHandleManager", DestroyAll());
      27            3 : }
      28              : 
      29           66 : SocketHandleManager &SocketHandleManager::GetInstance()
      30              : {
      31           66 :     static SocketHandleManager socketHandleManager;
      32           66 :     return socketHandleManager;
      33              : }
      34              : 
      35           14 : SocketHandle SocketHandleManager::Create(DevId devicePhyId, const PortData &localPort)
      36              : {
      37           14 :     RaInterface intf{};
      38           14 :     intf.phyId = devicePhyId;
      39           14 :     if (localPort.GetType() == PortDeploymentType::P2P) {
      40            2 :         intf.address = localPort.GetAddr();
      41           12 :     } else if (localPort.GetType() == PortDeploymentType::DEV_NET) {
      42           12 :         intf.address = localPort.GetAddr();
      43              :     } else {
      44            0 :         string msg = StringFormat("Not support this type now: %s", localPort.GetType().Describe().c_str());
      45            0 :         THROW<NotSupportException>(msg);
      46            0 :     }
      47              : 
      48           14 :     std::lock_guard<std::mutex> lock(socketHandleLock);
      49           14 :     if (devicePhyId > hccpSocketHandleMap.size() - 1
      50           14 :         || static_cast<u32>(localPort.GetProto()) > hccpSocketHandleMap[devicePhyId].size() - 1) {
      51            1 :         string msg = StringFormat("devicePhyId %u or prototype %u out of range", devicePhyId, static_cast<u32>(localPort.GetProto()));
      52            1 :         THROW<InternalException>(msg);
      53            1 :     }
      54           13 :     if (hccpSocketHandleMap[devicePhyId][static_cast<u32>(localPort.GetProto())].find(localPort.GetAddr())
      55           26 :         != hccpSocketHandleMap[devicePhyId][static_cast<u32>(localPort.GetProto())].end()) {
      56            6 :         return hccpSocketHandleMap[devicePhyId][static_cast<u32>(localPort.GetProto())][localPort.GetAddr()];
      57              :     }
      58            7 :     SocketHandle socketHandle = HrtRaSocketInit(HrtNetworkMode::HDC, intf);
      59              : 
      60            7 :     if ((u32)localPort.GetProto() > LINK_PROTO_TYPE_NUM - 1) {
      61            0 :         HrtRaSocketDeInit(socketHandle);
      62            0 :         HCCL_ERROR("Invalid LinkProtoType.");
      63            0 :         return nullptr;
      64              :     }
      65            7 :     hccpSocketHandleMap[devicePhyId][static_cast<u32>(localPort.GetProto())][localPort.GetAddr()] = socketHandle;
      66            7 :     return socketHandle;
      67           14 : }
      68              : 
      69            6 : SocketHandle SocketHandleManager::Get(u32 devicePhyId, const PortData &localPort)
      70              : {
      71            6 :     std::lock_guard<std::mutex> lock(socketHandleLock);
      72            6 :     if (devicePhyId > hccpSocketHandleMap.size() - 1
      73            6 :         || static_cast<u32>(localPort.GetProto()) > hccpSocketHandleMap[devicePhyId].size() - 1) {
      74            0 :         return nullptr;
      75              :     }
      76            6 :     if (hccpSocketHandleMap[devicePhyId][static_cast<u32>(localPort.GetProto())].find(localPort.GetAddr())
      77           12 :         == hccpSocketHandleMap[devicePhyId][static_cast<u32>(localPort.GetProto())].end()) {
      78            2 :             return nullptr;
      79              :     }
      80            4 :     return hccpSocketHandleMap[devicePhyId][static_cast<u32>(localPort.GetProto())][localPort.GetAddr()];
      81            6 : }
      82              : 
      83            3 : void SocketHandleManager::DestroyAll()
      84              : {
      85            3 :     if (destroyed.load()) {
      86            0 :         return;
      87              :     }
      88            3 :     destroyed.store(true);
      89              : 
      90            3 :     std::lock_guard<std::mutex> lock(socketHandleLock);
      91          198 :     for (u32 i = 0; i < hccpSocketHandleMap.size(); ++i) {
      92          975 :         for (u32 j = 0; j < hccpSocketHandleMap[i].size(); ++j) {
      93          784 :             for (auto &iterHandle : hccpSocketHandleMap[i][j]) {
      94            4 :                 if (iterHandle.second != nullptr) {
      95            4 :                     DECTOR_TRY_CATCH("RaSocketDeinit", HrtRaSocketDeInit(iterHandle.second));
      96            4 :                     iterHandle.second = nullptr;
      97              :                 }
      98              :             }
      99              :         }
     100              :     }
     101            3 :     hccpSocketHandleMap.clear();
     102            3 : }
     103              : 
     104            4 : void SocketHandleManager::DeInit(u32 devPhyId)
     105              : {
     106            4 :     if (destroyed.load()) {
     107            1 :         return;
     108              :     }
     109            4 :     HCCL_INFO("[SocketHandleManager][%s] DeInit[%u]", __func__, devPhyId);
     110            4 :     std::lock_guard<std::mutex> lock(socketHandleLock);
     111            4 :     if (devPhyId >= hccpSocketHandleMap.size()) {
     112            1 :         return;
     113              :     }
     114           15 :     for (u32 j = 0; j < hccpSocketHandleMap[devPhyId].size(); ++j) {
     115           15 :         for (auto &iterHandle : hccpSocketHandleMap[devPhyId][j]) {
     116            3 :             if (iterHandle.second != nullptr) {
     117            3 :                 DECTOR_TRY_CATCH("RaSocketDeinit", HrtRaSocketDeInit(iterHandle.second));
     118            3 :                 iterHandle.second = nullptr;
     119              :             }
     120              :         }
     121           12 :         hccpSocketHandleMap[devPhyId][j].clear();
     122              :     }
     123            4 : }
     124              : 
     125              : } // namespace Hccl