【PR】: feat: get notify events and device time-runtime-AtomGit

Minclude/driver/ascend_hal_base.h+18-0

	@@ -427,6 +427,8 @@ typedef enum {
427	INFO_TYPE_CPU_TOPO,	427	INFO_TYPE_CPU_TOPO,
428	INFO_TYPE_SLOT_ID,	428	INFO_TYPE_SLOT_ID,
429	INFO_TYPE_SWPLUGIN_UPGRADE_POLICY,	429	INFO_TYPE_SWPLUGIN_UPGRADE_POLICY,
		430	+ INFO_TYPE_SUPER_POD_INTERCON_TYPE,
		431	+ INFO_TYPE_REAL_TIME,
430	} DEV_INFO_TYPE;	432	} DEV_INFO_TYPE;
431		433
432	/**	434	/**
	@@ -5432,6 +5434,22 @@ DLLEXPORT drvError_t halGetDevIDsEx(uint32_t hw_type, uint32_t *devices, uint32_
5432	DLLEXPORT drvError_t halGetFaultEvent(uint32_t devId, struct halEventFilter* filter,	5434	DLLEXPORT drvError_t halGetFaultEvent(uint32_t devId, struct halEventFilter* filter,
5433	struct halFaultEventInfo* eventInfo, uint32_t len, uint32_t *eventCount);	5435	struct halFaultEventInfo* eventInfo, uint32_t len, uint32_t *eventCount);
5434		5436
		5437	+/**
		5438	+* @ingroup driver
		5439	+* @brief Support calling on host sides. Currently, not supported called in split mode.
		5440	+* If filter->filter_flag set to 0, it means do not filter events and get all events.
		5441	+* @attention If len equal to eventCount, some events may have been abandoned.
		5442	+* @param [in] devId the device id, not support -1
		5443	+* @param [in] filter Filter conditions
		5444	+* filter->filter_flag; bit0: event_id; bit1: severity; bit2: node_type; bit3: current tgid
		5445	+* @param [in] len the number of eventInfo
		5446	+* @param [out] eventInfo Notify event information
		5447	+* @param [out] eventCount Number of events obtained. Max 128
		5448	+* @return 0 for success, others for fail
		5449	+*/
		5450	+DLLEXPORT drvError_t halGetNotifyEvent(uint32_t devId, struct halEventFilter* filter,
		5451	+ struct halFaultEventInfo* eventInfo, uint32_t len, uint32_t *eventCount);
		5452	+
5435	/**	5453	/**
5436	* @ingroup driver	5454	* @ingroup driver
5437	* @brief Support calling host sides. Currently, not supported called in split mode.	5455	* @brief Support calling host sides. Currently, not supported called in split mode.

Msrc/runtime/core/inc/device/device_error_info.hpp+5-0

	@@ -121,6 +121,11 @@ extern const std::map<uint32_t, std::string> g_l2MulBitEccEventIdBlkList;
121		121
122	extern const std::map<uint32_t, std::string> g_ccuTimeoutEventIdBlkList;	122	extern const std::map<uint32_t, std::string> g_ccuTimeoutEventIdBlkList;
123		123
		124	+struct EventBlkEntry {
		125	+ uint32_t eventId;
		126	+ const std::map<uint32_t, std::string> &blkList;
		127	+};
		128	+
124	enum rtSdmaErrorType : std::uint32_t {	129	enum rtSdmaErrorType : std::uint32_t {
125	// Submission Descriptor read response error	130	// Submission Descriptor read response error
126	// this is bit position	131	// this is bit position

Msrc/runtime/core/inc/device/device_error_proc.hpp+2-2

	@@ -35,8 +35,8 @@ void SetTaskMteErr(TaskInfo errTaskPtr, const Device const dev,
35	const std::map<uint32_t, std::string>& eventIdBlkList = g_mulBitEccEventId);	35	const std::map<uint32_t, std::string>& eventIdBlkList = g_mulBitEccEventId);
36	void GetMteErrFromCqeStatus(TaskInfo errTaskPtr, const Device const dev, const uint32_t cqeStatus,	36	void GetMteErrFromCqeStatus(TaskInfo errTaskPtr, const Device const dev, const uint32_t cqeStatus,
37	const std::map<uint32_t, std::string>& eventIdBlkList = g_mulBitEccEventId);	37	const std::map<uint32_t, std::string>& eventIdBlkList = g_mulBitEccEventId);
38	-rtError_t GetDeviceFaultEvents(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo,	38	+rtError_t GetDeviceFaultEvents(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo, uint32_t &eventCount,
39	- uint32_t &eventCount, const uint32_t maxFaultNum = 128U);	39	+ bool needLog = true);
40	bool IsFaultEventOccur(const uint32_t faultEventId, const rtDmsFaultEvent * const faultEventInfo, const uint32_t eventCount);	40	bool IsFaultEventOccur(const uint32_t faultEventId, const rtDmsFaultEvent * const faultEventInfo, const uint32_t eventCount);
41	bool IsHitBlacklist(const rtDmsFaultEvent *faultEventInfo, const uint32_t eventCount, const std::map<uint32_t, std::string>& eventIdBlkList);	41	bool IsHitBlacklist(const rtDmsFaultEvent *faultEventInfo, const uint32_t eventCount, const std::map<uint32_t, std::string>& eventIdBlkList);
42	bool IsHitBlacklist(const uint32_t deviceId, const std::map<uint32_t, std::string>& eventIdBlkList);	42	bool IsHitBlacklist(const uint32_t deviceId, const std::map<uint32_t, std::string>& eventIdBlkList);

Msrc/runtime/core/inc/runtime.hpp+3-1

	@@ -68,6 +68,8 @@ constexpr uint32_t RAS_QUERY_INTERVAL = 10U;
68	constexpr uint16_t RAS_QUERY_MAX_COUNT = 50U;	68	constexpr uint16_t RAS_QUERY_MAX_COUNT = 50U;
69	constexpr uint16_t RT_DSM_EVENT_FILTER_FLAG_EVENT_ID = 1U;	69	constexpr uint16_t RT_DSM_EVENT_FILTER_FLAG_EVENT_ID = 1U;
70	constexpr uint16_t READ_FAULT_EVENT_TIMEOUT = 1000U; // 1s	70	constexpr uint16_t READ_FAULT_EVENT_TIMEOUT = 1000U; // 1s
		71	+constexpr uint32_t RAS_GET_MAX_NUM_SI = 128U; // single interface max event count
		72	+constexpr uint32_t RAS_GET_MAX_NUM = 256U; // halGetFaultEvent max 128, halGetNotifyEvent max 128
71		73
72	constexpr size_t NON_CPU_KERNEL_ARGS_ALIGN_SIZE = sizeof(uint64_t);	74	constexpr size_t NON_CPU_KERNEL_ARGS_ALIGN_SIZE = sizeof(uint64_t);
73	constexpr size_t CPU_KERNEL_ARGS_ALIGN_SIZE = 1U;	75	constexpr size_t CPU_KERNEL_ARGS_ALIGN_SIZE = 1U;
	@@ -936,7 +938,7 @@ private:
936	rtError_t GetDcacheLockMixOpPath(std::string &dcacheLockMixOpPath) const;	938	rtError_t GetDcacheLockMixOpPath(std::string &dcacheLockMixOpPath) const;
937	void ReportHBMRasProc();	939	void ReportHBMRasProc();
938	void ReportUBMemRasProc();	940	void ReportUBMemRasProc();
939	- void ProcUBMemNetworkException(const uint32_t devId, const rtDmsFaultEvent *faultEventInfo, uint32_t eventCount) const;	941	+ static void ProcUBMemNetworkException(const uint32_t devId, const rtDmsFaultEvent *faultEventInfo, uint32_t eventCount);
940	void ProcHBMRas(const uint32_t devId);	942	void ProcHBMRas(const uint32_t devId);
941	void ReportPageFaultProc();	943	void ReportPageFaultProc();
942	void ProcPageFault(Device * const device, const uint32_t value);	944	void ProcPageFault(Device * const device, const uint32_t value);

Msrc/runtime/core/src/api_impl/api_impl.cc+8-5文件内容审核中，请稍后刷新重试

Msrc/runtime/core/src/api_impl/api_impl_david.cc+1-0

	@@ -1992,6 +1992,7 @@ rtError_t ApiImplDavid::RepairError(const uint32_t deviceId, const rtErrorInfo *
1992	RT_LOG(RT_LOG_ERROR, "Does not support current error type [%d]", errorInfo->errorType);	1992	RT_LOG(RT_LOG_ERROR, "Does not support current error type [%d]", errorInfo->errorType);
1993	break;	1993	break;
1994	}	1994	}
		1995	+ dev->SetBaseTime();
1995	return error;	1996	return error;
1996	}	1997	}
1997		1998

Msrc/runtime/core/src/device/device.hpp+2-0

	@@ -337,6 +337,8 @@ public:
337	virtual bool IsDmaCpyNumLimit() const = 0;	337	virtual bool IsDmaCpyNumLimit() const = 0;
338	virtual int64_t GetPhyChipId() const = 0;	338	virtual int64_t GetPhyChipId() const = 0;
339	virtual int64_t GetPhyDieId() const = 0;	339	virtual int64_t GetPhyDieId() const = 0;
		340	+ virtual int64_t GetBaseTime() const = 0;
		341	+ virtual void SetBaseTime() = 0;
340	virtual Stream *GetNextRecycleStream() = 0;	342	virtual Stream *GetNextRecycleStream() = 0;
341	virtual bool IsSupportEventPool() = 0;	343	virtual bool IsSupportEventPool() = 0;
342	virtual bool PopNextPoolFreeEventId() = 0;	344	virtual bool PopNextPoolFreeEventId() = 0;

Msrc/runtime/core/src/device/device_error_core_proc.cc+13-35

	@@ -795,15 +795,9 @@ bool IsSmmuFault(const uint32_t deviceId)
795		795
796	bool IsHitBlacklist(const uint32_t deviceId, const std::map<uint32_t, std::string>& eventIdBlkList)	796	bool IsHitBlacklist(const uint32_t deviceId, const std::map<uint32_t, std::string>& eventIdBlkList)
797	{	797	{
798	- constexpr uint32_t maxFaultNum = 128U;	798	+ std::vector<rtDmsFaultEvent> faultEventInfo(RAS_GET_MAX_NUM, rtDmsFaultEvent{});
799	- std::vector<rtDmsFaultEvent> faultEventInfo(maxFaultNum);
800	-
801	- constexpr size_t totalSize = maxFaultNum * sizeof(rtDmsFaultEvent);
802	- const auto eRet = memset_s(&faultEventInfo[0U], totalSize, 0, totalSize);
803	- COND_RETURN_WARN(eRet != EOK, false, "Mem set error, ret=%d", eRet);
804	-
805	uint32_t eventCount = 0U;	799	uint32_t eventCount = 0U;
806	- rtError_t error = GetDeviceFaultEvents(deviceId, &faultEventInfo[0U], eventCount, maxFaultNum);	800	+ const rtError_t error = GetDeviceFaultEvents(deviceId, &faultEventInfo[0U], eventCount);
807	COND_PROC((error != RT_ERROR_NONE), return false);	801	COND_PROC((error != RT_ERROR_NONE), return false);
808	for (uint32_t faultIndex = 0U; faultIndex < eventCount; faultIndex++) {	802	for (uint32_t faultIndex = 0U; faultIndex < eventCount; faultIndex++) {
809	if (eventIdBlkList.find(faultEventInfo[faultIndex].eventId) != eventIdBlkList.end()) {	803	if (eventIdBlkList.find(faultEventInfo[faultIndex].eventId) != eventIdBlkList.end()) {
	@@ -820,21 +814,13 @@ bool IsHitBlacklist(const uint32_t deviceId, const std::map<uint32_t, std::strin
820		814
821	bool HasBlacklistEventOnDevice(const uint32_t deviceId, const std::map<uint32_t, std::string>& eventIdBlkList)	815	bool HasBlacklistEventOnDevice(const uint32_t deviceId, const std::map<uint32_t, std::string>& eventIdBlkList)
822	{	816	{
823	- constexpr uint32_t maxFaultNum = 128U;	817	+ std::vector<rtDmsFaultEvent> faultEventInfo(RAS_GET_MAX_NUM, rtDmsFaultEvent{});
824	- rtDmsFaultEvent *faultEventInfo = new (std::nothrow)rtDmsFaultEvent[maxFaultNum];
825	- COND_RETURN_AND_MSG_OUTER(faultEventInfo == nullptr, false, ErrorCode::EE1013,
826	- maxFaultNum * sizeof(rtDmsFaultEvent), "new");
827	- constexpr size_t totalSize = maxFaultNum * sizeof(rtDmsFaultEvent);
828	- (void)memset_s(faultEventInfo, totalSize, 0, totalSize);
829	-
830	- const std::function<void()> releaseFunc = [&faultEventInfo]() { DELETE_A(faultEventInfo); };
831	- ScopeGuard faultEventInfoRelease(releaseFunc);
832	uint32_t eventCount = 0U;	818	uint32_t eventCount = 0U;
833	- rtError_t error = GetDeviceFaultEvents(deviceId, faultEventInfo, eventCount, maxFaultNum);	819	+ const rtError_t error = GetDeviceFaultEvents(deviceId, &faultEventInfo[0U], eventCount);
834	if (error != RT_ERROR_NONE) {	820	if (error != RT_ERROR_NONE) {
835	return false;	821	return false;
836	}	822	}
837	- return IsHitBlacklist(faultEventInfo, eventCount, eventIdBlkList);	823	+ return IsHitBlacklist(&faultEventInfo[0U], eventCount, eventIdBlkList);
838	}	824	}
839		825
840	/* 检查是否存在黑名单中的UCE错误 */	826	/* 检查是否存在黑名单中的UCE错误 */
	@@ -860,7 +846,7 @@ bool IsHitBlacklist(const rtDmsFaultEvent *faultEventInfo, const uint32_t eventC
860	std::ostringstream oss;	846	std::ostringstream oss;
861	oss << std::hex << faultEventInfo[faultIndex].eventId;	847	oss << std::hex << faultEventInfo[faultIndex].eventId;
862	faultInfo = faultInfo + "[0x" + oss.str() + "]" + faultEventInfo[faultIndex].eventName;	848	faultInfo = faultInfo + "[0x" + oss.str() + "]" + faultEventInfo[faultIndex].eventName;
863	- RT_LOG(RT_LOG_INFO, "Fault message is: [%s].", faultInfo.c_str());	849	+ RT_LOG(RT_LOG_ERROR, "Fault message is: [%s].", faultInfo.c_str());
864	return true;	850	return true;
865	}	851	}
866	}	852	}
	@@ -881,16 +867,16 @@ bool IsFaultEventOccur(const uint32_t faultEventId, const rtDmsFaultEvent * cons
881	return false;	867	return false;
882	}	868	}
883		869
884	-rtError_t GetDeviceFaultEvents(const uint32_t deviceId, rtDmsFaultEvent* const faultEventInfo,	870	+rtError_t GetDeviceFaultEvents(const uint32_t deviceId, rtDmsFaultEvent* const faultEventInfo, uint32_t &eventCount,
885	- uint32_t &eventCount, const uint32_t maxFaultNum)	871	+ bool needLog)
886	{	872	{
887	rtError_t error = RT_ERROR_NONE;	873	rtError_t error = RT_ERROR_NONE;
888	- error = NpuDriver::GetAllFaultEvent(deviceId, faultEventInfo, maxFaultNum, &eventCount);	874	+ error = NpuDriver::GetAllFaultEvent(deviceId, faultEventInfo, &eventCount, needLog);
889	COND_RETURN_WARN(error == RT_ERROR_FEATURE_NOT_SUPPORT, RT_ERROR_FEATURE_NOT_SUPPORT,	875	COND_RETURN_WARN(error == RT_ERROR_FEATURE_NOT_SUPPORT, RT_ERROR_FEATURE_NOT_SUPPORT,
890	"Getting fault events is not supported.");	876	"Getting fault events is not supported.");
891	- COND_RETURN_ERROR((error != RT_ERROR_NONE) \|\| (eventCount > maxFaultNum), (error == RT_ERROR_NONE) ? RT_ERROR_DRV_ERR : error,	877	+ COND_RETURN_ERROR((error != RT_ERROR_NONE) \|\| (eventCount > RAS_GET_MAX_NUM), (error == RT_ERROR_NONE) ? RT_ERROR_DRV_ERR : error,
892	"Get fault event error, device_id=%u, eventCount=%u, maxFaultNum=%u, error=%#x.", deviceId,	878	"Get fault event error, device_id=%u, eventCount=%u, maxFaultNum=%u, error=%#x.", deviceId,
893	- eventCount, maxFaultNum, static_cast<uint32_t>(error));	879	+ eventCount, RAS_GET_MAX_NUM, static_cast<uint32_t>(error));
894	return error;	880	return error;
895	}	881	}
896		882
	@@ -990,17 +976,9 @@ bool IsEventRasMatch(const rtDmsFaultEvent &event, const EventRasFilter &filter)
990		976
991	bool IsEventIdAndRasCodeMatch( const uint32_t deviceId, const std::vector<EventRasFilter>& ubNonMemPoisonRasList)	977	bool IsEventIdAndRasCodeMatch( const uint32_t deviceId, const std::vector<EventRasFilter>& ubNonMemPoisonRasList)
992	{	978	{
993	- constexpr uint32_t maxFaultNum = 128U;	979	+ std::vector<rtDmsFaultEvent> faultEventInfo(RAS_GET_MAX_NUM, rtDmsFaultEvent{});
994	- rtDmsFaultEvent *faultEventInfo = new (std::nothrow)rtDmsFaultEvent[maxFaultNum];
995	- COND_RETURN_AND_MSG_OUTER(faultEventInfo == nullptr, false, ErrorCode::EE1013,
996	- maxFaultNum * sizeof(rtDmsFaultEvent), "new");
997	- constexpr size_t totalSize = maxFaultNum * sizeof(rtDmsFaultEvent);
998	- (void)memset_s(faultEventInfo, totalSize, 0, totalSize);
999	-
1000	- const std::function<void()> releaseFunc = [&faultEventInfo]() { DELETE_A(faultEventInfo); };
1001	- ScopeGuard faultEventInfoRelease(releaseFunc);
1002	uint32_t eventCount = 0U;	980	uint32_t eventCount = 0U;
1003	- rtError_t error = GetDeviceFaultEvents(deviceId, faultEventInfo, eventCount, maxFaultNum);	981	+ const rtError_t error = GetDeviceFaultEvents(deviceId, &faultEventInfo[0U], eventCount);
1004	if (error != RT_ERROR_NONE) {	982	if (error != RT_ERROR_NONE) {
1005	return false;	983	return false;
1006	}	984	}

Msrc/runtime/core/src/device/raw_device.cc+14-0

	@@ -610,6 +610,7 @@ rtError_t RawDevice::Init()
610	if (error != RT_ERROR_NONE) {	610	if (error != RT_ERROR_NONE) {
611	RT_LOG(RT_LOG_ERROR, "Get phy die id failed!, device_id=%u", deviceId_);	611	RT_LOG(RT_LOG_ERROR, "Get phy die id failed!, device_id=%u", deviceId_);
612	}	612	}
		613	+ SetBaseTime();
613	RT_LOG(RT_LOG_INFO, "Get phy info, phy chip id %" PRId64 ", phy die id %" PRId64, phyChipId_, phyDieId_);	614	RT_LOG(RT_LOG_INFO, "Get phy info, phy chip id %" PRId64 ", phy die id %" PRId64, phyChipId_, phyDieId_);
614	(void)InitTsdQos();	615	(void)InitTsdQos();
615	Runtime::Instance()->SetDisableThread(true);	616	Runtime::Instance()->SetDisableThread(true);
	@@ -2582,5 +2583,18 @@ void RawDevice::FreeFftsPlusArgHandleCache()
2582	fftsPlusArgHandleCache_.clear();	2583	fftsPlusArgHandleCache_.clear();
2583	}	2584	}
2584		2585
		2586	+void RawDevice::SetBaseTime()
		2587	+{
		2588	+ int64_t currTime = 0;
		2589	+ const rtError_t error = driver_->GetDevInfo(deviceId_, MODULE_TYPE_SYSTEM, INFO_TYPE_REAL_TIME, &currTime);
		2590	+ COND_RETURN_VOID((error != RT_ERROR_NONE) && (error != RT_ERROR_FEATURE_NOT_SUPPORT) && (error != RT_ERROR_DRV_INPUT),
		2591	+ "get device time failed, deviceId=%u, retCode=%#x.", deviceId_, static_cast<uint32_t>(error));
		2592	+ if (error != RT_ERROR_NONE) {
		2593	+ return;
		2594	+ }
		2595	+ baseTime_ = currTime;
		2596	+ RT_LOG(RT_LOG_DEBUG, "set device base time %" PRId64, baseTime_.load());
		2597	+}
		2598	+
2585	} // namespace runtime	2599	} // namespace runtime
2586	}	2600	}

Msrc/runtime/core/src/device/raw_device.hpp+7-0

	@@ -414,6 +414,12 @@ public:
414	return phyDieId_;	414	return phyDieId_;
415	}	415	}
416		416
		417	+ int64_t GetBaseTime() const override
		418	+ {
		419	+ return baseTime_;
		420	+ }
		421	+ void SetBaseTime() override;
		422	+
417	Stream *GetNextRecycleStream() override;	423	Stream *GetNextRecycleStream() override;
418	bool AddStreamToMessageQueue(Stream *stm) override;	424	bool AddStreamToMessageQueue(Stream *stm) override;
419	void DelStreamFromMessageQueue(Stream * const stm) override;	425	void DelStreamFromMessageQueue(Stream * const stm) override;
	@@ -966,6 +972,7 @@ private:
966	std::atomic<uint32_t> dmaCpyUsedNum_;	972	std::atomic<uint32_t> dmaCpyUsedNum_;
967	int64_t phyChipId_;	973	int64_t phyChipId_;
968	int64_t phyDieId_;	974	int64_t phyDieId_;
		975	+ std::atomic<int64_t> baseTime_{0}; // device system time after host sync, unit ms
969	uint16_t tsdQos_{0U}; // for aicpu task	976	uint16_t tsdQos_{0U}; // for aicpu task
970	uint64_t *messageQueue_{nullptr};	977	uint64_t *messageQueue_{nullptr};
971	uint16_t messageQueueSize_{STREAM_MESSAGE_QUEUE_SIZE};	978	uint16_t messageQueueSize_{STREAM_MESSAGE_QUEUE_SIZE};

Msrc/runtime/core/src/device/v200_base/device_error_proc_c.cc+31-59

	@@ -380,20 +380,13 @@ void CheckAndPrintRasInfo(const Device * const dev)
380	if (dev == nullptr) {	380	if (dev == nullptr) {
381	return;	381	return;
382	}	382	}
383	-	383	+ std::vector<rtDmsFaultEvent> faultEventInfo(RAS_GET_MAX_NUM, rtDmsFaultEvent{});
384	- constexpr uint32_t maxFaultNum = 128U;	384	+ constexpr size_t totalSize = RAS_GET_MAX_NUM * sizeof(rtDmsFaultEvent);
385	- rtDmsFaultEvent *faultEventInfo = new (std::nothrow)rtDmsFaultEvent[maxFaultNum];
386	- COND_RETURN_VOID_AND_MSG_OUTER(faultEventInfo == nullptr, ErrorCode::EE1013,
387	- maxFaultNum * sizeof(rtDmsFaultEvent), "new");
388	- constexpr size_t totalSize = maxFaultNum * sizeof(rtDmsFaultEvent);
389	- const std::function<void()> releaseFunc = [&faultEventInfo]() { DELETE_A(faultEventInfo); };
390	- ScopeGuard faultEventInfoRelease(releaseFunc);
391	-
392	for (uint32_t queryCount = 0U; queryCount < RAS_QUERY_MAX_COUNT; ++queryCount) {	385	for (uint32_t queryCount = 0U; queryCount < RAS_QUERY_MAX_COUNT; ++queryCount) {
393	- (void)memset_s(faultEventInfo, totalSize, 0, totalSize);	386	+ (void)memset_s(&faultEventInfo[0U], totalSize, 0, totalSize);
394	uint32_t eventCount = 0U;	387	uint32_t eventCount = 0U;
395	- rtError_t error = GetDeviceFaultEvents(dev->Id_(), faultEventInfo, eventCount, maxFaultNum);	388	+ const rtError_t error = GetDeviceFaultEvents(dev->Id_(), &faultEventInfo[0U], eventCount);
396	- if ((error == RT_ERROR_NONE) && PrintRasEvents(dev, faultEventInfo, eventCount)) {	389	+ if ((error == RT_ERROR_NONE) && PrintRasEvents(dev, &faultEventInfo[0U], eventCount)) {
397	return;	390	return;
398	}	391	}
399	std::this_thread::sleep_for(std::chrono::milliseconds(RAS_QUERY_INTERVAL));	392	std::this_thread::sleep_for(std::chrono::milliseconds(RAS_QUERY_INTERVAL));
	@@ -470,21 +463,15 @@ static void AiCoreUnknownErrProc(const Device * const dev, const StarsDeviceErro
470		463
471	static void AixLinkErrProc(const Device * const dev, const StarsDeviceErrorInfo * const info, TaskInfo *errTaskPtr)	464	static void AixLinkErrProc(const Device * const dev, const StarsDeviceErrorInfo * const info, TaskInfo *errTaskPtr)
472	{	465	{
473	- constexpr uint32_t maxFaultNum = 128U;	466	+ std::vector<rtDmsFaultEvent> faultEventInfo(RAS_GET_MAX_NUM, rtDmsFaultEvent{});
474	- rtDmsFaultEvent *faultEventInfo = new (std::nothrow)rtDmsFaultEvent[maxFaultNum];
475	- COND_RETURN_VOID_AND_MSG_OUTER(faultEventInfo == nullptr, ErrorCode::EE1013,
476	- maxFaultNum * sizeof(rtDmsFaultEvent), "new");
477	-
478	- const std::function<void()> releaseFunc = [&faultEventInfo]() { DELETE_A(faultEventInfo); };
479	- ScopeGuard faultEventInfoRelease(releaseFunc);
480	uint32_t eventCount = 0U;	467	uint32_t eventCount = 0U;
481	- rtError_t error = GetDeviceFaultEvents(dev->Id_(), faultEventInfo, eventCount, maxFaultNum);	468	+ const rtError_t error = GetDeviceFaultEvents(dev->Id_(), &faultEventInfo[0U], eventCount);
482	if (error != RT_ERROR_NONE) {	469	if (error != RT_ERROR_NONE) {
483	AiCoreUnknownErrProc(dev, info);	470	AiCoreUnknownErrProc(dev, info);
484	return;	471	return;
485	}	472	}
486		473
487	- if (!IsHitBlacklist(faultEventInfo, eventCount, g_ccuTimeoutEventIdBlkList)) {	474	+ if (!IsHitBlacklist(&faultEventInfo[0U], eventCount, g_ccuTimeoutEventIdBlkList)) {
488	for (uint32_t faultIndex = 0; faultIndex < eventCount; faultIndex++) {	475	for (uint32_t faultIndex = 0; faultIndex < eventCount; faultIndex++) {
489	if (faultEventInfo[faultIndex].eventId == UB_REMOTE_MEM_TIMEOUT_EVENT_ID) {	476	if (faultEventInfo[faultIndex].eventId == UB_REMOTE_MEM_TIMEOUT_EVENT_ID) {
490	errTaskPtr->mte_error = TS_ERROR_LINK_ERROR;	477	errTaskPtr->mte_error = TS_ERROR_LINK_ERROR;
	@@ -503,37 +490,28 @@ static void AixLinkErrProc(const Device * const dev, const StarsDeviceErrorInfo
503	AiCoreUnknownErrProc(dev, info);	490	AiCoreUnknownErrProc(dev, info);
504	}	491	}
505		492
506	-static void GetMteDeviceFaultEvent(	493	+static void GetMteDeviceFaultEvent(const Device* const dev, uint32_t& faultEventId)
507	- const Device* const dev, uint32_t& faultEventId, bool& isHitBlklist, bool& isHitRemoteBlklist, bool& isHitWhitelist)
508	{	494	{
509	- constexpr uint32_t maxFaultNum = 128U;	495	+ std::vector<rtDmsFaultEvent> faultEventInfo(RAS_GET_MAX_NUM, rtDmsFaultEvent{});
510	- rtDmsFaultEvent *faultEventInfo = new (std::nothrow)rtDmsFaultEvent[maxFaultNum];
511	- COND_RETURN_VOID((faultEventInfo == nullptr), "new rtDmsFaultEvent failed.");
512	- constexpr size_t totalSize = maxFaultNum * sizeof(rtDmsFaultEvent);
513	- (void)memset_s(faultEventInfo, totalSize, 0, totalSize);
514	-
515	- const std::function<void()> releaseFunc = [&faultEventInfo]() { DELETE_A(faultEventInfo); };
516	- ScopeGuard faultEventInfoRelease(releaseFunc);
517	uint32_t eventCount = 0U;	496	uint32_t eventCount = 0U;
518	- const rtError_t error = GetDeviceFaultEvents(dev->Id_(), faultEventInfo, eventCount, maxFaultNum);	497	+ const rtError_t error = GetDeviceFaultEvents(dev->Id_(), &faultEventInfo[0U], eventCount);
519	if (error != RT_ERROR_NONE) {	498	if (error != RT_ERROR_NONE) {
520	return;	499	return;
521	}	500	}
522		501
523	- if (IsFaultEventOccur(L2_BUFFER_ECC_EVENT_ID, faultEventInfo, eventCount)) {	502	+ static const EventBlkEntry eventId2BlkList[] = {
524	- isHitBlklist = IsHitBlacklist(faultEventInfo, eventCount, g_l2MulBitEccEventIdBlkList);	503	+ {L2_BUFFER_ECC_EVENT_ID, g_l2MulBitEccEventIdBlkList},
525	- if (!isHitBlklist) {	504	+ {HBM_ECC_NOTIFY_EVENT_ID, g_aicOrSdmaOrHcclLocalMulBitEccEventIdBlkList},
526	- faultEventId = L2_BUFFER_ECC_EVENT_ID;	505	+ {HBM_ECC_EVENT_ID, g_aicOrSdmaOrHcclLocalMulBitEccEventIdBlkList},
		506	+ {UB_REMOTE_MEM_DATA_EXCEPTION_EVENT_ID, g_hcclRemoteMulBitEccEventIdBlkList}
		507	+ };
		508	+ for (const auto &entry : eventId2BlkList) {
		509	+ if (IsFaultEventOccur(entry.eventId, &faultEventInfo[0U], eventCount) &&
		510	+ !IsHitBlacklist(&faultEventInfo[0U], eventCount, entry.blkList)) {
		511	+ faultEventId = entry.eventId;
527	return;	512	return;
528	}	513	}
529	}	514	}
530	-
531	- isHitBlklist = IsHitBlacklist(faultEventInfo, eventCount, g_aicOrSdmaOrHcclLocalMulBitEccEventIdBlkList);
532	- isHitRemoteBlklist = IsHitBlacklist(faultEventInfo, eventCount, g_hcclRemoteMulBitEccEventIdBlkList);
533	- isHitWhitelist = IsFaultEventOccur(UB_REMOTE_MEM_DATA_EXCEPTION_EVENT_ID, faultEventInfo, eventCount);
534	- if (IsFaultEventOccur(HBM_ECC_EVENT_ID, faultEventInfo, eventCount) && !isHitBlklist) {
535	- faultEventId = HBM_ECC_EVENT_ID;
536	- }
537	}	515	}
538		516
539	static void SetTaskMteErrByType(const rtErrorType errType, const Device * const dev, TaskInfo *errTaskPtr)	517	static void SetTaskMteErrByType(const rtErrorType errType, const Device * const dev, TaskInfo *errTaskPtr)
	@@ -546,35 +524,29 @@ static void SetTaskMteErrByType(const rtErrorType errType, const Device * const
546	(RtPtrToUnConstPtr<Device *>(dev))->SetDeviceFaultType(DeviceFaultType::AICORE_UNKNOWN_ERROR);	524	(RtPtrToUnConstPtr<Device *>(dev))->SetDeviceFaultType(DeviceFaultType::AICORE_UNKNOWN_ERROR);
547	}	525	}
548		526
549	- const bool suppHbmRas = (Runtime::Instance()->GetHbmRasProcFlag() != HBM_RAS_NOT_SUPPORT);	527	+ const bool hasHbmEccNotify = HasMteErr(dev);
550	- bool hasMteHbmErr = suppHbmRas ? HasMteErr(dev) : false;
551	-
552	uint32_t faultEventId = 0U;	528	uint32_t faultEventId = 0U;
553	- bool isHitBlklist = false;	529	+ GetMteDeviceFaultEvent(dev, faultEventId);
554	- bool isHitRemoteBlklist = false;
555	- bool isHitWhitelist = false;
556	- GetMteDeviceFaultEvent(dev, faultEventId, isHitBlklist, isHitRemoteBlklist, isHitWhitelist);
557	const bool hasL2BuffEcc = (faultEventId == L2_BUFFER_ECC_EVENT_ID);	530	const bool hasL2BuffEcc = (faultEventId == L2_BUFFER_ECC_EVENT_ID);
558	- const bool hasHbmEcc = (faultEventId == HBM_ECC_EVENT_ID);	531	+ const bool hasHbmEcc = hasHbmEccNotify &&
559	- const bool isHitHbmBlkList = !hasL2BuffEcc && isHitBlklist;	532	+ ((faultEventId == HBM_ECC_NOTIFY_EVENT_ID) \|\| (faultEventId == HBM_ECC_EVENT_ID));
560	- RT_LOG(RT_LOG_ERROR, "support_hbm_ras_report=%d, has_l2_buffer_ecc_event=%d, has_hbm_ecc_notify_event=%d, "	533	+ const bool hasRemoteErr = (faultEventId == UB_REMOTE_MEM_DATA_EXCEPTION_EVENT_ID);
561	- "has_hbm_ecc_event=%d, hit_black_list=%d, hit_remote_blk_list=%d, hit_white_list=%d.", suppHbmRas, hasL2BuffEcc, hasMteHbmErr,	534	+ RT_LOG(RT_LOG_ERROR, "has_hbm_ecc_notify_event=%d, event_id=0x%x, device_id=%u",
562	- hasHbmEcc, isHitBlklist, isHitRemoteBlklist, isHitWhitelist);	535	+ hasHbmEccNotify, faultEventId, dev->Id_());
563		536
564	const uint16_t local_error = (errType == AICORE_ERROR) ? TS_ERROR_AICORE_MTE_ERROR : TS_ERROR_SDMA_POISON_ERROR;	537	const uint16_t local_error = (errType == AICORE_ERROR) ? TS_ERROR_AICORE_MTE_ERROR : TS_ERROR_SDMA_POISON_ERROR;
565	- constexpr uint16_t remote_error = TS_ERROR_SDMA_LINK_ERROR;
566	if (hasL2BuffEcc) {	538	if (hasL2BuffEcc) {
567	errTaskPtr->mte_error = local_error;	539	errTaskPtr->mte_error = local_error;
568	(RtPtrToUnConstPtr<Device *>(dev))->SetDeviceFaultType(DeviceFaultType::L2_BUFFER_ERROR);	540	(RtPtrToUnConstPtr<Device *>(dev))->SetDeviceFaultType(DeviceFaultType::L2_BUFFER_ERROR);
569	return;	541	return;
570	}	542	}
571	- if ((!suppHbmRas && hasHbmEcc) \|\| (hasMteHbmErr && !isHitHbmBlkList)) {	543	+ if (hasHbmEcc) {
572	errTaskPtr->mte_error = local_error;	544	errTaskPtr->mte_error = local_error;
573	(RtPtrToUnConstPtr<Device *>(dev))->SetDeviceFaultType(DeviceFaultType::HBM_UCE_ERROR);	545	(RtPtrToUnConstPtr<Device *>(dev))->SetDeviceFaultType(DeviceFaultType::HBM_UCE_ERROR);
574	return;	546	return;
		atomgit-bot7月11日 🟡 Medium Priority 变更行：`device_error_proc_c.cc` 中 `SetTaskMteErrByType` 函数（第527-547行）。旧代码的 HBM 错误处理有两个入口： `!suppHbmRas && hasHbmEcc`：当 RAS 不支持时，若 HBM_ECC 事件存在则触发 HBM_UCE_ERROR `hasMteHbmErr && !isHitHbmBlkList`：当 RAS 支持时，若 HasMteErr 为真且不在黑名单则触发新代码统一为 `hasHbmEcc = hasHbmEccNotify && (faultEventId == HBM_ECC_NOTIFY_EVENT_ID \|\| faultEventId == HBM_ECC_EVENT_ID)`，即始终要求 `HasMteErr(dev)` 为真。当 `suppHbmRas` 为 false 时，`HasMteErr` 可能返回 false，导致原来能通过 `!suppHbmRas && hasHbmEcc` 路径触发的 HBM_UCE_ERROR 被漏掉。测试变更确认此行为变化：`aicore_task_hw_r_error_mte_error_proc_not_support_ras` 测试被删除，`aicore_task_hw_r_error_not_support_get_fault_event` 期望故障类型从 `HBM_UCE_ERROR` 变为 `AICORE_UNKNOWN_ERROR`。触发条件：当 `hbmRasProcFlag_ == HBM_RAS_NOT_SUPPORT` 且设备上存在 HBM_ECC 事件但 `HasMteErr` 返回 false 时，旧代码会报 HBM_UCE_ERROR，新代码不会。建议：如果移除 !suppHbmRas 路径是有意为之，请确认产品需求上不再需要该路径；否则应在 hasHbmEcc 条件中恢复对 !suppHbmRas 场景的处理，例如：`const bool hasHbmEcc = (hasHbmEccNotify && (...)) \|\| (!suppHbmRas && (faultEventId == HBM_ECC_EVENT_ID));` 并恢复被删除的测试用例。 V vaceciliachen 7月11日评论： 7月11日评论：
575	}	547	}
576	- if (suppHbmRas && !hasMteHbmErr && !isHitRemoteBlklist && isHitWhitelist) {	548	+ if ((errType == AICORE_ERROR) && hasRemoteErr) {
577	- errTaskPtr->mte_error = remote_error;	549	+ errTaskPtr->mte_error = TS_ERROR_REMOTE_MEM_ERROR;
578	(RtPtrToUnConstPtr<Device *>(dev))->SetDeviceFaultType(DeviceFaultType::LINK_ERROR);	550	(RtPtrToUnConstPtr<Device *>(dev))->SetDeviceFaultType(DeviceFaultType::LINK_ERROR);
579	return;	551	return;
		atomgit-bot7月11日 🟡 Medium Priority 变更行：`device_error_proc_c.cc` 中 `SetTaskMteErrByType` 函数第549-552行。旧代码的远程错误处理： if (suppHbmRas && !hasMteHbmErr && !isHitRemoteBlklist && isHitWhitelist) { errTaskPtr->mte_error = remote_error; // TS_ERROR_SDMA_LINK_ERROR 该路径对 ANY errType（AICORE_ERROR 和 SDMA_ERROR）都生效。新代码： if ((errType == AICORE_ERROR) && hasRemoteErr) { errTaskPtr->mte_error = TS_ERROR_REMOTE_MEM_ERROR; 仅对 `errType == AICORE_ERROR` 生效，SDMA_ERROR 不再触发远程错误处理。查看 `SetTaskMteErrByType` 的调用点：AICORE_ERROR 路径（第561行）和 SDMA_ERROR 路径（第743行）。旧代码中 SDMA_ERROR 也可以触发远程错误，新代码不会。触发条件：SDMA 错误 + 远程内存异常事件（UB_REMOTE_MEM_DATA_EXCEPTION_EVENT_ID）存在且不在远程黑名单中时，旧代码会设置 `TS_ERROR_SDMA_LINK_ERROR`，新代码会回退到 `TS_SUCCESS`。建议：如果 SDMA 错误的远程内存异常不再需要处理是有意为之，请确认；否则需要恢复对 SDMA_ERROR 的远程错误处理，例如将条件改为 `hasRemoteErr` 不限制 errType，或为 SDMA_ERROR 增加单独的错误码分支。 V vaceciliachen 7月11日评论： 7月11日评论：
580	}	552	}

Msrc/runtime/core/src/runtime.cc+8-13

	@@ -5074,33 +5074,28 @@ void Runtime::ReportHBMRasProc(void)
5074		5074
5075	void Runtime::ReportUBMemRasProc()	5075	void Runtime::ReportUBMemRasProc()
5076	{	5076	{
5077	- constexpr uint32_t maxFaultNum = 128U;	5077	+ std::vector<rtDmsFaultEvent> faultEventInfo(RAS_GET_MAX_NUM, rtDmsFaultEvent{});
5078	- rtDmsFaultEvent *faultEventInfo = new (std::nothrow)rtDmsFaultEvent[maxFaultNum];
5079	- COND_RETURN_VOID((faultEventInfo == nullptr), "new rtDmsFaultEvent failed.");
5080	- const size_t totalSize = maxFaultNum * sizeof(rtDmsFaultEvent);
5081	- (void)memset_s(faultEventInfo, totalSize, 0, totalSize);
5082	-
5083	- const std::function<void()> releaseFunc = [&faultEventInfo]() { DELETE_A(faultEventInfo); };
5084	- ScopeGuard faultEventInfoRelease(releaseFunc);
5085	-
5086	for (uint32_t devId = 0U; devId < RT_MAX_DEV_NUM; devId++) {	5078	for (uint32_t devId = 0U; devId < RT_MAX_DEV_NUM; devId++) {
5087	Device *dev = GetDevice(devId, 0U, false);	5079	Device *dev = GetDevice(devId, 0U, false);
5088	if (dev == nullptr \|\| dev->IsDeviceRelease()) {	5080	if (dev == nullptr \|\| dev->IsDeviceRelease()) {
5089	continue;	5081	continue;
5090	}	5082	}
5091	uint32_t eventCount = 0U;	5083	uint32_t eventCount = 0U;
5092	- rtError_t error = GetDeviceFaultEvents(devId, faultEventInfo, eventCount, maxFaultNum);	5084	+ const rtError_t error = GetDeviceFaultEvents(devId, &faultEventInfo[0U], eventCount, false);
5093	if (error != RT_ERROR_NONE) {	5085	if (error != RT_ERROR_NONE) {
5094	continue;	5086	continue;
5095	}	5087	}
5096	- ProcUBMemNetworkException(devId, faultEventInfo, eventCount);	5088	+ ProcUBMemNetworkException(devId, &faultEventInfo[0U], eventCount);
5097	}	5089	}
5098	}	5090	}
5099		5091
5100	-void Runtime::ProcUBMemNetworkException(const uint32_t devId, const rtDmsFaultEvent *faultEventInfo, uint32_t eventCount) const	5092	+void Runtime::ProcUBMemNetworkException(const uint32_t devId, const rtDmsFaultEvent *faultEventInfo, uint32_t eventCount)
5101	{	5093	{
		5094	+ static std::array<uint64_t, RT_MAX_DEV_NUM> lastReportTime = {};
5102	for (uint32_t faultIndex = 0U; faultIndex < eventCount; faultIndex++) {	5095	for (uint32_t faultIndex = 0U; faultIndex < eventCount; faultIndex++) {
5103	- if (faultEventInfo[faultIndex].eventId == UB_MEM_NETWORK_EXCEPTION_EVENT_ID) {	5096	+ if ((faultEventInfo[faultIndex].eventId == UB_MEM_NETWORK_EXCEPTION_EVENT_ID) &&
		5097	+ (faultEventInfo[faultIndex].alarmRaisedTime > lastReportTime[devId])) {
		5098	+ lastReportTime[devId] = faultEventInfo[faultIndex].alarmRaisedTime;
5104	if (ContextManage::DeviceSetFaultTypeIfNoError(devId, DeviceFaultType::L3_PORT_ERROR)) {	5099	if (ContextManage::DeviceSetFaultTypeIfNoError(devId, DeviceFaultType::L3_PORT_ERROR)) {
5105	ContextManage::SetGlobalFailureErr(devId, RT_ERROR_L3_PORT_ERROR);	5100	ContextManage::SetGlobalFailureErr(devId, RT_ERROR_L3_PORT_ERROR);
5106	RT_LOG(RT_LOG_INFO, "set fault type for ub mem, device id=%u, event id=0x%x.",	5101	RT_LOG(RT_LOG_INFO, "set fault type for ub mem, device id=%u, event id=0x%x.",

Msrc/runtime/core/src/task/task_info/model/model_execute_task.cc+3-1

	@@ -32,7 +32,9 @@ namespace {
32	const std::set<int32_t> MEM_ERROR_CODE = {TS_ERROR_AICORE_MTE_ERROR,	32	const std::set<int32_t> MEM_ERROR_CODE = {TS_ERROR_AICORE_MTE_ERROR,
33	TS_ERROR_SDMA_LINK_ERROR,	33	TS_ERROR_SDMA_LINK_ERROR,
34	TS_ERROR_SDMA_POISON_ERROR,	34	TS_ERROR_SDMA_POISON_ERROR,
35	- TS_ERROR_LINK_ERROR};	35	+ TS_ERROR_LINK_ERROR,
		36	+ TS_ERROR_LOCAL_MEM_ERROR,
		37	+ TS_ERROR_REMOTE_MEM_ERROR};
36	} // namespace	38	} // namespace
37	#if F_DESC("ModelExecuteTask")	39	#if F_DESC("ModelExecuteTask")
38		40

Msrc/runtime/driver/npu_driver.cc+2-0

	@@ -489,6 +489,8 @@ rtError_t NpuDriver::GetDevInfo(const uint32_t deviceId, const int32_t moduleTyp
489	if (drvRet != DRV_ERROR_NONE) {	489	if (drvRet != DRV_ERROR_NONE) {
490	if (moduleType == MODULE_TYPE_VECTOR_CORE) {	490	if (moduleType == MODULE_TYPE_VECTOR_CORE) {
491	(*val) = 0;	491	(*val) = 0;
		492	+ } else if (infoType == INFO_TYPE_REAL_TIME) {
		493	+ return RT_GET_DRV_ERRCODE(drvRet);
492	} else {	494	} else {
493	COND_RETURN_WARN(drvRet == DRV_ERROR_NOT_SUPPORT, RT_ERROR_FEATURE_NOT_SUPPORT,	495	COND_RETURN_WARN(drvRet == DRV_ERROR_NOT_SUPPORT, RT_ERROR_FEATURE_NOT_SUPPORT,
494	"[drv api] halGetDeviceInfo does not support.");	496	"[drv api] halGetDeviceInfo does not support.");

Msrc/runtime/driver/npu_driver.hpp+2-2

	@@ -639,8 +639,8 @@ public:
639	static rtError_t MemQEventCrossDevSupported(int32_t * const isSupported);	639	static rtError_t MemQEventCrossDevSupported(int32_t * const isSupported);
640	static rtError_t GetFaultEvent(const int32_t deviceId, const rtDmsEventFilter * const filter, rtDmsFaultEvent *dmsEvent,	640	static rtError_t GetFaultEvent(const int32_t deviceId, const rtDmsEventFilter * const filter, rtDmsFaultEvent *dmsEvent,
641	uint32_t len, uint32_t *eventCount);	641	uint32_t len, uint32_t *eventCount);
642	- static rtError_t GetAllFaultEvent(const uint32_t deviceId, rtDmsFaultEvent * const dmsEvent,	642	+ static rtError_t GetAllFaultEvent(const uint32_t deviceId, rtDmsFaultEvent * const dmsEvent, uint32_t *eventCount,
643	- uint32_t len, uint32_t *eventCount);	643	+ bool needLog = true);
644	static rtError_t ReadFaultEvent(	644	static rtError_t ReadFaultEvent(
645	const int32_t deviceId, uint32_t timeout, const rtDmsEventFilter * const filter, rtDmsFaultEvent *dmsEvent);	645	const int32_t deviceId, uint32_t timeout, const rtDmsEventFilter * const filter, rtDmsFaultEvent *dmsEvent);
646	static rtError_t GetRasSyscnt(const uint32_t deviceId, RtHbmRasInfo *hbmRasInfo);	646	static rtError_t GetRasSyscnt(const uint32_t deviceId, RtHbmRasInfo *hbmRasInfo);

Msrc/runtime/driver/npu_driver_base.hpp+4-2

	@@ -115,8 +115,10 @@ drvError_t __attribute__((weak)) halShrIdSetAttribute(const char *name, enum shr
115	drvError_t __attribute__((weak)) halShrIdInfoGet(const char name, struct shrIdGetInfo info);	115	drvError_t __attribute__((weak)) halShrIdInfoGet(const char name, struct shrIdGetInfo info);
116	drvError_t __attribute__((weak)) halGetFaultEvent(uint32_t devId, struct halEventFilter *filter,	116	drvError_t __attribute__((weak)) halGetFaultEvent(uint32_t devId, struct halEventFilter *filter,
117	struct halFaultEventInfo eventInfo, uint32_t len, uint32_t eventCount);	117	struct halFaultEventInfo eventInfo, uint32_t len, uint32_t eventCount);
118	-drvError_t __attribute__((weak)) halGetDeviceInfoByBuff(uint32_t devId, int moduleType,	118	+drvError_t __attribute__((weak)) halGetNotifyEvent(uint32_t devId, struct halEventFilter *filter,
119	- int infoType, void buf, int32_t size);	119	+ struct halFaultEventInfo eventInfo, uint32_t len, uint32_t eventCount);
		120	+drvError_t __attribute__((weak)) halGetDeviceInfoByBuff(uint32_t devId, int32_t moduleType,
		121	+ int32_t infoType, void buf, int32_t size);
120	drvError_t __attribute__((weak)) halSetDeviceInfoByBuff(uint32_t devId, int32_t moduleType,	122	drvError_t __attribute__((weak)) halSetDeviceInfoByBuff(uint32_t devId, int32_t moduleType,
121	int32_t infoType, void *buf, int32_t size);	123	int32_t infoType, void *buf, int32_t size);
122	drvError_t __attribute__((weak)) halRepairFault(uint32_t devid, halRepairFaultInfo *info);	124	drvError_t __attribute__((weak)) halRepairFault(uint32_t devid, halRepairFaultInfo *info);

Msrc/runtime/driver/npu_driver_res.cc+77-31

	@@ -20,52 +20,98 @@ namespace runtime {
20	constexpr uint32_t GET_SQ_HEAD_MAX_RETRY_TIMES = 100U;	20	constexpr uint32_t GET_SQ_HEAD_MAX_RETRY_TIMES = 100U;
21	constexpr uint32_t GET_SQ_HEAD_QUERY_FAIL_STAT_TIMES = 1000U;	21	constexpr uint32_t GET_SQ_HEAD_QUERY_FAIL_STAT_TIMES = 1000U;
22		22
23	-rtError_t NpuDriver::GetFaultEvent(const int32_t deviceId, const rtDmsEventFilter * const filter,	23	+static rtError_t GetFaultEvents(const uint32_t deviceId, const rtDmsEventFilter * const filter,
24	- rtDmsFaultEvent dmsEvent, uint32_t len, uint32_t eventCount)	24	+ rtDmsFaultEvent dmsEvent, uint32_t len, uint32_t eventCount)
25	{	25	{
26	drvError_t drvRet = DRV_ERROR_NONE;	26	drvError_t drvRet = DRV_ERROR_NONE;
27		27
28	COND_RETURN_WARN(&halGetFaultEvent == nullptr, RT_ERROR_FEATURE_NOT_SUPPORT,	28	COND_RETURN_WARN(&halGetFaultEvent == nullptr, RT_ERROR_FEATURE_NOT_SUPPORT,
29	"[drv api] halGetFaultEvent does not exist");	29	"[drv api] halGetFaultEvent does not exist");
30	struct halEventFilter dmsFilter = {};	30	struct halEventFilter dmsFilter = {};
31	- dmsFilter.filter_flag = static_cast<uint64_t>(RT_DSM_EVENT_FILTER_FLAG_PID);	31	+ if (filter != nullptr) {
32	- dmsFilter.event_id = filter->eventId;	32	+ dmsFilter.filter_flag = static_cast<uint64_t>(RT_DSM_EVENT_FILTER_FLAG_PID);
33	- dmsFilter.severity = filter->severity;	33	+ dmsFilter.event_id = filter->eventId;
34	- dmsFilter.node_type = filter->nodeType;	34	+ dmsFilter.severity = filter->severity;
35	- RT_LOG(RT_LOG_INFO, "get fault event, drv devId=%d, filterFlag=%llu, outputLen=%u.",	35	+ dmsFilter.node_type = filter->nodeType;
36	- deviceId, dmsFilter.filter_flag, len);	36	+ RT_LOG(RT_LOG_INFO, "get fault event, drv devId=%u, eventId=%#x, filterFlag=%llu, outputLen=%u.",
37	- drvRet = halGetFaultEvent(static_cast<uint32_t>(deviceId), &dmsFilter,	37	+ deviceId, dmsFilter.event_id, dmsFilter.filter_flag, len);
38	- RtPtrToPtr<halFaultEventInfo *>(dmsEvent), len, eventCount);	38	+ } else {
39	-	39	+ dmsFilter.filter_flag = 0ULL;
40	- COND_RETURN_WARN(drvRet == DRV_ERROR_NOT_SUPPORT, RT_ERROR_FEATURE_NOT_SUPPORT,
41	- "[drv api] halGetFaultEvent does not support.");
42	- if (drvRet != DRV_ERROR_NONE) {
43	- DRV_ERROR_PROCESS(drvRet, "Call driver api halGetFaultEvent failed, drvRetCode=%d, drvDevId=%d.",
44	- static_cast<int32_t>(drvRet), deviceId);
45	}	40	}
		41	+ drvRet = halGetFaultEvent(deviceId, &dmsFilter, RtPtrToPtr<halFaultEventInfo *>(dmsEvent), len, eventCount);
46		42
47	- return RT_GET_DRV_ERRCODE(drvRet);
48	-}
49	-
50	-rtError_t NpuDriver::GetAllFaultEvent(const uint32_t deviceId, rtDmsFaultEvent * const dmsEvent,
51	- uint32_t len, uint32_t *eventCount)
52	-{
53	- drvError_t drvRet = DRV_ERROR_NONE;
54	-
55	- COND_RETURN_WARN(&halGetFaultEvent == nullptr, RT_ERROR_FEATURE_NOT_SUPPORT,
56	- "[drv api] halGetFaultEvent does not exist");
57	- struct halEventFilter dmsFilter = {};
58	- dmsFilter.filter_flag = 0U;
59	- drvRet = halGetFaultEvent(deviceId, &dmsFilter,
60	- RtPtrToPtr<halFaultEventInfo *>(dmsEvent), len, eventCount);
61	COND_RETURN_WARN(drvRet == DRV_ERROR_NOT_SUPPORT, RT_ERROR_FEATURE_NOT_SUPPORT,	43	COND_RETURN_WARN(drvRet == DRV_ERROR_NOT_SUPPORT, RT_ERROR_FEATURE_NOT_SUPPORT,
62	"[drv api] halGetFaultEvent does not support.");	44	"[drv api] halGetFaultEvent does not support.");
63	DRV_PROCESS_ERROR_RETURN(drvRet, "Call driver api halGetFaultEvent failed, drvRetCode=%d, drvDevId=%u, len=%u, flag=%llu.",	45	DRV_PROCESS_ERROR_RETURN(drvRet, "Call driver api halGetFaultEvent failed, drvRetCode=%d, drvDevId=%u, len=%u, flag=%llu.",
64	- static_cast<int32_t>(drvRet), deviceId, len, dmsFilter.filter_flag);	46	+ static_cast<int32_t>(drvRet), deviceId, len, dmsFilter.filter_flag);
65		47
66	return RT_ERROR_NONE;	48	return RT_ERROR_NONE;
67	}	49	}
68		50
		51	+static rtError_t GetNotifyEvents(const uint32_t deviceId, const rtDmsEventFilter * const filter,
		52	+ rtDmsFaultEvent dmsEvent, uint32_t len, uint32_t eventCount)
		53	+{
		54	+ UNUSED(filter);
		55	+ drvError_t drvRet = DRV_ERROR_NONE;
		56	+ struct halEventFilter dmsFilter = {};
		57	+ dmsFilter.filter_flag = 0ULL;
		58	+ drvRet = halGetNotifyEvent(deviceId, &dmsFilter, RtPtrToPtr<halFaultEventInfo *>(dmsEvent), len, eventCount);
		59	+
		60	+ COND_RETURN_WARN(drvRet == DRV_ERROR_NOT_SUPPORT, RT_ERROR_FEATURE_NOT_SUPPORT,
		61	+ "[drv api] halGetNotifyEvent does not support.");
		62	+ DRV_PROCESS_ERROR_RETURN(drvRet, "Call driver api halGetNotifyEvent failed, drvRetCode=%d, drvDevId=%u, len=%u, flag=%llu.",
		63	+ static_cast<int32_t>(drvRet), deviceId, len, dmsFilter.filter_flag);
		64	+
		65	+ return RT_ERROR_NONE;
		66	+}
		67	+
		68	+static rtError_t GetEventsWithTimeCheck(const uint32_t deviceId, const rtDmsEventFilter * const filter,
		69	+ rtDmsFaultEvent dmsEvent, uint32_t eventCount, bool needLog)
		70	+{
		71	+ rtError_t error = RT_ERROR_NONE;
		72	+ uint32_t faultEvtCnt = 0U;
		73	+ uint32_t notifyEvtCnt = 0U;
		74	+ error = GetFaultEvents(deviceId, filter, dmsEvent, RAS_GET_MAX_NUM_SI, &faultEvtCnt);
		75	+ COND_RETURN_ERROR((faultEvtCnt > RAS_GET_MAX_NUM_SI), (error == RT_ERROR_NONE) ? RT_ERROR_DRV_ERR : error,
		76	+ "Get fault event error, device_id=%u, eventCount=%u, maxFaultNum=%u, error=%#x.",
		77	+ deviceId, faultEvtCnt, RAS_GET_MAX_NUM_SI, static_cast<uint32_t>(error));
		78	+ COND_RETURN_WITH_NOLOG(error != RT_ERROR_NONE, error);
		79	+ error = GetNotifyEvents(deviceId, filter, dmsEvent + faultEvtCnt, RAS_GET_MAX_NUM_SI, &notifyEvtCnt);
		80	+ COND_RETURN_WITH_NOLOG(error != RT_ERROR_NONE, error);
		81	+ *eventCount = faultEvtCnt + notifyEvtCnt;
		82	+ int64_t devBaseTime = 0;
		83	+ Device * const dev = Runtime::Instance()->GetDevice(deviceId, 0U, false);
		84	+ if (dev != nullptr) {
		85	+ devBaseTime = dev->GetBaseTime();
		86	+ }
		87	+ COND_RETURN_WITH_NOLOG(devBaseTime == 0, RT_ERROR_NONE);
		88	+ for (uint32_t faultIndex = 0U; faultIndex < *eventCount; ++faultIndex) {
		89	+ if (dmsEvent[faultIndex].alarmRaisedTime < static_cast<uint64_t>(devBaseTime)) {
		90	+ if (needLog) {
		91	+ RT_LOG(RT_LOG_DEBUG, "skip historical event_id=0x%x, event_time=%llu, base_time=%lld, device_id=%u.",
		92	+ dmsEvent[faultIndex].eventId, dmsEvent[faultIndex].alarmRaisedTime, devBaseTime, deviceId);
		93	+ }
		94	+ dmsEvent[faultIndex].eventId = 0U;
		95	+ }
		96	+ }
		97	+ return RT_ERROR_NONE;
		98	+}
		99	+
		100	+rtError_t NpuDriver::GetFaultEvent(const int32_t deviceId, const rtDmsEventFilter * const filter,
		101	+ rtDmsFaultEvent dmsEvent, uint32_t len, uint32_t eventCount)
		102	+{
		103	+ return GetFaultEvents(static_cast<uint32_t>(deviceId), filter, dmsEvent, len, eventCount);
		104	+}
		105	+
		106	+rtError_t NpuDriver::GetAllFaultEvent(const uint32_t deviceId, rtDmsFaultEvent * const dmsEvent, uint32_t *eventCount,
		107	+ bool needLog)
		108	+{
		109	+ if (&halGetNotifyEvent != nullptr) {
		110	+ return GetEventsWithTimeCheck(deviceId, nullptr, dmsEvent, eventCount, needLog);
		111	+ }
		112	+ return GetFaultEvents(deviceId, nullptr, dmsEvent, RAS_GET_MAX_NUM_SI, eventCount);
		113	+}
		114	+
69	rtError_t NpuDriver::ReadFaultEvent(	115	rtError_t NpuDriver::ReadFaultEvent(
70	const int32_t deviceId, uint32_t timeout, const rtDmsEventFilter * const filter, rtDmsFaultEvent *dmsEvent)	116	const int32_t deviceId, uint32_t timeout, const rtDmsEventFilter * const filter, rtDmsFaultEvent *dmsEvent)
71	{	117	{

Msrc/runtime/driver/npu_driver_win.cc+3-3

	@@ -727,13 +727,13 @@ rtError_t NpuDriver::GetFaultEvent(const int32_t deviceId, const rtDmsEventFilte
727	return RT_ERROR_NONE;	727	return RT_ERROR_NONE;
728	}	728	}
729		729
730	-rtError_t NpuDriver::GetAllFaultEvent(const uint32_t deviceId, rtDmsFaultEvent * const dmsEvent,	730	+rtError_t NpuDriver::GetAllFaultEvent(const uint32_t deviceId, rtDmsFaultEvent * const dmsEvent, uint32_t *eventCount,
731	- uint32_t len, uint32_t *eventCount)	731	+ bool needLog)
732	{	732	{
733	UNUSED(deviceId);	733	UNUSED(deviceId);
734	UNUSED(dmsEvent);	734	UNUSED(dmsEvent);
735	- UNUSED(len);
736	UNUSED(eventCount);	735	UNUSED(eventCount);
		736	+ UNUSED(needLog);
737	return RT_ERROR_NONE;	737	return RT_ERROR_NONE;
738	}	738	}
739		739

Msrc/runtime/feature/ccu/ccu_device_error_proc.cc+2-2

	@@ -128,7 +128,7 @@ static void MapCcuErrorCodeForFastRecovery(const uint8_t status, const uint8_t s
128	if (!hasMteErr && !HasMemUceErr(device, g_hcclRemoteMulBitEccEventIdBlkList)) {	128	if (!hasMteErr && !HasMemUceErr(device, g_hcclRemoteMulBitEccEventIdBlkList)) {
129	taskInfo->mte_error = TS_ERROR_REMOTE_MEM_ERROR;	129	taskInfo->mte_error = TS_ERROR_REMOTE_MEM_ERROR;
130	RT_LOG(RT_LOG_ERROR,	130	RT_LOG(RT_LOG_ERROR,
131	- "CCU Launch remote HBM UCE fault occurred: device_id=%u, stream_id=%d, task_id=%hu, retCode=%u",	131	+ "CCU Launch remote memory fault occurred: device_id=%u, stream_id=%d, task_id=%hu, retCode=%hu",
132	devId, taskInfo->stream->Id_(), taskInfo->id, taskInfo->mte_error);	132	devId, taskInfo->stream->Id_(), taskInfo->id, taskInfo->mte_error);
133	}	133	}
134	} else if (status == CCU_TASK_LINK_ERROR) {	134	} else if (status == CCU_TASK_LINK_ERROR) {
	@@ -166,7 +166,7 @@ static void MapFusionCcuErrorCodeForFastRecovery(const uint8_t ccuStatus, const
166	if (!hasMteErr && !HasMemUceErr(device, g_hcclRemoteMulBitEccEventIdBlkList)) {	166	if (!hasMteErr && !HasMemUceErr(device, g_hcclRemoteMulBitEccEventIdBlkList)) {
167	taskInfo->mte_error = TS_ERROR_REMOTE_MEM_ERROR;	167	taskInfo->mte_error = TS_ERROR_REMOTE_MEM_ERROR;
168	RT_LOG(RT_LOG_ERROR,	168	RT_LOG(RT_LOG_ERROR,
169	- "fusion CCU Launch remote HBM UCE fault occurred: device_id=%u, stream_id=%d, task_id=%hu, retCode=%u",	169	+ "fusion CCU Launch remote memory fault occurred: device_id=%u, stream_id=%d, task_id=%hu, retCode=%hu",
170	devId, taskInfo->stream->Id_(), taskInfo->id, taskInfo->mte_error);	170	devId, taskInfo->stream->Id_(), taskInfo->id, taskInfo->mte_error);
171	}	171	}
172	} else if (ccuStatus == CCU_TASK_LINK_ERROR) {	172	} else if (ccuStatus == CCU_TASK_LINK_ERROR) {

Mtests/ut/runtime/runtime/test/platform/950/rt_utest_david.cc+20-32

	@@ -1190,8 +1190,10 @@ TEST_F(DavidTaskTest, construct_davidsqe_for_common_task)
1190	}	1190	}
1191		1191
1192	static rtError_t StubGetDeviceFaultEventsWithRasEvent(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo,	1192	static rtError_t StubGetDeviceFaultEventsWithRasEvent(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo,
1193	- uint32_t &eventCount, const uint32_t maxFaultNum)	1193	+ uint32_t &eventCount, bool needLog)
1194	{	1194	{
		1195	+ UNUSED(deviceId);
		1196	+ UNUSED(needLog);
1195	if (faultEventInfo == nullptr) {	1197	if (faultEventInfo == nullptr) {
1196	return RT_ERROR_INVALID_VALUE;	1198	return RT_ERROR_INVALID_VALUE;
1197	}	1199	}
	@@ -1205,8 +1207,10 @@ static rtError_t StubGetDeviceFaultEventsWithRasEvent(const uint32_t deviceId, r
1205	}	1207	}
1206		1208
1207	static rtError_t StubGetDeviceFaultEventsWithoutRasEvent(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo,	1209	static rtError_t StubGetDeviceFaultEventsWithoutRasEvent(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo,
1208	- uint32_t &eventCount, const uint32_t maxFaultNum)	1210	+ uint32_t &eventCount, bool needLog)
1209	{	1211	{
		1212	+ UNUSED(deviceId);
		1213	+ UNUSED(needLog);
1210	if (faultEventInfo == nullptr) {	1214	if (faultEventInfo == nullptr) {
1211	return RT_ERROR_INVALID_VALUE;	1215	return RT_ERROR_INVALID_VALUE;
1212	}	1216	}
	@@ -1239,14 +1243,22 @@ TEST_F(DavidTaskTest, CheckAndPrintRasInfo_without_ras_event)
1239	}	1243	}
1240		1244
1241	static rtError_t StubGetDeviceFaultEventsError(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo,	1245	static rtError_t StubGetDeviceFaultEventsError(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo,
1242	- uint32_t &eventCount, const uint32_t maxFaultNum)	1246	+ uint32_t &eventCount, bool needLog)
1243	{	1247	{
		1248	+ UNUSED(deviceId);
		1249	+ UNUSED(faultEventInfo);
		1250	+ UNUSED(eventCount);
		1251	+ UNUSED(needLog);
1244	return RT_ERROR_DRV_ERR;	1252	return RT_ERROR_DRV_ERR;
1245	}	1253	}
1246		1254
1247	static rtError_t StubGetDeviceFaultEventsFeatureNotSupported(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo,	1255	static rtError_t StubGetDeviceFaultEventsFeatureNotSupported(const uint32_t deviceId, rtDmsFaultEvent * const faultEventInfo,
1248	- uint32_t &eventCount, const uint32_t maxFaultNum)	1256	+ uint32_t &eventCount, bool needLog)
1249	{	1257	{
		1258	+ UNUSED(deviceId);
		1259	+ UNUSED(faultEventInfo);
		1260	+ UNUSED(eventCount);
		1261	+ UNUSED(needLog);
1250	return RT_ERROR_FEATURE_NOT_SUPPORT;	1262	return RT_ERROR_FEATURE_NOT_SUPPORT;
1251	}	1263	}
1252		1264
	@@ -2218,7 +2230,6 @@ TEST_F(DavidTaskTest, aic_task_hw_r_error_proc_for_fusion)
2218	delete errorProc;	2230	delete errorProc;
2219	}	2231	}
2220		2232
2221	-
2222	extern int32_t faultEventFlag;	2233	extern int32_t faultEventFlag;
2223	TEST_F(DavidTaskTest, aic_task_hw_l_error_proc_for_fusion)	2234	TEST_F(DavidTaskTest, aic_task_hw_l_error_proc_for_fusion)
2224	{	2235	{
	@@ -2671,7 +2682,7 @@ TEST_F(DavidTaskTest, aicore_task_hw_r_error_not_support_get_fault_event)
2671	faultEventFlag = 0;	2682	faultEventFlag = 0;
2672	EXPECT_EQ(ret, RT_ERROR_NONE);	2683	EXPECT_EQ(ret, RT_ERROR_NONE);
2673	const DeviceFaultType faultType = dev_->GetDeviceFaultType();	2684	const DeviceFaultType faultType = dev_->GetDeviceFaultType();
2674	- EXPECT_EQ(faultType, DeviceFaultType::HBM_UCE_ERROR);	2685	+ EXPECT_EQ(faultType, DeviceFaultType::AICORE_UNKNOWN_ERROR);
2675	GlobalMockObject::verify();	2686	GlobalMockObject::verify();
2676	delete errorProc;	2687	delete errorProc;
2677	}	2688	}
	@@ -2702,7 +2713,6 @@ TEST_F(DavidTaskTest, aicore_task_hw_r_error_mte_error_proc)
2702	StarsDeviceErrorInfo errorInfo = {};	2713	StarsDeviceErrorInfo errorInfo = {};
2703	errorInfo.u.coreErrorInfo.comm.flag = static_cast<uint8_t>(AixErrClass::AIX_MTE_POISON_ERROR);	2714	errorInfo.u.coreErrorInfo.comm.flag = static_cast<uint8_t>(AixErrClass::AIX_MTE_POISON_ERROR);
2704	TaskInfo task = {};	2715	TaskInfo task = {};
2705	- uint32_t val = 0x100U;
2706	task.type = TS_TASK_TYPE_KERNEL_AICORE;	2716	task.type = TS_TASK_TYPE_KERNEL_AICORE;
2707	InitByStream(&task, stream_);	2717	InitByStream(&task, stream_);
2708	MOCKER(GetTaskInfo).stubs().will(returnValue(&task));	2718	MOCKER(GetTaskInfo).stubs().will(returnValue(&task));
	@@ -2718,29 +2728,6 @@ TEST_F(DavidTaskTest, aicore_task_hw_r_error_mte_error_proc)
2718	delete errorProc;	2728	delete errorProc;
2719	}	2729	}
2720		2730
2721	-TEST_F(DavidTaskTest, aicore_task_hw_r_error_mte_error_proc_not_support_ras)
2722	-{
2723	- DeviceErrorProc *errorProc = new DeviceErrorProc(dev_);
2724	- StarsDeviceErrorInfo errorInfo = {};
2725	- errorInfo.u.coreErrorInfo.comm.flag = static_cast<uint8_t>(AixErrClass::AIX_MTE_POISON_ERROR);
2726	- TaskInfo task = {};
2727	- task.type = TS_TASK_TYPE_KERNEL_AICORE;
2728	- InitByStream(&task, stream_);
2729	- MOCKER(GetTaskInfo).stubs().will(returnValue(&task));
2730	- Runtime::Instance()->hbmRasProcFlag_ = HBM_RAS_NOT_SUPPORT;
2731	- dev_->SetDeviceRas(true);
2732	- faultEventFlag = 1;
2733	- rtError_t ret = ProcessDavidStarsCoreErrorInfo(&errorInfo, 0, dev_, nullptr);
2734	- faultEventFlag = 0;
2735	- Runtime::Instance()->hbmRasProcFlag_ = HBM_RAS_WORKING;
2736	- EXPECT_EQ(ret, RT_ERROR_NONE);
2737	- const DeviceFaultType faultType = dev_->GetDeviceFaultType();
2738	- EXPECT_EQ(faultType, DeviceFaultType::AICORE_UNKNOWN_ERROR);
2739	- dev_->SetDeviceFaultType(DeviceFaultType::NO_ERROR);
2740	- GlobalMockObject::verify();
2741	- delete errorProc;
2742	-}
2743	-
2744	TEST_F(DavidTaskTest, ProcessStarsSdmaErrorInfoNotSupportRas)	2731	TEST_F(DavidTaskTest, ProcessStarsSdmaErrorInfoNotSupportRas)
2745	{	2732	{
2746	DeviceErrorProc *errorProc = new DeviceErrorProc(dev_);	2733	DeviceErrorProc *errorProc = new DeviceErrorProc(dev_);
	@@ -2760,7 +2747,8 @@ TEST_F(DavidTaskTest, ProcessStarsSdmaErrorInfoNotSupportRas)
2760	Runtime::Instance()->hbmRasProcFlag_ = HBM_RAS_WORKING;	2747	Runtime::Instance()->hbmRasProcFlag_ = HBM_RAS_WORKING;
2761	EXPECT_EQ(ret, RT_ERROR_NONE);	2748	EXPECT_EQ(ret, RT_ERROR_NONE);
2762	const DeviceFaultType faultType = dev_->GetDeviceFaultType();	2749	const DeviceFaultType faultType = dev_->GetDeviceFaultType();
2763	- EXPECT_EQ(faultType, DeviceFaultType::NO_ERROR);	2750	+ EXPECT_EQ(faultType, DeviceFaultType::HBM_UCE_ERROR);
		2751	+ dev_->SetDeviceFaultType(DeviceFaultType::NO_ERROR);
2764	GlobalMockObject::verify();	2752	GlobalMockObject::verify();
2765	delete errorProc;	2753	delete errorProc;
2766	}	2754	}
	@@ -2827,7 +2815,7 @@ TEST_F(DavidTaskTest, ProcessStarsSdmaErrorInfoSupportRasAndNotSupportGetFaultEv
2827	faultEventFlag = 0;	2815	faultEventFlag = 0;
2828	EXPECT_EQ(ret, RT_ERROR_NONE);	2816	EXPECT_EQ(ret, RT_ERROR_NONE);
2829	const DeviceFaultType faultType = dev_->GetDeviceFaultType();	2817	const DeviceFaultType faultType = dev_->GetDeviceFaultType();
2830	- EXPECT_EQ(faultType, DeviceFaultType::HBM_UCE_ERROR);	2818	+ EXPECT_EQ(faultType, DeviceFaultType::NO_ERROR);
2831	GlobalMockObject::verify();	2819	GlobalMockObject::verify();
2832	delete errorProc;	2820	delete errorProc;
2833	}	2821	}

Mtests/ut/runtime/runtime/test/platform/950/rt_utest_david_task.cc+2-1

	@@ -1354,7 +1354,8 @@ TEST_F(TaskTestDavid, SetStarsResultForHcclUbDdrcDavinciTask)
1354	faultEventFlag = 9;	1354	faultEventFlag = 9;
1355	StarsV2SetStarsResultForDavinciTask(&taskInfo, logicCq);	1355	StarsV2SetStarsResultForDavinciTask(&taskInfo, logicCq);
1356	EXPECT_EQ(taskInfo.errorCode, TS_ERROR_AICPU_EXCEPTION);	1356	EXPECT_EQ(taskInfo.errorCode, TS_ERROR_AICPU_EXCEPTION);
1357	-	1357	+
		1358	+ taskInfo.stream->Device_()->SetDeviceRas(false);
1358	logicCq.errorCode = static_cast<uint32_t>(AICPU_HCCL_OP_UB_DDRC_FAILED) << RT_AICPU_ERROR_CODE_BIT_MOVE;	1359	logicCq.errorCode = static_cast<uint32_t>(AICPU_HCCL_OP_UB_DDRC_FAILED) << RT_AICPU_ERROR_CODE_BIT_MOVE;
1359	faultEventFlag = 0;	1360	faultEventFlag = 0;
1360	StarsV2SetStarsResultForDavinciTask(&taskInfo, logicCq);	1361	StarsV2SetStarsResultForDavinciTask(&taskInfo, logicCq);

Mtests/ut/runtime/runtime/test/platform/950/stub/hal_stub.cc+10-1

	@@ -157,7 +157,8 @@ drvError_t halGetFaultEvent(uint32_t devId, struct halEventFilter* filter,
157	}	157	}
158	if (faultEventFlag == 9) { // UB Dispatch Input Error, in g_aicOrSdmaOrHcclLocalMulBitEccEventIdBlkList	158	if (faultEventFlag == 9) { // UB Dispatch Input Error, in g_aicOrSdmaOrHcclLocalMulBitEccEventIdBlkList
159	*eventCount = 1;	159	*eventCount = 1;
160	- eventInfo[0].event_id = 0x81B58002U;	160	+ eventInfo[0].event_id = 0x81B58002U;
		161	+ eventInfo[0].alarm_raised_time = 0x1000ULL;
161	return DRV_ERROR_NONE;	162	return DRV_ERROR_NONE;
162	}	163	}
163	*eventCount = 1;	164	*eventCount = 1;
	@@ -165,6 +166,14 @@ drvError_t halGetFaultEvent(uint32_t devId, struct halEventFilter* filter,
165	return DRV_ERROR_NONE;	166	return DRV_ERROR_NONE;
166	}	167	}
167		168
		169	+drvError_t halGetNotifyEvent(uint32_t devId, struct halEventFilter* filter,
		170	+ struct halFaultEventInfo* eventInfo, uint32_t len, uint32_t *eventCount)
		171	+{
		172	+ *eventCount = 1;
		173	+ eventInfo[0].event_id = 0x80E18400U; // HBM_ECC_NOTIFY_EVENT_ID
		174	+ return DRV_ERROR_NONE;
		175	+}
		176	+
168	int32_t l2_buffer_error_resume_cnt = 0;	177	int32_t l2_buffer_error_resume_cnt = 0;
169	drvError_t halGetDeviceInfoByBuff(uint32_t devId, int32_t moduleType, int32_t infoType, void buf, int32_t size)	178	drvError_t halGetDeviceInfoByBuff(uint32_t devId, int32_t moduleType, int32_t infoType, void buf, int32_t size)
170	{	179	{