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 "hcclCommTaskException.h"
12 : #include <memory>
13 : #include "log.h"
14 : #include "coll_comm.h"
15 : #include "acl/acl_rt.h"
16 : #include "orion_adapter_hccp.h"
17 : #include "hcomm_adapter_hccp.h"
18 : #include <adapter_error_manager_pub.h>
19 : #include "op_type.h"
20 : #include "task_exception_handler.h"
21 : #include "ccuTaskException.h"
22 : #include "hccl_types.h"
23 : #include "dpu_kernel_entrance.h"
24 :
25 : namespace hcomm {
26 :
27 : using namespace std;
28 :
29 : constexpr u32 MAX_MODULE_DEVICE_NUM_V2 = 65;
30 : constexpr uint32_t TASK_CONTEXT_SIZE = 50;
31 : constexpr uint32_t TASK_CONTEXT_INFO_SIZE = LOG_TMPBUF_SIZE - 50; // task 执行失败时打印前序task信息的长度限制
32 :
33 : // Leaky Singleton: 故意不释放，规避 Static Destruction Order Fiasco，
34 : // 确保 RTS 回调访问 handlers_ 时内存仍有效
35 : static TaskExceptionHost* handlers_ = new TaskExceptionHost[MAX_MODULE_DEVICE_NUM_V2];
36 : GetAicpuCqeErrInfoCallBackHcomm g_getAicpuCqeErrInfoCallBack = nullptr;
37 : AicpuGetErrStatusVecCallBack g_AicpuGetErrStatusVecCallBack = nullptr;
38 :
39 52 : void RegisterGetAicpuCqeErrInfoCallBackHcomm(GetAicpuCqeErrInfoCallBackHcomm p1)
40 : {
41 52 : g_getAicpuCqeErrInfoCallBack = p1;
42 52 : return;
43 : }
44 :
45 0 : void TaskExceptionHost::ClusterMoniterGetAicpuCqeErrInfo(
46 : u32 remoteLocalId, u32 locDeviceId, uint16_t status, string localEid, string remoteEid, string remoteInsId) const
47 : {
48 0 : if (g_getAicpuCqeErrInfoCallBack != nullptr) {
49 0 : g_getAicpuCqeErrInfoCallBack(remoteLocalId, locDeviceId, status, localEid, remoteEid, remoteInsId);
50 : } else {
51 0 : HCCL_RUN_WARNING("[%s]g_getAicpuCqeErrInfoCallBack is nullptr.", __func__);
52 : }
53 0 : return;
54 : }
55 :
56 52 : void RegisterAicpuGetErrStatusVecCallBack(AicpuGetErrStatusVecCallBack p1)
57 : {
58 52 : g_AicpuGetErrStatusVecCallBack = p1;
59 52 : return;
60 : }
61 :
62 4 : std::vector<std::string> AicpuGetErrStatusVec(s32 deviceLogicID)
63 : {
64 4 : if (g_AicpuGetErrStatusVecCallBack != nullptr) {
65 4 : return g_AicpuGetErrStatusVecCallBack(deviceLogicID);
66 : } else {
67 0 : HCCL_RUN_WARNING("[AicpuGetErrStatusVec]g_AicpuGetErrStatusVecCallBack is nullptr.");
68 : }
69 0 : return std::vector<std::string>();
70 : }
71 :
72 4 : std::string AicpuGetAndPrintClusterMonitorErr(const rtExceptionInfo* exceptionInfo)
73 : {
74 4 : auto errStatusVec = AicpuGetErrStatusVec(exceptionInfo->deviceid);
75 4 : std::string errMsg = "";
76 4 : int errSize = errStatusVec.size();
77 4 : if (errSize > 0) {
78 0 : int maxListSize = 3; // 放入errMsg中的异常事件最多只有3个
79 0 : if (errSize <= maxListSize) {
80 0 : errMsg = "\nthere are(is) " + std::to_string(errSize) + " abnormal device(s):\n";
81 : } else {
82 0 : errMsg = "\nthere are " + std::to_string(errSize) + " abnormal device(s), "
83 0 : + "only the first 3 devices are listed:\n";
84 : }
85 :
86 0 : for (int i = 0; i < errSize; i++) {
87 0 : HCCL_ERROR("%s", errStatusVec[i].c_str());
88 0 : if (i < maxListSize) {
89 0 : errMsg += ("\t" + errStatusVec[i] + "\n");
90 : }
91 : }
92 : }
93 4 : return errMsg;
94 4 : }
95 :
96 384 : TaskExceptionHost* TaskExceptionHost::GetInstance(s32 deviceLogicID)
97 : {
98 384 : if (deviceLogicID < 0 || static_cast<u32>(deviceLogicID) >= MAX_MODULE_DEVICE_NUM_V2) {
99 0 : HCCL_ERROR("[TaskExceptionHost][GetInstance] deviceLogicID[%d] is invalid", deviceLogicID);
100 0 : return nullptr;
101 : }
102 384 : return &handlers_[deviceLogicID];
103 : }
104 :
105 0 : TaskExceptionHost::~TaskExceptionHost()
106 : {
107 0 : std::unique_lock<std::mutex> lock(taskExceptionMutex_);
108 0 : if (!CommRegisterMap_.empty()) {
109 0 : CommRegisterMap_.clear();
110 0 : aclError ret = aclrtExceptionInfoCallbackUnregister(ProcessCallback); // 注销注册给rts的TaskException回调
111 0 : HCCL_RUN_INFO("[%s]aclrtExceptionInfoCallbackUnregister, ret[%d]", __func__, ret);
112 : }
113 0 : }
114 :
115 1 : void TaskExceptionHost::ProcessCallback(rtExceptionInfo_t* exceptionInfo)
116 : {
117 1 : CHK_PRT_RET(exceptionInfo == nullptr, HCCL_ERROR("[%s]fail, exceptionInfo is nullptr", __func__), );
118 :
119 0 : TaskExceptionHost* handler = TaskExceptionHost::GetInstance(exceptionInfo->deviceid);
120 0 : CHK_PRT_RET(handler == nullptr, HCCL_ERROR("[%s]fail, TaskExceptionHost is nullptr", __func__), );
121 0 : handler->Process(exceptionInfo);
122 : }
123 :
124 165 : HcclResult TaskExceptionHost::Register(u64 commHandle)
125 : {
126 165 : std::unique_lock<std::mutex> lock(taskExceptionMutex_);
127 165 : if (CommRegisterMap_.empty()) {
128 164 : aclError ret = aclrtExceptionInfoCallbackRegister(ProcessCallback);
129 164 : CHK_PRT_RET(
130 : ret != ACL_SUCCESS, HCCL_ERROR("[%s]aclrtExceptionInfoCallbackRegister failed, ret[%d]", __func__, ret),
131 : HCCL_E_RUNTIME);
132 164 : Hccl::HrtUnregTaskExceptionCallbackByModule(Hccl::TaskExceptionHandler::Process);
133 164 : HCCL_RUN_INFO(
134 : "[%s]aclrtExceptionInfoCallbackRegister set ProcessCallback success and unregister legacy "
135 : "TaskExceptionHandler::Process callback",
136 : __func__);
137 : }
138 :
139 165 : CommRegisterMap_.insert(commHandle);
140 165 : HCCL_INFO("[%s]success, commHandle[0x%llx]", __func__, commHandle);
141 165 : return HCCL_SUCCESS;
142 165 : }
143 :
144 205 : HcclResult TaskExceptionHost::UnRegister(u64 commHandle)
145 : {
146 205 : std::unique_lock<std::mutex> lock(taskExceptionMutex_);
147 205 : if (CommRegisterMap_.find(commHandle) == CommRegisterMap_.end()) {
148 41 : HCCL_INFO("[%s] commHandle[0x%llx] has not registered, skip", __func__, commHandle);
149 41 : return HCCL_SUCCESS;
150 : }
151 :
152 164 : CommRegisterMap_.erase(commHandle);
153 164 : if (CommRegisterMap_.empty()) {
154 163 : aclError ret = aclrtExceptionInfoCallbackUnregister(ProcessCallback); // 注销注册给rts的TaskException回调
155 163 : CHK_PRT_RET(
156 : ret != ACL_SUCCESS, HCCL_ERROR("[%s]aclrtExceptionInfoCallbackUnregister failed, ret[%d]", __func__, ret),
157 : HCCL_E_RUNTIME);
158 163 : HCCL_RUN_INFO("[%s]aclrtExceptionInfoCallbackUnregister success", __func__);
159 : }
160 :
161 164 : HCCL_INFO("[%s]success, commHandle[0x%llx]", __func__, commHandle);
162 164 : return HCCL_SUCCESS;
163 205 : }
164 :
165 0 : HcclResult TaskExceptionHost::PrintUbRegisters(s32 devLogicId, const RdmaHandle rdmaHandle) const
166 : {
167 0 : HCCL_INFO("[PrintUbRegister] start, devLogicId[%d], rdmaHandle[%p]", devLogicId, rdmaHandle);
168 0 : Hccl::AuxInfoIn in;
169 0 : in.cqe.status = 0xffffffff; // 0xffffffff代表查询所有寄存器
170 0 : in.auxInfoInType = Hccl::AuxInfoInType::AUX_INFO_IN_TYPE_CQE;
171 0 : in.cqe.sR = 0;
172 0 : Hccl::AuxInfoOut auxInfo;
173 0 : auto ret = Hccl::RaGetAuxInfo(rdmaHandle, in, auxInfo);
174 0 : if (ret != HCCL_SUCCESS) {
175 0 : HCCL_ERROR("[PrintUbRegister]GetUbRegisterInfo failed, devLogicId[%d], rdmaHandle[%p]", devLogicId, rdmaHandle);
176 0 : return ret;
177 : }
178 :
179 0 : bool isAuxInfoExisted{false};
180 0 : for (u32 i = 0; i < auxInfo.auxInfoNum; i++) {
181 0 : if (auxInfo.auxInfoValues[i] != 0) { // 非零进行打印
182 0 : isAuxInfoExisted = true;
183 0 : HCCL_ERROR(
184 : "devLogicId[%d], cqe_aux_info_type[%u], cqe_aux_info_value[0x%x]", devLogicId, auxInfo.auxInfoTypes[i],
185 : auxInfo.auxInfoValues[i]);
186 : } else {
187 0 : HCCL_INFO(
188 : "devLogicId[%d], cqe_aux_info_type[%u], cqe_aux_info_value[0x%x]", devLogicId, auxInfo.auxInfoTypes[i],
189 : auxInfo.auxInfoValues[i]);
190 : }
191 : }
192 0 : if (!isAuxInfoExisted) {
193 0 : HCCL_ERROR("devLogicId[%d], all aux_info values are zero.", devLogicId);
194 : }
195 0 : return HCCL_SUCCESS;
196 : }
197 :
198 7 : bool IsMC2Exception(const rtExceptionInfo_t* exceptionInfo)
199 : {
200 7 : return exceptionInfo->expandInfo.type == RT_EXCEPTION_FUSION
201 7 : && exceptionInfo->expandInfo.u.fusionInfo.type == RT_FUSION_AICORE_CCU;
202 : }
203 :
204 7 : bool TaskExceptionHost::ProcessDpuException(const rtExceptionInfo_t* exceptionInfo) const
205 : {
206 7 : HCCL_RUN_INFO("[TaskExceptionHost][%s]begin to execute hccl task exception callback function.", __func__);
207 7 : bool isExce = false;
208 7 : errno_t ret = EOK;
209 7 : uint16_t hcclRet = 0;
210 7 : for (auto pairMap : g_taskExpMemMap) {
211 0 : std::string commId = pairMap.first;
212 : // 读取共享内存内容并打印
213 0 : ret = memcpy_s(
214 : &hcclRet, sizeof(uint16_t),
215 0 : reinterpret_cast<uint8_t*>(pairMap.second[exceptionInfo->deviceid]) + sizeof(uint8_t) + sizeof(uint16_t),
216 : sizeof(uint16_t));
217 0 : if (ret != EOK) {
218 0 : HCCL_ERROR("memcpy_s get dpu taskexception failed: %d", ret);
219 0 : return isExce;
220 : }
221 0 : if (hcclRet != 0) { // 有dpu任务出错
222 0 : HCCL_ERROR("[TaskExceptionHost][ProcessDpuException] Task from HCCL run failed.");
223 0 : HCCL_ERROR(
224 : "[TaskExceptionHost][ProcessDpuException] errorCode[%d], devId[%u], commId[%s]", hcclRet,
225 : exceptionInfo->deviceid, commId.c_str());
226 0 : ret = memset_s(
227 0 : reinterpret_cast<uint8_t*>(pairMap.second[exceptionInfo->deviceid]) + sizeof(uint8_t)
228 0 : + sizeof(uint16_t),
229 : sizeof(uint16_t), 0, sizeof(uint16_t)); // 清空 dpu taskexception共享内存内容
230 0 : if (ret != EOK) {
231 0 : HCCL_ERROR("memset_s clean dpu taskexception failed: %d", ret);
232 0 : return isExce;
233 : }
234 0 : isExce = true;
235 0 : break;
236 : }
237 0 : }
238 7 : return isExce;
239 : }
240 :
241 7 : void TaskExceptionHost::Process(rtExceptionInfo_t* exceptionInfo)
242 : {
243 7 : HCCL_RUN_INFO(
244 : "[TaskExceptionHost][%s], taskid[%u], streamid[%u], tid[%u], deviceid[%u], retcode[%u], type[%d]", __func__,
245 : exceptionInfo->taskid, exceptionInfo->streamid, exceptionInfo->tid, exceptionInfo->deviceid,
246 : exceptionInfo->retcode, exceptionInfo->expandInfo.type);
247 :
248 7 : if (IsMC2Exception(exceptionInfo)) { // MC2 taskException 新流程暂未支持，回退到老流程
249 0 : Hccl::TaskExceptionHandler::Process(exceptionInfo);
250 0 : return;
251 : }
252 :
253 : // dpu taskexception
254 7 : if (ProcessDpuException(exceptionInfo)) {
255 0 : HCCL_ERROR("[TaskExceptionHost][ProcessDpuException] end.");
256 0 : return;
257 : };
258 :
259 7 : ProcessHcclTaskException(exceptionInfo);
260 : }
261 :
262 7 : void TaskExceptionHost::ProcessHcclTaskException(rtExceptionInfo_t* exceptionInfo)
263 : {
264 7 : Hccl::TaskInfo* curTask = nullptr;
265 7 : HcclResult ret = Hccl::GlobalMirrorTasks::Instance().FindTaskInfo(
266 : exceptionInfo->deviceid, exceptionInfo->streamid, exceptionInfo->taskid, curTask);
267 7 : CHK_PRT_RET(
268 : ret == HCCL_E_NOT_FOUND,
269 : HCCL_RUN_WARNING(
270 : "[%s]FindTaskInfo not found, deviceid[%u] streamid[%u] taskid[%u].", __func__, exceptionInfo->deviceid,
271 : exceptionInfo->streamid, exceptionInfo->taskid), );
272 :
273 0 : CHK_PRT_RET(
274 : ret != HCCL_SUCCESS || curTask == nullptr,
275 : HCCL_ERROR(
276 : "[%s]FindTaskInfo fail, ret[%d], deviceid[%u], streamid[%u], taskid[%u].", __func__, ret,
277 : exceptionInfo->deviceid, exceptionInfo->streamid, exceptionInfo->taskid), );
278 :
279 0 : if (curTask->taskParam_.taskType == Hccl::TaskParamType::TASK_AIV) {
280 0 : HCCL_RUN_INFO(
281 : "[TaskExceptionHost][%s] AIV taskType, taskid[%u] streamid[%u] deviceid[%u].", __func__,
282 : exceptionInfo->taskid, exceptionInfo->streamid, exceptionInfo->deviceid);
283 0 : return;
284 : }
285 :
286 0 : CHK_PRT_RET(curTask->dfxOpInfo_ == nullptr, HCCL_ERROR("[%s]fail, dfxOpInfo is nullptr", __func__), );
287 0 : bool isIndop_ = curTask->dfxOpInfo_->isIndop_;
288 0 : HCCL_INFO("[%s]isIndop_[%d], taskType[%s]", __func__, isIndop_, curTask->taskParam_.taskType.Describe().c_str());
289 :
290 : // 老流程TaskException打印
291 0 : if (!isIndop_) {
292 0 : Hccl::TaskExceptionHandler::Process(exceptionInfo);
293 0 : return;
294 : }
295 :
296 : // 新流程支持的TaskException打印
297 0 : std::unique_lock<std::mutex> lock(taskExceptionMutex_);
298 0 : u64 commHandle = reinterpret_cast<u64>(curTask->dfxOpInfo_->comm_);
299 0 : if (curTask->dfxOpInfo_->comm_ == nullptr || CommRegisterMap_.find(commHandle) == CommRegisterMap_.end()) {
300 0 : HCCL_ERROR(
301 : "[TaskExceptionHost][%s] commHandle[0x%llx] not exist, "
302 : "the comm may have been destroyed or was never registered",
303 : __func__, commHandle);
304 0 : return;
305 : }
306 :
307 0 : if (curTask->taskParam_.taskType == Hccl::TaskParamType::TASK_CCU) {
308 0 : CcuTaskException::ProcessCcuException(exceptionInfo, *curTask);
309 : } else {
310 0 : ProcessException(exceptionInfo, *curTask);
311 : }
312 0 : }
313 :
314 2 : std::string TaskExceptionHost::GetGroupRankInfo(const Hccl::TaskInfo& taskInfo) const
315 : {
316 2 : if (taskInfo.dfxOpInfo_ == nullptr || taskInfo.dfxOpInfo_->comm_ == nullptr) {
317 2 : HCCL_ERROR("[TaskInfo][%s]TaskInfo communicator is nullptr.", __func__);
318 4 : return "";
319 : }
320 :
321 0 : hccl::CollComm* communicator = static_cast<hccl::CollComm*>(taskInfo.dfxOpInfo_->comm_);
322 : return Hccl::StringFormat(
323 0 : "group:[%s], rankSize[%u], rankId[%u]", communicator->GetCommId().c_str(), communicator->GetRankSize(),
324 0 : communicator->GetMyRankId());
325 : }
326 :
327 0 : void TaskExceptionHost::GetAicpuCqeErrRemoteLocalIdByRankId(
328 : hccl::CollComm* collComm, uint32_t rankid, u32& remoteLocalId) const
329 : {
330 0 : if (collComm == nullptr || rankid == Hccl::DFX_INVALID_RANKID) {
331 0 : HCCL_ERROR("[GetAicpuCqeErrRemoteLocalIdByRankId]collComm is nullptr or rankId is invalid, rankId[%u]", rankid);
332 0 : remoteLocalId = Hccl::DFX_INVALID_RANKID;
333 0 : return;
334 : }
335 :
336 0 : Hccl::HcclCommunicator* commV2 = static_cast<Hccl::HcclCommunicator*>(collComm->GetCommunicatorV2());
337 0 : if (commV2 == nullptr) {
338 0 : HCCL_ERROR("[GetAicpuCqeErrRemoteLocalIdByRankId]commV2 is nullptr, rankId[%u]", rankid);
339 0 : remoteLocalId = Hccl::DFX_INVALID_RANKID;
340 0 : return;
341 : }
342 0 : void* rankGraph = nullptr;
343 0 : HcclResult ret = commV2->GetRankGraphV2(rankGraph);
344 0 : if (ret != HCCL_SUCCESS) {
345 0 : HCCL_ERROR("[GetAicpuCqeErrRemoteLocalIdByRankId]GetRankGraphV2 failed, rankId[%u], ret[%d]", rankid, ret);
346 0 : remoteLocalId = Hccl::DFX_INVALID_RANKID;
347 0 : return;
348 : }
349 0 : Hccl::RankGraph* rankGraphv2 = static_cast<Hccl::RankGraph*>(rankGraph);
350 0 : u32 LocalId = rankGraphv2->GetLocalId(rankid);
351 0 : remoteLocalId = LocalId;
352 0 : return;
353 : }
354 :
355 0 : void TaskExceptionHost::GetAicpuCqeErrNetInstanceByRankId(
356 : hccl::CollComm* collComm, uint32_t rankid, std::string& netInstanceId) const
357 : {
358 0 : if (collComm == nullptr || rankid == Hccl::DFX_INVALID_RANKID) {
359 0 : HCCL_ERROR("[GetAicpuCqeErrNetInstanceByRankId]collComm is nullptr or rankId is invalid, rankId[%u]", rankid);
360 0 : netInstanceId = "";
361 0 : return;
362 : }
363 :
364 0 : Hccl::HcclCommunicator* commV2 = static_cast<Hccl::HcclCommunicator*>(collComm->GetCommunicatorV2());
365 0 : if (commV2 == nullptr) {
366 0 : HCCL_ERROR("[GetAicpuCqeErrNetInstanceByRankId]commV2 is nullptr, rankId[%u]", rankid);
367 0 : netInstanceId = "";
368 0 : return;
369 : }
370 0 : void* rankGraph = nullptr;
371 0 : HcclResult ret = commV2->GetRankGraphV2(rankGraph);
372 0 : if (ret != HCCL_SUCCESS) {
373 0 : HCCL_ERROR("[GetAicpuCqeErrNetInstanceByRankId]GetRankGraphV2 failed, rankId[%u], ret[%d]", rankid, ret);
374 0 : netInstanceId = "";
375 0 : return;
376 : }
377 0 : Hccl::RankGraph* rankGraphv2 = static_cast<Hccl::RankGraph*>(rankGraph);
378 0 : const Hccl::NetInstance* netInstance = rankGraphv2->GetNetInstanceByRankId(0, rankid);
379 0 : if (netInstance == nullptr) {
380 0 : HCCL_ERROR("[GetAicpuCqeErrNetInstanceByRankId]netInstance is nullptr, rankId[%u]", rankid);
381 0 : netInstanceId = "";
382 0 : return;
383 : }
384 0 : std::string netInsId = netInstance->GetNetInstId();
385 0 : netInstanceId = netInsId;
386 0 : return;
387 0 : }
388 :
389 0 : void TaskExceptionHost::GetAicpuCqeErrInfo(
390 : rtExceptionInfo_t* exceptionInfo, const Hccl::ErrorMessageReport& errorMessage,
391 : const Hccl::TaskInfo& taskInfo) const
392 : {
393 0 : hccl::CollComm* collComm = static_cast<hccl::CollComm*>(taskInfo.dfxOpInfo_->comm_);
394 0 : u32 remoteLocalId = Hccl::DFX_INVALID_RANKID;
395 0 : GetAicpuCqeErrRemoteLocalIdByRankId(collComm, errorMessage.remoteUserRank, remoteLocalId);
396 0 : std::string netInstanceId = "";
397 0 : GetAicpuCqeErrNetInstanceByRankId(collComm, errorMessage.remoteUserRank, netInstanceId);
398 0 : ClusterMoniterGetAicpuCqeErrInfo(
399 0 : remoteLocalId, exceptionInfo->deviceid, errorMessage.ubCqeStatus, errorMessage.locEid.Describe(),
400 0 : errorMessage.rmtEid.Describe(), netInstanceId); // 上报AICPU CQE错误信息到集群监控
401 0 : return;
402 0 : }
403 :
404 0 : void TaskExceptionHost::ProcessException(rtExceptionInfo_t* exceptionInfo, const Hccl::TaskInfo& taskInfo)
405 : {
406 0 : HCCL_RUN_INFO("[TaskExceptionHost][%s]begin to execute hccl task exception callback function.", __func__);
407 0 : Hccl::ErrorMessageReport errorMessage;
408 0 : if (!hasAicpuReport_) { // 防止aicpu task exception重复上报
409 0 : hccl::CollComm* communicator = static_cast<hccl::CollComm*>(taskInfo.dfxOpInfo_->comm_);
410 0 : errorMessage = communicator->GetAicpuTaskException();
411 : }
412 :
413 0 : if (strlen(errorMessage.tag) > 0) {
414 0 : hasAicpuReport_ = true;
415 0 : HandleAicpuErrorReport(exceptionInfo, errorMessage, taskInfo);
416 : } else {
417 0 : HandleHostErrorReport(exceptionInfo, taskInfo);
418 : }
419 0 : }
420 :
421 2 : void TaskExceptionHost::HandleHostErrorReport(rtExceptionInfo_t* exceptionInfo, const Hccl::TaskInfo& taskInfo) const
422 : {
423 2 : HCCL_ERROR("[TaskExceptionHost][%s]Task from HCCL run failed.", __func__);
424 2 : if (taskInfo.taskParam_.taskType == Hccl::TaskParamType::TASK_NOTIFY_WAIT) {
425 2 : if (ShouldReportError()) {
426 1 : PrintTaskContextInfo(exceptionInfo->deviceid, exceptionInfo->streamid, exceptionInfo->taskid);
427 17 : RPT_INPUT_ERR(
428 : true, "EI0002",
429 : std::vector<std::string>(
430 : {"remote_rankid", "base_information", "task_information", "group_rank_content"}),
431 : std::vector<std::string>(
432 : {std::to_string(taskInfo.remoteRank_), taskInfo.GetBaseInfo(), (taskInfo.GetParaInfo()), ""}));
433 : } else {
434 1 : HCCL_WARNING(
435 : "[TaskExceptionHost] EI0002 already reported on device[%u], skip duplicate.", exceptionInfo->deviceid);
436 : }
437 : }
438 2 : std::string clusterMonitorErrMsg = AicpuGetAndPrintClusterMonitorErr(exceptionInfo);
439 2 : HCCL_ERROR(
440 : "[TaskExceptionHost]Task run failed, base information is deviceID:[%u], %s.", exceptionInfo->deviceid,
441 : taskInfo.GetIndopBaseInfo().c_str());
442 2 : HCCL_ERROR("[TaskExceptionHost]Task run failed, para information is %s.", taskInfo.GetParaInfo().c_str());
443 2 : HCCL_ERROR("[TaskExceptionHost]Task run failed, groupRank information is %s.", GetGroupRankInfo(taskInfo).c_str());
444 2 : HCCL_ERROR("[TaskExceptionHost]Task run failed, opData information is %s.", taskInfo.GetIndopDataInfo().c_str());
445 4 : }
446 :
447 5 : void TaskExceptionHost::PrintTaskContextInfo(uint32_t deviceId, uint32_t streamId, uint32_t taskId) const
448 : {
449 5 : Hccl::TaskInfoQueue* queue = nullptr;
450 : try {
451 5 : queue = Hccl::GlobalMirrorTasks::Instance().GetQueue(deviceId, streamId);
452 0 : } catch (Hccl::HcclException& e) {
453 0 : HCCL_ERROR("Exception task queue not found. deviceId[%u], streamId[%u].", deviceId, streamId);
454 0 : return;
455 0 : }
456 :
457 5 : if (queue == nullptr) {
458 : // 未找到异常对应的TaskQueue
459 0 : HCCL_ERROR("Exception task queue not found. deviceId[%u], streamId[%u].", deviceId, streamId);
460 0 : return;
461 : }
462 :
463 31 : auto func = [taskId](const unique_ptr<Hccl::TaskInfo>& task) {
464 31 : return task->taskId_ == taskId;
465 5 : };
466 5 : auto taskIterPtr = queue->Find(func);
467 5 : if (taskIterPtr == nullptr || *taskIterPtr == *queue->End()) {
468 : // 在队列中未找到异常对应的TaskInfo
469 2 : HCCL_ERROR("Exception task not found. deviceId[%u], streamId[%u], taskId[%u].", deviceId, streamId, taskId);
470 2 : return;
471 : }
472 :
473 : // 找到当前异常task的前50个task(至多)
474 3 : vector<Hccl::TaskInfo*> taskContext{};
475 10 : for (uint32_t i = 0; i < TASK_CONTEXT_SIZE && *taskIterPtr != *queue->Begin(); ++i, --(*taskIterPtr)) {
476 8 : if ((**taskIterPtr)->taskId_ > taskId) {
477 1 : HCCL_ERROR(
478 : "[%s]prev taskId[%u] is bigger than err taskId[%u], traversal end.", __func__, (**taskIterPtr)->taskId_,
479 : taskId);
480 1 : break;
481 : }
482 7 : taskContext.emplace_back((**taskIterPtr).get());
483 : }
484 :
485 3 : HCCL_ERROR("[TaskExceptionHost]Task run failed, context sequence before error task is "
486 : "[SDMA:M(rank), RDMA:RS(rank,id), SendPayload:SP(rank), InlineReduce:IR(rank), Reduce:R(rank), "
487 : "NotifyRecord:NR(rank,id), NotifyWait:NW(rank,id), SendNotify:SN(rank,id), "
488 : "WriteWithNotify:WN(rank,id), WriteReduceWithNotify:WRN(rank,id)]:");
489 :
490 3 : std::string taskContextInfo = "";
491 10 : for (auto it = taskContext.rbegin(); it != taskContext.rend(); ++it) {
492 7 : std::string conciseInfo = (*it)->GetConciseBaseInfo();
493 7 : conciseInfo += ",";
494 :
495 7 : if (taskContextInfo.size() + conciseInfo.size() >= TASK_CONTEXT_INFO_SIZE) {
496 0 : HCCL_ERROR("[TaskExceptionHost]%s", taskContextInfo.c_str());
497 0 : taskContextInfo = "";
498 : }
499 :
500 7 : taskContextInfo += conciseInfo;
501 7 : }
502 3 : HCCL_ERROR("[TaskExceptionHost]%s end.", taskContextInfo.c_str());
503 5 : }
504 :
505 0 : inline void PrintBaseErrorLog(const std::string& stageErrInfo, const std::string& baseInfo)
506 : {
507 0 : HCCL_ERROR("%sTask run failed, base information is %s", stageErrInfo.c_str(), baseInfo.c_str());
508 0 : }
509 :
510 0 : inline void PrintParaErrorLog(const std::string& stageErrInfo, const std::string& paraInfoStr)
511 : {
512 0 : HCCL_ERROR("%sTask run failed, para information is %s.", stageErrInfo.c_str(), paraInfoStr.c_str());
513 0 : }
514 :
515 0 : inline void PrintOpDataErrorLog(const std::string& stageErrInfo, const std::string& opDataContent)
516 : {
517 0 : HCCL_ERROR("%sTask run failed, opData information is %s", stageErrInfo.c_str(), opDataContent.c_str());
518 0 : }
519 :
520 0 : inline void PrintGroupErrorLog(const std::string& stageErrInfo, const std::string& groupRankContent)
521 : {
522 0 : HCCL_ERROR("%sTask run failed, groupRank information is %s.", stageErrInfo.c_str(), groupRankContent.c_str());
523 0 : }
524 :
525 0 : void TaskExceptionHost::PrintGroupErrorMessage(
526 : const Hccl::ErrorMessageReport& errorMessage, [[maybe_unused]] const Hccl::TaskInfo& exceptionTaskInfo,
527 : std::string& groupRankContent, std::string& stageErrInfo) const
528 : {
529 0 : groupRankContent += "group:[";
530 0 : groupRankContent += std::string(errorMessage.group);
531 0 : groupRankContent += "], rankSize[";
532 0 : groupRankContent += std::to_string(errorMessage.rankSize);
533 0 : groupRankContent += "], localRank[";
534 0 : groupRankContent += std::to_string(errorMessage.rankId);
535 0 : groupRankContent += "], remoteRank[";
536 0 : groupRankContent += std::to_string(errorMessage.remoteUserRank);
537 0 : groupRankContent += "]";
538 :
539 0 : PrintGroupErrorLog(stageErrInfo, groupRankContent);
540 0 : return;
541 : }
542 :
543 : const std::map<HcclReduceOp, std::string> HCOM_REDUCE_OP_STR_MAP{
544 : {HcclReduceOp::HCCL_REDUCE_SUM, "sum"},
545 : {HcclReduceOp::HCCL_REDUCE_PROD, "prod"},
546 : {HcclReduceOp::HCCL_REDUCE_MAX, "max"},
547 : {HcclReduceOp::HCCL_REDUCE_MIN, "min"},
548 : {HcclReduceOp::HCCL_REDUCE_RESERVED, "invalid"}};
549 :
550 0 : inline std::string GetReduceOpEnumStr2(HcclReduceOp reduceOp)
551 : {
552 0 : auto iter = HCOM_REDUCE_OP_STR_MAP.find(reduceOp);
553 0 : if (iter == HCOM_REDUCE_OP_STR_MAP.end()) {
554 0 : return "HcclReduceOp(" + std::to_string(reduceOp) + ")";
555 : } else {
556 0 : return iter->second;
557 : }
558 : }
559 :
560 : const std::map<HcclDataType, std::string> HCOM_DATA_TYPE_STR_MAP{
561 : {HcclDataType::HCCL_DATA_TYPE_INT8, "int8"}, {HcclDataType::HCCL_DATA_TYPE_INT16, "int16"},
562 : {HcclDataType::HCCL_DATA_TYPE_INT32, "int32"}, {HcclDataType::HCCL_DATA_TYPE_INT64, "int64"},
563 : {HcclDataType::HCCL_DATA_TYPE_UINT64, "uint64"}, {HcclDataType::HCCL_DATA_TYPE_FP16, "float16"},
564 : {HcclDataType::HCCL_DATA_TYPE_FP32, "float32"}, {HcclDataType::HCCL_DATA_TYPE_UINT8, "uint8"},
565 : {HcclDataType::HCCL_DATA_TYPE_UINT16, "uint16"}, {HcclDataType::HCCL_DATA_TYPE_UINT32, "uint32"},
566 : {HcclDataType::HCCL_DATA_TYPE_FP64, "float64"}, {HcclDataType::HCCL_DATA_TYPE_BFP16, "bfloat16"},
567 : {HcclDataType::HCCL_DATA_TYPE_INT128, "int128"}, {HcclDataType::HCCL_DATA_TYPE_FP8E4M3, "fp8e4m3"},
568 : {HcclDataType::HCCL_DATA_TYPE_FP8E5M2, "fp8e5m2"}, {HcclDataType::HCCL_DATA_TYPE_RESERVED, "reserved"}};
569 :
570 0 : inline std::string GetDataTypeEnumStr2(HcclDataType dataType)
571 : {
572 0 : auto iter = HCOM_DATA_TYPE_STR_MAP.find(dataType);
573 0 : if (iter == HCOM_DATA_TYPE_STR_MAP.end()) {
574 0 : return "HcclDataType(" + std::to_string(dataType) + ")";
575 : } else {
576 0 : return iter->second;
577 : }
578 : }
579 :
580 0 : inline std::string GetDataTypeEnumStr(u32 dataType)
581 : {
582 0 : auto hcclDataType = static_cast<HcclDataType>(dataType);
583 0 : return GetDataTypeEnumStr2(hcclDataType);
584 : }
585 : inline std::string GetOpTypeEnumStr(u32 opType)
586 : {
587 : Hccl::OpType hcclOpType = static_cast<Hccl::OpType::Value>(opType);
588 : return hcclOpType.Describe();
589 : }
590 :
591 0 : void TaskExceptionHost::PrintOpDataErrorMessage(
592 : u32 deviceId, const Hccl::ErrorMessageReport& errorMessage, std::string& stageErrInfo) const
593 : {
594 0 : std::stringstream opDataStr;
595 0 : opDataStr << "src" << "[0x" << std::hex << errorMessage.srcAddr << "], dst[0x" << std::hex << errorMessage.dstAddr
596 0 : << "], ";
597 :
598 0 : std::string opStr;
599 0 : if (errorMessage.reduceType != HcclReduceOp::HCCL_REDUCE_RESERVED) {
600 0 : opStr += "reduceType[";
601 0 : opStr += GetReduceOpEnumStr2(static_cast<HcclReduceOp>(errorMessage.reduceType));
602 0 : opStr += "], ";
603 : }
604 :
605 0 : std::string opDataContent;
606 0 : opDataContent += "deviceId:[";
607 0 : opDataContent += std::to_string(deviceId);
608 0 : opDataContent += "], index[";
609 0 : opDataContent += std::to_string(errorMessage.opIndex);
610 0 : opDataContent += "], count[";
611 0 : opDataContent += std::to_string(errorMessage.count);
612 0 : opDataContent += "], ";
613 0 : opDataContent += opStr;
614 0 : opDataContent += opDataStr.str();
615 0 : opDataContent += "dataType[";
616 0 : opDataContent += GetDataTypeEnumStr(errorMessage.dataType);
617 0 : opDataContent += "].";
618 :
619 0 : PrintOpDataErrorLog(stageErrInfo, opDataContent);
620 0 : return;
621 0 : }
622 :
623 2 : void TaskExceptionHost::ReportErrorMsg(
624 : const Hccl::TaskInfo& exceptionTaskInfo, [[maybe_unused]] const std::string& groupRankContent,
625 : const Hccl::ErrorMessageReport& errorMessage, rtExceptionInfo_t* exceptionInfo) const
626 : {
627 2 : HCCL_RUN_INFO("[ReportErrorMsg] start, taskType[%d]", exceptionTaskInfo.taskParam_.taskType);
628 :
629 2 : std::string clusterMonitorErrMsg = AicpuGetAndPrintClusterMonitorErr(exceptionInfo);
630 :
631 2 : if (exceptionTaskInfo.taskParam_.taskType == Hccl::TaskParamType::TASK_NOTIFY_WAIT) {
632 2 : if (ShouldReportError()) {
633 1 : HCCL_ERROR("[ReportErrorMsg] EI0002");
634 18 : RPT_INPUT_ERR(
635 : true, "EI0002",
636 : std::vector<std::string>(
637 : {"remote_rankid", "base_information", "task_information", "group_rank_content"}),
638 : std::vector<std::string>(
639 : {std::to_string(exceptionTaskInfo.remoteRank_), exceptionTaskInfo.GetIndopBaseInfo().c_str(),
640 : (exceptionTaskInfo.GetParaInfo() + clusterMonitorErrMsg).c_str(), ""}));
641 : } else {
642 1 : HCCL_WARNING(
643 : "[ReportErrorMsg] EI0002 already reported on device[%u], skip duplicate.", exceptionInfo->deviceid);
644 : }
645 0 : } else if (
646 0 : exceptionTaskInfo.taskParam_.taskType == Hccl::TaskParamType::TASK_WRITE_REDUCE_WITH_NOTIFY
647 0 : || exceptionTaskInfo.taskParam_.taskType == Hccl::TaskParamType::TASK_WRITE_WITH_NOTIFY
648 0 : || exceptionTaskInfo.taskParam_.taskType == Hccl::TaskParamType::TASK_UB_INLINE_WRITE
649 0 : || exceptionTaskInfo.taskParam_.taskType == Hccl::TaskParamType::TASK_UB_REDUCE_INLINE
650 0 : || exceptionTaskInfo.taskParam_.taskType == Hccl::TaskParamType::TASK_UB) {
651 0 : ReportEI0018Error(exceptionTaskInfo, errorMessage);
652 : }
653 5 : }
654 :
655 4 : bool TaskExceptionHost::ShouldReportError() const
656 : {
657 4 : std::lock_guard<std::mutex> lock(ei0002ReportedMutex_);
658 4 : if (!ei0002Reported_) {
659 2 : ei0002Reported_ = true;
660 2 : return true;
661 : }
662 2 : return false;
663 4 : }
664 :
665 0 : void TaskExceptionHost::ReportEI0018Error(
666 : const Hccl::TaskInfo& exceptionTaskInfo, const Hccl::ErrorMessageReport& errorMessage) const
667 : {
668 0 : hccl::CollComm* collComm = static_cast<hccl::CollComm*>(exceptionTaskInfo.dfxOpInfo_->comm_);
669 0 : std::string localServerId = "";
670 0 : GetAicpuCqeErrNetInstanceByRankId(collComm, errorMessage.rankId, localServerId);
671 0 : u32 localDeviceId = Hccl::DFX_INVALID_RANKID;
672 0 : GetAicpuCqeErrRemoteLocalIdByRankId(collComm, errorMessage.rankId, localDeviceId);
673 0 : std::string remoteServerId = "";
674 0 : GetAicpuCqeErrNetInstanceByRankId(collComm, errorMessage.remoteUserRank, remoteServerId);
675 0 : u32 remoteDeviceId = Hccl::DFX_INVALID_RANKID;
676 0 : GetAicpuCqeErrRemoteLocalIdByRankId(collComm, errorMessage.remoteUserRank, remoteDeviceId);
677 0 : Hccl::IpAddress localAddr(errorMessage.locEid);
678 0 : Hccl::IpAddress remoteAddr(errorMessage.rmtEid);
679 0 : HCCL_ERROR("[ReportErrorMsg] EI0018");
680 0 : RPT_INPUT_ERR(
681 : true, "EI0018",
682 : std::vector<std::string>(
683 : {"localServerId", "localDeviceId", "localDeviceIp", "remoteServerId", "remoteDeviceId", "remoteDeviceIp"}),
684 : std::vector<std::string>(
685 : {localServerId, std::to_string(localDeviceId), localAddr.GetReverseEid().Describe().c_str(), remoteServerId,
686 : std::to_string(remoteDeviceId), remoteAddr.GetReverseEid().Describe().c_str()}));
687 0 : }
688 :
689 9 : void GetTaskParam(Hccl::TaskParam& taskParam, const Hccl::ErrorMessageReport& errMsgInfo)
690 : {
691 9 : switch (errMsgInfo.taskType) {
692 2 : case Hccl::TaskParamType::TASK_NOTIFY_WAIT:
693 : case Hccl::TaskParamType::TASK_NOTIFY_RECORD:
694 2 : taskParam.taskPara.Notify.notifyID = errMsgInfo.notifyId;
695 2 : taskParam.taskPara.Notify.value = errMsgInfo.notifyValue;
696 2 : break;
697 2 : case Hccl::TaskParamType::TASK_UB_REDUCE_INLINE:
698 : case Hccl::TaskParamType::TASK_WRITE_REDUCE_WITH_NOTIFY:
699 2 : taskParam.taskPara.Reduce.notifyID = errMsgInfo.notifyId;
700 2 : taskParam.taskPara.Reduce.notifyValue = errMsgInfo.notifyValue;
701 2 : taskParam.taskPara.Reduce.locEid = errMsgInfo.locEid;
702 2 : taskParam.taskPara.Reduce.rmtEid = errMsgInfo.rmtEid;
703 2 : taskParam.taskPara.Reduce.linkType = errMsgInfo.linkType;
704 2 : taskParam.taskPara.Reduce.size = errMsgInfo.size;
705 2 : taskParam.taskPara.Reduce.src = reinterpret_cast<void*>(errMsgInfo.taskSrcAddr);
706 2 : taskParam.taskPara.Reduce.dst = reinterpret_cast<void*>(errMsgInfo.taskDstAddr);
707 2 : break;
708 1 : case Hccl::TaskParamType::TASK_REDUCE_INLINE:
709 1 : taskParam.taskPara.Reduce.reduceOp = static_cast<HcclReduceOp>(errMsgInfo.reduceType);
710 1 : break;
711 2 : case Hccl::TaskParamType::TASK_UB_INLINE_WRITE:
712 : case Hccl::TaskParamType::TASK_WRITE_WITH_NOTIFY:
713 2 : taskParam.taskPara.DMA.notifyID = errMsgInfo.notifyId;
714 2 : taskParam.taskPara.DMA.notifyValue = errMsgInfo.notifyValue;
715 2 : taskParam.taskPara.DMA.locEid = errMsgInfo.locEid;
716 2 : taskParam.taskPara.DMA.rmtEid = errMsgInfo.rmtEid;
717 2 : taskParam.taskPara.DMA.linkType = errMsgInfo.linkType;
718 2 : taskParam.taskPara.DMA.size = errMsgInfo.size;
719 2 : taskParam.taskPara.DMA.src = reinterpret_cast<void*>(errMsgInfo.taskSrcAddr);
720 2 : taskParam.taskPara.DMA.dst = reinterpret_cast<void*>(errMsgInfo.taskDstAddr);
721 2 : break;
722 1 : case Hccl::TaskParamType::TASK_UB:
723 1 : taskParam.taskPara.DMA.locEid = errMsgInfo.locEid;
724 1 : taskParam.taskPara.DMA.rmtEid = errMsgInfo.rmtEid;
725 1 : taskParam.taskPara.DMA.linkType = errMsgInfo.linkType;
726 1 : taskParam.taskPara.DMA.size = errMsgInfo.size;
727 1 : taskParam.taskPara.DMA.src = reinterpret_cast<void*>(errMsgInfo.taskSrcAddr);
728 1 : taskParam.taskPara.DMA.dst = reinterpret_cast<void*>(errMsgInfo.taskDstAddr);
729 1 : break;
730 1 : case Hccl::TaskParamType::TASK_SDMA:
731 1 : taskParam.taskPara.DMA.linkType = errMsgInfo.linkType;
732 1 : taskParam.taskPara.DMA.size = errMsgInfo.size;
733 1 : taskParam.taskPara.DMA.src = reinterpret_cast<void*>(errMsgInfo.taskSrcAddr);
734 1 : taskParam.taskPara.DMA.dst = reinterpret_cast<void*>(errMsgInfo.taskDstAddr);
735 1 : break;
736 0 : default:
737 0 : HCCL_ERROR("[TaskException][HOST]%s taskType[%d] is not supported", __func__, taskParam.taskType);
738 0 : return;
739 : }
740 : }
741 :
742 0 : void TaskExceptionHost::HandleAicpuErrorReport(
743 : rtExceptionInfo_t* exceptionInfo, const Hccl::ErrorMessageReport& errorMessage,
744 : const Hccl::TaskInfo& taskInfo) const
745 : {
746 0 : std::string groupRankContent;
747 0 : u32 streamId = static_cast<u32>(errorMessage.streamId);
748 0 : std::string tag = std::string(errorMessage.tag);
749 0 : Hccl::TaskParam taskParam{};
750 0 : taskParam.taskType = errorMessage.taskType;
751 0 : GetTaskParam(taskParam, errorMessage);
752 0 : std::shared_ptr<Hccl::DfxOpInfo> dfxOpInfo = std::make_shared<Hccl::DfxOpInfo>();
753 0 : dfxOpInfo->tag_ = tag;
754 0 : dfxOpInfo->comm_ = taskInfo.dfxOpInfo_->comm_;
755 0 : Hccl::TaskInfo exceptionTaskInfo(streamId, errorMessage.taskId, errorMessage.remoteUserRank, taskParam, dfxOpInfo);
756 0 : auto logKeywordL2 = exceptionTaskInfo.taskParam_.taskType == Hccl::TaskParamType::TASK_NOTIFY_WAIT ?
757 : Hccl::LOG_KEYWORDS_TIMEOUT :
758 0 : Hccl::LOG_KEYWORDS_RUN_FAILED;
759 : auto stageErrInfo
760 0 : = "[" + Hccl::LOG_KEYWORDS_TASK_EXEC + "][" + logKeywordL2 + "][" + Hccl::LOG_KEYWORDS_AICPU + "]";
761 0 : HCCL_ERROR("%sTask from HCCL run failed.", stageErrInfo.c_str());
762 : // 防止tag字符串过长， 信息分开打印
763 0 : PrintBaseErrorLog(stageErrInfo, exceptionTaskInfo.GetIndopBaseInfo());
764 0 : PrintParaErrorLog(stageErrInfo, exceptionTaskInfo.GetParaInfo());
765 0 : PrintGroupErrorMessage(errorMessage, exceptionTaskInfo, groupRankContent, stageErrInfo);
766 0 : PrintOpDataErrorMessage(exceptionInfo->deviceid, errorMessage, stageErrInfo);
767 0 : HCCL_ERROR(
768 : "errorMessage taskType[%s], rtCqErrorType[%u], rtCqErrorCode[%u]. ", errorMessage.taskType.Describe().c_str(),
769 : static_cast<u32>(errorMessage.rtCqErrorType), errorMessage.rtCqErrorCode);
770 :
771 : // 打印UB DFX寄存器信息
772 0 : PrintUbDfxInfo(exceptionInfo, errorMessage);
773 0 : ReportErrorMsg(exceptionTaskInfo, groupRankContent, errorMessage, exceptionInfo);
774 0 : if (errorMessage.ubCqeStatus != 0) {
775 0 : GetAicpuCqeErrInfo(exceptionInfo, errorMessage, taskInfo);
776 : }
777 0 : }
778 :
779 0 : void TaskExceptionHost::PrintUbDfxInfo(
780 : rtExceptionInfo_t* exceptionInfo, const Hccl::ErrorMessageReport& errorMessage) const
781 : {
782 0 : if (errorMessage.taskType == Hccl::TaskParamType::TASK_WRITE_WITH_NOTIFY
783 0 : || errorMessage.taskType == Hccl::TaskParamType::TASK_WRITE_REDUCE_WITH_NOTIFY
784 0 : || errorMessage.taskType == Hccl::TaskParamType::TASK_UB_INLINE_WRITE
785 0 : || errorMessage.taskType == Hccl::TaskParamType::TASK_UB_REDUCE_INLINE
786 0 : || errorMessage.taskType == Hccl::TaskParamType::TASK_UB) {
787 0 : HCCL_ERROR(
788 : "errorMessage ubCqeStatus[%u], localEid[%s], remoteEid[%s]. ", static_cast<u32>(errorMessage.ubCqeStatus),
789 : errorMessage.locEid.Describe().c_str(), errorMessage.rmtEid.Describe().c_str());
790 0 : auto addr = Hccl::IpAddress(errorMessage.locEid);
791 0 : u32 devPhyId = Hccl::HrtGetDevicePhyIdByIndex(exceptionInfo->deviceid);
792 0 : auto rdmaHandle = Hccl::RdmaHandleManager::GetInstance().GetByIp(devPhyId, addr);
793 0 : HrtRaDumpJettyContext(reinterpret_cast<void*>(errorMessage.jettyHandle), errorMessage.jettyId);
794 0 : PrintUbRegisters(static_cast<s32>(exceptionInfo->deviceid), rdmaHandle);
795 : }
796 0 : }
797 : } // namespace hcomm
|
