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 <shared_mutex>
12 : #include "inc/aicpu_mc2_handler.h"
13 : #include "inc/aicpu_utils.h"
14 : #include "communicator_impl_lite_manager.h"
15 : #include "log.h"
16 :
17 : namespace Hccl {
18 28 : AicpuMc2Handler::AicpuMc2Handler() {}
19 :
20 6 : AicpuMc2Handler& AicpuMc2Handler::GetInstance()
21 : {
22 6 : static AicpuMc2Handler instance_;
23 6 : return instance_;
24 : }
25 :
26 5 : HcclResult AicpuMc2Handler::HcclGetCommHandleByCtx(void* ctx, void** opHandle) const
27 : {
28 15 : HCCL_RUN_INFO("[%s]HcclGetCommHandleByCtx begin, ctx:%p, *ctx:%llu", __func__, ctx, *((uint64_t*)ctx));
29 : // 存储kernel参数
30 5 : unique_lock<std::shared_timed_mutex> handlerLock(AicpuUtils::GetInstance().handlerMutex_);
31 5 : AicpuUtils::GetInstance().kernelParam_ = reinterpret_cast<HcclKernelParamLite*>(ctx);
32 5 : uint32_t commIdIndex = AicpuUtils::GetInstance().kernelParam_->comm.idIndex;
33 5 : if (AicpuUtils::GetInstance().kernelParamMap_.find(commIdIndex)
34 10 : == AicpuUtils::GetInstance().kernelParamMap_.end()) {
35 1 : AicpuUtils::GetInstance().kernelParamMap_[commIdIndex] = AicpuUtils::GetInstance().kernelParam_;
36 : }
37 5 : handlerLock.unlock();
38 :
39 : // 创建单例对象
40 5 : std::shared_lock<std::shared_timed_mutex> sharedLock(AicpuUtils::GetInstance().handlerMutex_);
41 5 : AicpuUtils::GetInstance().CreateSingleInstance(ctx);
42 5 : CHK_RET(AicpuUtils::GetInstance().Init());
43 :
44 : // 初始化硬件参数
45 5 : DevCapability::GetInstance().Init(AicpuUtils::GetInstance().kernelParam_->comm.devType);
46 :
47 15 : HCCL_INFO(
48 : "[%s]DevCapability %s, kernelParam_.algName[%s], commIdIndex[%u]", __func__,
49 : AicpuUtils::GetInstance().kernelParam_->comm.devType.Describe().c_str(),
50 : AicpuUtils::GetInstance().kernelParam_->algName, commIdIndex);
51 :
52 5 : CommunicatorImplLite* communicatorImplLite = CommunicatorImplLiteMgr::GetInstance().Get(commIdIndex);
53 8 : CHK_PTR_NULL(communicatorImplLite);
54 4 : return AicpuUtils::GetInstance().GetCommHandle(communicatorImplLite, opHandle);
55 5 : }
56 :
57 : // HcclReleaseComm 设置isUsed标记未使用，不会释放opHandle
58 2 : HcclResult AicpuMc2Handler::HcclReleaseComm(void* opHandle) const
59 : {
60 6 : HCCL_RUN_INFO("[%s]HcclReleaseComm begin", __func__);
61 2 : CommunicatorImplLite* communicatorImplLite = reinterpret_cast<CommunicatorImplLite*>(opHandle);
62 : // isUsed状态置false
63 2 : unique_lock<std::mutex> aicpuLock(communicatorImplLite->GetAicpuMc2Mutex());
64 2 : communicatorImplLite->SetIsUsed(false);
65 2 : aicpuLock.unlock();
66 :
67 2 : unique_lock<std::shared_timed_mutex> handlerLock(AicpuUtils::GetInstance().handlerMutex_);
68 2 : uint32_t commIdIndex = communicatorImplLite->GetCommIdIndex();
69 2 : auto it = AicpuUtils::GetInstance().kernelParamMap_.find(commIdIndex);
70 2 : if (it != AicpuUtils::GetInstance().kernelParamMap_.end()) {
71 2 : AicpuUtils::GetInstance().kernelParamMap_.erase(it);
72 : }
73 2 : return HCCL_SUCCESS;
74 2 : }
75 :
76 2 : HcclResult AicpuMc2Handler::HcclGetTaskStatus(void* opHandle, HcclTaskStatus* status) const
77 : {
78 2 : CommunicatorImplLite* communicatorImplLite = reinterpret_cast<CommunicatorImplLite*>(opHandle);
79 :
80 2 : auto* streamLiteMgr = communicatorImplLite->GetStreamLiteMgr();
81 2 : CHK_PTR_NULL(streamLiteMgr);
82 :
83 2 : StreamLite* curStream = streamLiteMgr->GetMaster();
84 2 : CHK_PTR_NULL_WITH_MSG(curStream, "commId[%u].", communicatorImplLite->GetCommIdIndex());
85 6 : HCCL_INFO("[%s]commId[%u], stream[%u].", __func__, communicatorImplLite->GetCommIdIndex(), curStream->GetId());
86 6 : if (AicpuUtils::GetInstance().GetException(curStream, GET_TASK_STATUS, communicatorImplLite) == 1) {
87 1 : *status = HcclTaskStatus::HCCL_CQE_ERROR;
88 1 : return HCCL_SUCCESS;
89 : }
90 :
91 1 : for (uint32_t id = 0; id < streamLiteMgr->SizeOfSlaves(); id++) {
92 0 : curStream = streamLiteMgr->GetSlave(id);
93 0 : CHK_PTR_NULL_WITH_MSG(curStream, "commId[%u]", communicatorImplLite->GetCommIdIndex());
94 0 : HCCL_INFO("[%s]commId[%u], stream[%u].", __func__, communicatorImplLite->GetCommIdIndex(), curStream->GetId());
95 0 : if (AicpuUtils::GetInstance().GetException(curStream, GET_TASK_STATUS, communicatorImplLite) == 1) {
96 0 : *status = HcclTaskStatus::HCCL_CQE_ERROR;
97 0 : return HCCL_SUCCESS;
98 : }
99 : }
100 :
101 1 : *status = HcclTaskStatus::HCCL_NORMAL_STATUS;
102 1 : return HCCL_SUCCESS;
103 : }
104 :
105 6 : HcclResult AicpuMc2Handler::HcclCheckFinishByStream(void* opHandle) const
106 : {
107 6 : CommunicatorImplLite* communicatorImplLite = reinterpret_cast<CommunicatorImplLite*>(opHandle);
108 :
109 6 : auto* streamLiteMgr = communicatorImplLite->GetStreamLiteMgr();
110 9 : CHK_PTR_NULL(streamLiteMgr);
111 :
112 5 : StreamLite* stream = streamLiteMgr->GetMaster();
113 8 : CHK_PTR_NULL(stream);
114 :
115 : // 比较主流首尾指针
116 4 : RtsqBase* rtsq = stream->GetRtsq();
117 4 : CHK_PTR_NULL_WITH_MSG(rtsq, "commId[%u], stream[%u].", communicatorImplLite->GetCommIdIndex(), stream->GetId());
118 :
119 4 : auto sqHead = rtsq->QuerySqHead();
120 4 : auto sqTail = rtsq->QuerySqTail();
121 4 : if (sqTail == sqHead) {
122 6 : HCCL_INFO(
123 : "[%s]Stream %u finished, sq id %u, head&tail %u.", __func__, stream->GetId(), stream->GetSqId(), sqHead);
124 2 : return HCCL_SUCCESS;
125 : }
126 2 : return HCCL_E_UNAVAIL;
127 : }
128 :
129 5 : HcclResult AicpuMc2Handler::HcclPrintTaskExceptionAllComm(void* opHandle) const
130 : {
131 : // 打印全部通信域状态信息
132 5 : CommunicatorImplLite* curCommunicatorImplLite = reinterpret_cast<CommunicatorImplLite*>(opHandle);
133 5 : string additionInfo;
134 5 : auto communicatorImplLiteVec = CommunicatorImplLiteMgr::GetInstance().GetAll();
135 9 : for (CommunicatorImplLite* communicatorImplLite : communicatorImplLiteVec) {
136 : // 打印主流信息
137 4 : if (communicatorImplLite == curCommunicatorImplLite) {
138 : additionInfo = "[HcclPrintTaskExceptionAllComm]Current communicatorImplLite exists exception,commId "
139 4 : + to_string(communicatorImplLite->GetCommIdIndex());
140 : } else {
141 0 : additionInfo = "";
142 : }
143 4 : auto* streamLiteMgr = communicatorImplLite->GetStreamLiteMgr();
144 4 : if (streamLiteMgr == nullptr) {
145 3 : HCCL_WARNING("[%s]CommunicatorImplLite streamLiteMgr is nullptr", __func__);
146 1 : continue;
147 1 : }
148 :
149 3 : StreamLite* curStream = streamLiteMgr->GetMaster();
150 3 : string nullInfo = "streamLiteMgr->GetMaster is nullptr";
151 3 : AicpuUtils::GetInstance().GetStreamException(curStream, nullInfo, communicatorImplLite, additionInfo);
152 :
153 3 : for (uint32_t id = 0; id < streamLiteMgr->SizeOfSlaves(); id++) {
154 0 : curStream = streamLiteMgr->GetSlave(id);
155 0 : nullInfo = "streamLiteMgr->GetSlave(" + to_string(id) + ") is nullptr";
156 0 : AicpuUtils::GetInstance().GetStreamException(curStream, nullInfo, communicatorImplLite, additionInfo);
157 : }
158 3 : }
159 5 : return HCCL_SUCCESS;
160 5 : }
161 :
162 : // ccore sqe wait拼写并下发流
163 2 : HcclResult AicpuMc2Handler::HcclLaunchCcoreWait(
164 : void* opHandle, uint64_t waitAddr, uint32_t turnNum, uint64_t turnNumAddr, bool isLast) const
165 : {
166 6 : HCCL_INFO(
167 : "[%s]opHandle %p, waitAddr %llu, turnNum %u, turnNumAddr %llu, isLast %u.", __func__, opHandle, waitAddr,
168 : turnNum, turnNumAddr, isLast);
169 2 : return AicpuUtils::GetInstance().HcclLaunchCcore(opHandle, waitAddr, turnNum, turnNumAddr, isLast, CCORE_WAIT_TYPE);
170 : }
171 :
172 : // ccore sqe record拼写并下发流
173 : HcclResult
174 3 : AicpuMc2Handler::HcclLaunchCcorePost(void* opHandle, uint64_t recordAddr, uint32_t turnNum, uint64_t turnNumAddr) const
175 : {
176 9 : HCCL_INFO(
177 : "[%s]opHandle %p, recordAddr %llu, turnNum %u, turnNumAddr %llu.", __func__, opHandle, recordAddr, turnNum,
178 : turnNumAddr);
179 3 : return AicpuUtils::GetInstance().HcclLaunchCcore(
180 2 : opHandle, recordAddr, turnNum, turnNumAddr, false, CCORE_NOTIFY_TYPE);
181 : }
182 :
183 8 : HcclResult AicpuMc2Handler::HcclLaunchOp(void* opHandle, HcclOpData* data) const
184 : {
185 8 : CommunicatorImplLite* communicatorImplLite = reinterpret_cast<CommunicatorImplLite*>(opHandle);
186 14 : CHK_RET(AicpuUtils::GetInstance().RecoverKernelParam(communicatorImplLite, data));
187 5 : CHK_RET(AicpuUtils::GetInstance().RestoreOpRes(communicatorImplLite));
188 5 : CHK_RET(AicpuUtils::GetInstance().ExecuteOp(communicatorImplLite));
189 :
190 : // 用于算法编排内存释放
191 5 : unique_lock<std::shared_timed_mutex> handlerLock(AicpuUtils::GetInstance().handlerMutex_);
192 5 : AicpuUtils::GetInstance().kernelParam_->op.algOperator.scratchMem = nullptr;
193 5 : handlerLock.unlock();
194 5 : return HCCL_SUCCESS;
195 5 : }
196 : } // namespace Hccl
|
