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